Java - 每個線程的多個Runnables

Question

我得到了固定數量的線程。我希望每個線程都能一個接一個地運行三個Runnable。下面是一些僞代碼來解釋：

Thread[] threads = new Thread[4]; 

for (int i = 0; i < threads.length; i++) { 
    // Set the first tasks. 
    threads[i] = new Thread(new FirstRunnable()); 
    threads[i].start(); 
} 

for (int i = 0; i < threads.length; i++) 
    threads[i].join(); // wait until the first tasks are done 

for (int i = 0; i < threads.length; i++) { 
    // Set the second task. 
    threads[i].setRunnable(new SecondRunnable()); 
    threads[i].start(); 
} 

for (int i = 0; i < threads.length; i++) 
    threads[i].join(); // wait until the second tasks are done 

... 

使用ThreadPool聽起來方式矯枉過正，特別是因爲我爲首的性能，性能，性能。在Java中實現這個最好的方法是什麼？

Answer 1

每當您看到new Thread(...).start()時，請使用Executors框架。特別要利用Executors.newFixedThreadPool(...)。

Answer 2

您可以使用CyclicBarrier和「CombinedRunnable」，如下所示。屏障允許所有線程都等待對方完成，然後再繼續下一個可運行。

CyclicBarrier barrier = new CyclicBarrier(4); 
Runnable r = new CombinedRunnable(barrier, new FirstRunnable(), new SecondRunnable()); 
Thread[] threads = new Thread[4]; 
for (int i = 0; i < threads.length; i++) { 
    threads[i] = new Thread(r); 
    threads[i].start(); 
} 

的CombinedRunnable類：

public class CombinedRunnable implements Runnable{ 

    private final CyclicBarrier barrier; 
    private final Runnable[] runnables; 

    public CombinedRunnable(CyclicBarrier barrier, Runnable... runnables){ 
     this.barrier = barrier; 
     this.runnables = runnables; 
    } 

    /* (non-Javadoc) 
    * @see java.lang.Runnable#run() 
    */ 
    @Override 
    public void run() { 
     for(Runnable r: runnables){ 
      r.run(); 
      try { 
       barrier.await(); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } catch (BrokenBarrierException e) { 
       e.printStackTrace(); 
      } 
     } 
    } 
} 

Answer 3

執行人框架是隻爲你。
下面是僞代碼：
1.創建執行服務

Executors type1Runnables = Executors.newFixedThreadPool(4); 
Executors type2Runnables = Executors.newFixedThreadPool(4); 

等。
2.提交任務，它

for(){ 
type1Runnables.submit(new Runnable1()); 
type2Runnables.submit(new Runnable2); 
} 

3.調用執行人

type1Runnables.invokeAll(); 
type2Runnables.invokeAll(); 

爲了使它更通用，你可以編寫自己的executorservicefactory它接受不同的可運行類型。

Answer 4

似乎很適合Executors類中的newFixedThreadPool。

所以，你的代碼看起來是這樣的：

ExecutorService es = Executors.newFixedThreadPool(4); 
List<Future> futures = new ArrayList<Future>(); 
for (int x = 0; x < 4; x ++) { 
    futures.add(es.submit(new FirstRunnable())); 
} 
while (futures.size() > 0) { 
    futures.remove(0).get(); 
} 
for (int x = 0; x < 4; x ++) { 
    futures.add(es.submit(new SecondRunnable())); 
} 

while (futures.size() > 0) { 
    futures.remove(0).get(); 
} 

當然，你也可能很容易地重構上面的代碼刪除代碼重複。

Answer 5

實現此目的的一種慣用方法是將Executor與CompletionService結合使用。這使您可以將許多工作單元映射到固定大小的線程池，並提供了一種優化的阻塞機制，直到所有工作完成。

請注意，您關心如何使用線程池可能會影響效率並不是真正的問題：主要開銷是創建單個線程，無論如何，創建池時額外的對象創建開銷將可以忽略不計。

// Create fixed thread pool and wrap in a CompletionService to allow for easy access to completed tasks. 
// We don't have an explicit result for each Runnable so parameterise the service on Void. 
CompletionService<Void> cs = new ExecutorCompletionService<Void>(Executors.newFixedThreadPool(3)); 

// Create units of work for submission to completion service. 
Runnable[] runnables = ... 

// Submit runnables. Note that we don't care about the result so pass in null. 
for (Runnable r : runnables) { 
    cs.submit(r, null); 
} 

// Take each *completed* result in turn, blocking until a completed result becomes available. 
for (int i=0; i<runnables.length; ++i) { 
    Future<Void> completed = cs.take(); 
}