Bir Diziyi İşlemek için 10 Başlığı Kullanma

Question

Java becerilerimi geliştirmek için çalışıyorum ama bu çok iş parçacıklı uygulamayı nasıl kullanacağım konusunda biraz emin değilim. Temel olarak, program bir metin dosyası okur ve en büyük sayıyı bulur. 10 iş parçacığı oluşturmak için arama algoritmamda bir döngü ekledim ancak aslında 10 iş parçacığı oluşturup oluşturmadığından emin değilim. Buradaki fikir, yürütme süresinin iyileştirilmesidir, ya da en azından bunun gerçekleşmesi gerektiği varsayılmaktadır. Doğru bir şekilde yapıp yapmadığımı ve yürütme süresinin gerçekten iyileşip iyileşmediğini kontrol etmek için var mı?

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

Bu, belirli bir dizi belirli bir değerler aralığı işlem mesajları oluşturma ve çalışan temel kavramlarını gösteren bir çok temel bir örnektir. Örnek birkaç varsayım yapmaktadır (örneğin, sadece birkaç eleman). örnek de biraz uzun soluklu olduğunu ve daha fazla ayrıntı

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; 
     } 

    } 

} 

Biraz daha basit bir çözüm için the Concurrency Trail bir göz alarak

Başlat ihtiyaç olacağını temel adımları göstermek amacıyla, bu nedenle kasıtlı yapılıyor Hizmete bir Callable s ürün serisini sunmanızı sağlayacak ExecutorService API'sini dahil eder, bu da List'un Future 'lerini döndürür. Burada yararı parçacığı durumlarını kontrol sürekli gerekmez yüzden tüm Callable s kadar dönmeyecek hizmeti tamamlamış (veya başarısız olmuş) olduğunu

Muhtemelen başlamak isteyeceksiniz

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; 
     } 

    } 

}