10スレッドを使用して配列を処理する

Question

私はJavaのスキルを向上させるために取り組んでいますが、このマルチスレッドアプリケーションの処理方法は少し不明です。基本的に、プログラムはテキストファイルを読み込み、最大の番号を見つけます。私は10スレッドを作成するために私の検索アルゴリズム内のforループを追加しましたが、実際に10スレッドを作成しているかどうかはわかりません。アイデアは、実行時間を改善することです。少なくとも、それは私が想定していることです。とにかく、私はそれを正しくしたかどうか、実行時間が本当に改善されているかどうかを確認する必要はありますか？

import java.io.BufferedReader; 
import java.io.FileReader; 
import java.io.IOException; 

public class ProcessDataFile { 

    public static void main(String[] args) throws IOException { 

     int max = Integer.MIN_VALUE; 
     int i = 0; 
     int[] numbers = new int[100000]; 
     String datafile = "dataset529.txt"; //string which contains datafile 
     String line; //current line of text file 

     try (BufferedReader br = new BufferedReader(new FileReader(datafile))) { //reads in the datafile 
      while ((line = br.readLine()) != null) { //reads through each line 
       numbers[i++] = Integer.parseInt(line); //pulls out the number of each line and puts it in numbers[] 
      } 
     } 

     for (i = 0; i < 10000; i++){ //loop to go through each number in the file and compare it to find the largest int. 
      for(int j = 0; j < 10; j++) { //creates 10 threads 
       new Thread(); 
      } 
      if (max < numbers[i]) //As max gets bigger it checks the array and keeps increasing it as it finds a larger int. 
       max = numbers[i]; //Sets max equal to the final highest value found. 
     } 


     System.out.println("The largest number in DataSet529 is: " + max); 
    } 
} 

Answer 1

これは、特定の配列の値の所定の範囲を処理するスレッドを作成し、実行の基本的な概念を示して非常に基本的な例です。この例では、いくつかの前提があります（たとえば、偶数の要素のみ）。例も少し長い息切れされるので、意図的に行われ、

import java.util.Random; 

public class ThreadExample { 

    public static void main(String[] args) { 
     int[] numbers = new int[100000]; 
     Random rnd = new Random(); 
     for (int index = 0; index < numbers.length; index++) { 
      numbers[index] = rnd.nextInt(); 
     } 

     Thread[] threads = new Thread[10]; 
     Worker[] workers = new Worker[10]; 

     int range = numbers.length/10; 
     for (int index = 0; index < 10; index++) { 
      int startAt = index * range; 
      int endAt = startAt + range; 
      workers[index] = new Worker(startAt, endAt, numbers); 
     } 

     for (int index = 0; index < 10; index++) { 
      threads[index] = new Thread(workers[index]); 
      threads[index].start(); 
     } 

     boolean isProcessing = false; 
     do { 
      isProcessing = false; 
      for (Thread t : threads) { 
       if (t.isAlive()) { 
        isProcessing = true; 
        break; 
       } 
      } 
     } while (isProcessing); 

     for (Worker worker : workers) { 
      System.out.println("Max = " + worker.getMax()); 
     } 

    } 

    public static class Worker implements Runnable { 

     private int startAt; 
     private int endAt; 
     private int numbers[]; 

     private int max = Integer.MIN_VALUE; 

     public Worker(int startAt, int endAt, int[] numbers) { 
      this.startAt = startAt; 
      this.endAt = endAt; 
      this.numbers = numbers; 
     } 

     @Override 
     public void run() { 
      for (int index = startAt; index < endAt; index++) { 
       max = Math.max(numbers[index], max); 
      } 
     } 

     public int getMax() { 
      return max; 
     } 

    } 

} 

A、わずかに簡単な解決策の詳細はthe Concurrency Trailを見てとることで

スタートを必要とされるであろう基本的な手順を実証するための試みで、 ExecutorService APIを使用すると、一連のCallableをサービスに提供できるようになり、ListのFutureが返されます。ここでの利点は、スレッドの状態をチェックし、絶えず必要としないように、すべてのCallable秒まで戻りませんサービスは、完了した（または失敗した）、ある

あなたはおそらく開始することをお勧めします

import java.util.Arrays; 
import java.util.List; 
import java.util.Random; 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Future; 

public class ThreadExample { 

    public static void main(String[] args) { 
     int[] numbers = new int[100000]; 
     Random rnd = new Random(); 
     for (int index = 0; index < numbers.length; index++) { 
      numbers[index] = rnd.nextInt(); 
     } 

     ExecutorService executor = Executors.newFixedThreadPool(10); 

     Worker[] workers = new Worker[10]; 

     int range = numbers.length/10; 
     for (int index = 0; index < 10; index++) { 
      int startAt = index * range; 
      int endAt = startAt + range; 
      workers[index] = new Worker(startAt, endAt, numbers); 
     } 

     try { 
      List<Future<Integer>> results = executor.invokeAll(Arrays.asList(workers)); 
      for (Future<Integer> future : results) { 
       System.out.println(future.get()); 
      } 
     } catch (InterruptedException | ExecutionException ex) { 
      ex.printStackTrace(); 
     } 

    } 

    public static class Worker implements Callable<Integer> { 

     private int startAt; 
     private int endAt; 
     private int numbers[]; 


     public Worker(int startAt, int endAt, int[] numbers) { 
      this.startAt = startAt; 
      this.endAt = endAt; 
      this.numbers = numbers; 
     } 

     @Override 
     public Integer call() throws Exception { 
      int max = Integer.MIN_VALUE; 
      for (int index = startAt; index < endAt; index++) { 
       max = Math.max(numbers[index], max); 
      } 
      return max; 
     } 

    } 

}