如何在Java代碼中啓動一組線程

Question

我有問題。

我有10000個字符串，我想對他們每個人執行一些操作。我想將這些操作並行化，以使總執行時間可以接受。

我決定創建線程。特別是，我每10個字符串就會啓動10個線程。對於每個線程，我將結果保存在列表中。

我試過兩個版本的代碼。這是我的第一個版本。

int size = 10000; 
int cont = 0; 
     int n = 1; 
     String[] arrstr2; 
     int threadgroup = 10; 
if (cont + threadgroup - 1 > size) { 
         arrstr2[i - cont] = subject.toString(); 
        } else { 
         arrstr2[i - cont] = subject.toString(); 
        } 

        if ((i == (threadgroup * n) - 1) || (i == size - 1)) { 

         cont = i + 1; 
         n = n + 1; 
         for (int j = 0; j < arrstr2.length; j++) { 
          Thread t = new Thread(new MyThread(arrstr2[j], l)); 
          t.start(); 

          try { 
           t.join(); 
          } catch (InterruptedException e) { 
           // TODO Auto-generated catch block 
           e.printStackTrace(); 
          } 
         } 
         if (cont + threadgroup - 1 > size) { 
          arrstr2 = new String[size - i - 1]; 
         } 
        } 
        i = i + 1; 

在這個版本中，我沒有得到總執行的優勢。

這是我的第二個版本：

int size = 10000; 
    int cont = 0; 
      int n = 1; 
      String[] arrstr2; 
      int threadgroup = 10; 
    if (cont + threadgroup - 1 > size) { 
          arrstr2[i - cont] = subject.toString(); 
         } else { 
          arrstr2[i - cont] = subject.toString(); 
         } 

         if ((i == (threadgroup * n) - 1) || (i == size - 1)) { 

          cont = i + 1; 
          n = n + 1; 
          for (int j = 0; j < arrstr2.length; j++) { 
           Thread t = new Thread(new MyThread(arrstr2[j], l)); 
           t.start(); 

          } 
try { 
           Thread.sleep(500); 
          } catch (InterruptedException e) { 
           // TODO Auto-generated catch block 
           e.printStackTrace(); 
          } 
          if (cont + threadgroup - 1 > size) { 
           arrstr2 = new String[size - i - 1]; 
          } 
         } 
         i = i + 1; 

在這種情況下，我失去了一些信息。 MyThread的是，做了一些處理，並提出在列表中的Java結果的類：

public class MyThread implements Runnable{ 

    String subject; 
    private List<String[]> l; 

    public MyThread(String subject, List<String[]> l) { 
     this.subject = subject; 
     this.l = l; 
    } 

    @Override 
    public void run() { 

     synchronized (l){ 
     //do something 
     String[] result = new String[2]; 
     result[0] = res0; 
     result[1] = res1; 
     l.add(result); 
    } 
} 

對於我的目標，這個代碼是正確的嗎？如何在Java代碼中啓動一組線程並檢索可接受的時間？

Answer 1

下面是一個ExecutorService的小示例。線程大小固定爲10，但您可以根據需要進行調整。

StringTask基本上顛倒了給定的字符串。

public class Test { 

    private static final int THREADS = 10; 
    private static final int DATA_SIZE = 1000; 

    public static void main(String[] args) { 
     // Declare a new ExecutorService with a maximum of 2 threads. 
     ExecutorService service = Executors.newFixedThreadPool(THREADS); 

     // Prepare a list of Future results. 
     List<Future<String>> futures = new ArrayList<Future<String>>(DATA_SIZE); 

     // Submit the tasks and store the results. 
     for (int i = 0; i < DATA_SIZE; i++) { 
      futures.add(service.submit(new StringTask("Sample String " + i))); 
     } 

     // Accept no new tasks. 
     service.shutdown(); 

     // Retrieve the actual String results. 
     List<String> results = new ArrayList<String>(DATA_SIZE); 
     try { 
      for (Future<String> future : futures) { 
       // The get() method blocks if the execution of the task is not finished. 
       results.add(future.get()); 
       System.out.println(future.get()); 
      } 
     } catch (ExecutionException ee) { 
      System.out.println("Error while getting result!"); 
      ee.printStackTrace(); 
     } catch (InterruptedException ie) { 
      System.out.println("Error while getting result!"); 
      ie.printStackTrace(); 
     } 
    } 

    /** 
    * Callable task that reverses a given String. 
    */ 
    private static final class StringTask implements Callable<String> { 
     private String input; 

     private StringTask(String input) { 
      super(); 

      if (input == null) { 
       throw new NullPointerException(); 
      } 

      this.input = input; 
     } 

     @Override 
     public String call() throws Exception { 
      StringBuilder builder = new StringBuilder(); 

      for (int i = this.input.length() - 1; i >= 0; i--) { 
       builder.append(this.input.charAt(i)); 
      } 

      return builder.toString(); 
     } 
    } 
} 

我使用Callable這裏，而不是Runnable因爲Callable允許作業實際回報，我們可以使用（通過Future接口）的結果。如果您只需要執行任務，則可以簡單地使用Runnable！

Answer 2

也許你可能會看看新的Java 8 Stream API。 http://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html 在那裏你可以很容易地並行這些操作。

Answer 3

使用Java 8：

List<String> res = Arrays.toStream(arrstr2) 
         .parallel() 
         .map(s -> doWork(s)) 
         .collect(Collectors.toList());