有什么方法可以简单地等待所有线程进程完成？例如，假设我有：
public class DoSomethingInAThread implements Runnable{
public static void main(String[] args) {
for (int n=0; n<1000; n++) {
Thread t = new Thread(new DoSomethingInAThread());
t.start();
}
// wait for all threads' run() methods to complete before continuing
}
public void run() {
// do something here
}
}如何更改此main()方法，以便该方法在注释处暂停，直到所有线程的run()方法退出？谢谢！
Answers:
您将所有线程放入一个数组，全部启动，然后进行循环
for(i = 0; i < threads.length; i++)
threads[i].join();每个连接将阻塞，直到相应的线程完成为止。线程的完成顺序可能不同于您加入线程的顺序，但这不是问题：退出循环时，所有线程均已完成。
一种方法是做一个List的ThreadS，创建和启动每个线程，而将其添加到列表中。一切启动后，循环遍历该列表并调用join()每个列表。线程以什么顺序执行无关紧要，您需要知道的是，在第二个循环完成执行时，每个线程都将完成。
更好的方法是使用ExecutorService及其关联的方法：
List<Callable> callables = ... // assemble list of Callables here
// Like Runnable but can return a value
ExecutorService execSvc = Executors.newCachedThreadPool();
List<Future<?>> results = execSvc.invokeAll(callables);
// Note: You may not care about the return values, in which case don't
// bother saving them使用ExecutorService（以及Java 5的并发实用程序中的所有新功能）非常灵活，并且上面的示例几乎没有涉及表面。
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class DoSomethingInAThread implements Runnable
{
public static void main(String[] args) throws ExecutionException, InterruptedException
{
//limit the number of actual threads
int poolSize = 10;
ExecutorService service = Executors.newFixedThreadPool(poolSize);
List<Future<Runnable>> futures = new ArrayList<Future<Runnable>>();
for (int n = 0; n < 1000; n++)
{
Future f = service.submit(new DoSomethingInAThread());
futures.add(f);
}
// wait for all tasks to complete before continuing
for (Future<Runnable> f : futures)
{
f.get();
}
//shut down the executor service so that this thread can exit
service.shutdownNow();
}
public void run()
{
// do something here
}
}join()可以使用CountDownLatch代替，而这是一个旧的API 。我已按照以下方式修改了您的代码，以满足您的要求。
import java.util.concurrent.*;
class DoSomethingInAThread implements Runnable{
CountDownLatch latch;
public DoSomethingInAThread(CountDownLatch latch){
this.latch = latch;
}
public void run() {
try{
System.out.println("Do some thing");
latch.countDown();
}catch(Exception err){
err.printStackTrace();
}
}
}
public class CountDownLatchDemo {
public static void main(String[] args) {
try{
CountDownLatch latch = new CountDownLatch(1000);
for (int n=0; n<1000; n++) {
Thread t = new Thread(new DoSomethingInAThread(latch));
t.start();
}
latch.await();
System.out.println("In Main thread after completion of 1000 threads");
}catch(Exception err){
err.printStackTrace();
}
}
}说明：
CountDownLatch 已根据您的要求使用给定的计数1000进行了初始化。
每个工作线程DoSomethingInAThread 都会减少CountDownLatch，该值已在构造函数中传递。
主线程，CountDownLatchDemo await()直到计数变为零为止。一旦计数变为零，您将在输出下一行。
In Main thread after completion of 1000 threadsoracle文档页面上的更多信息
public void await()
throws InterruptedException导致当前线程等待，直到锁存器递减计数到零为止，除非该线程被中断。
有关其他选项，请参阅相关的SE问题：
完全避免使用Thread类，而使用java.util.concurrent中提供的高级抽象
ExecutorService类提供的方法invokeAll似乎可以完成您想要的任何事情。
考虑使用java.util.concurrent.CountDownLatch。javadocs中的示例
正如Martin K所建议的那样，这 java.util.concurrent.CountDownLatch似乎是一个更好的解决方案。只是添加一个例子
public class CountDownLatchDemo
{
public static void main (String[] args)
{
int noOfThreads = 5;
// Declare the count down latch based on the number of threads you need
// to wait on
final CountDownLatch executionCompleted = new CountDownLatch(noOfThreads);
for (int i = 0; i < noOfThreads; i++)
{
new Thread()
{
@Override
public void run ()
{
System.out.println("I am executed by :" + Thread.currentThread().getName());
try
{
// Dummy sleep
Thread.sleep(3000);
// One thread has completed its job
executionCompleted.countDown();
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}.start();
}
try
{
// Wait till the count down latch opens.In the given case till five
// times countDown method is invoked
executionCompleted.await();
System.out.println("All over");
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}如果列出了所有线程，则可以对它们进行循环访问，并针对每个循环进行.join（），当所有线程都拥有时，循环将结束。我还没有尝试过。
http://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#join（）
在第一个for循环内创建线程对象。
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(new Runnable() {
public void run() {
// some code to run in parallel
}
});
threads[i].start();
}然后每个人都在说。
for(i = 0; i < threads.length; i++)
threads[i].join();您可以使用对象“ ThreadGroup”及其参数activeCount来实现：
作为CountDownLatch的替代方法，您还可以使用CyclicBarrier例如
public class ThreadWaitEx {
static CyclicBarrier barrier = new CyclicBarrier(100, new Runnable(){
public void run(){
System.out.println("clean up job after all tasks are done.");
}
});
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
Thread t = new Thread(new MyCallable(barrier));
t.start();
}
}
}
class MyCallable implements Runnable{
private CyclicBarrier b = null;
public MyCallable(CyclicBarrier b){
this.b = b;
}
@Override
public void run(){
try {
//do something
System.out.println(Thread.currentThread().getName()+" is waiting for barrier after completing his job.");
b.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}在这种情况下，要使用CyclicBarrier，barrier.await（）应该是最后一条语句，即线程完成其工作时。CyclicBarrier可以通过其reset（）方法再次使用。引用javadocs：
CyclicBarrier支持可选的Runnable命令，该命令在障碍中的最后一个线程到达之后但在释放任何线程之前，每个障碍点运行一次。此屏障操作对于在任何一方继续之前更新共享状态很有用。
该join()不是对我很有帮助。在Kotlin中查看此示例：
val timeInMillis = System.currentTimeMillis()
ThreadUtils.startNewThread(Runnable {
for (i in 1..5) {
val t = Thread(Runnable {
Thread.sleep(50)
var a = i
kotlin.io.println(Thread.currentThread().name + "|" + "a=$a")
Thread.sleep(200)
for (j in 1..5) {
a *= j
Thread.sleep(100)
kotlin.io.println(Thread.currentThread().name + "|" + "$a*$j=$a")
}
kotlin.io.println(Thread.currentThread().name + "|TaskDurationInMillis = " + (System.currentTimeMillis() - timeInMillis))
})
t.start()
}
})结果：
Thread-5|a=5
Thread-1|a=1
Thread-3|a=3
Thread-2|a=2
Thread-4|a=4
Thread-2|2*1=2
Thread-3|3*1=3
Thread-1|1*1=1
Thread-5|5*1=5
Thread-4|4*1=4
Thread-1|2*2=2
Thread-5|10*2=10
Thread-3|6*2=6
Thread-4|8*2=8
Thread-2|4*2=4
Thread-3|18*3=18
Thread-1|6*3=6
Thread-5|30*3=30
Thread-2|12*3=12
Thread-4|24*3=24
Thread-4|96*4=96
Thread-2|48*4=48
Thread-5|120*4=120
Thread-1|24*4=24
Thread-3|72*4=72
Thread-5|600*5=600
Thread-4|480*5=480
Thread-3|360*5=360
Thread-1|120*5=120
Thread-2|240*5=240
Thread-1|TaskDurationInMillis = 765
Thread-3|TaskDurationInMillis = 765
Thread-4|TaskDurationInMillis = 765
Thread-5|TaskDurationInMillis = 765
Thread-2|TaskDurationInMillis = 765现在让我使用join()for线程：
val timeInMillis = System.currentTimeMillis()
ThreadUtils.startNewThread(Runnable {
for (i in 1..5) {
val t = Thread(Runnable {
Thread.sleep(50)
var a = i
kotlin.io.println(Thread.currentThread().name + "|" + "a=$a")
Thread.sleep(200)
for (j in 1..5) {
a *= j
Thread.sleep(100)
kotlin.io.println(Thread.currentThread().name + "|" + "$a*$j=$a")
}
kotlin.io.println(Thread.currentThread().name + "|TaskDurationInMillis = " + (System.currentTimeMillis() - timeInMillis))
})
t.start()
t.join()
}
})结果：
Thread-1|a=1
Thread-1|1*1=1
Thread-1|2*2=2
Thread-1|6*3=6
Thread-1|24*4=24
Thread-1|120*5=120
Thread-1|TaskDurationInMillis = 815
Thread-2|a=2
Thread-2|2*1=2
Thread-2|4*2=4
Thread-2|12*3=12
Thread-2|48*4=48
Thread-2|240*5=240
Thread-2|TaskDurationInMillis = 1568
Thread-3|a=3
Thread-3|3*1=3
Thread-3|6*2=6
Thread-3|18*3=18
Thread-3|72*4=72
Thread-3|360*5=360
Thread-3|TaskDurationInMillis = 2323
Thread-4|a=4
Thread-4|4*1=4
Thread-4|8*2=8
Thread-4|24*3=24
Thread-4|96*4=96
Thread-4|480*5=480
Thread-4|TaskDurationInMillis = 3078
Thread-5|a=5
Thread-5|5*1=5
Thread-5|10*2=10
Thread-5|30*3=30
Thread-5|120*4=120
Thread-5|600*5=600
Thread-5|TaskDurationInMillis = 3833很明显，当我们使用时join：
我们防止阻塞其他线程的解决方案是创建ArrayList：
val threads = ArrayList<Thread>()现在，当我们要启动一个新线程时，我们最多将其添加到ArrayList中：
addThreadToArray(
ThreadUtils.startNewThread(Runnable {
...
})
)该addThreadToArray函数：
@Synchronized
fun addThreadToArray(th: Thread) {
threads.add(th)
}该startNewThreadfunstion：
fun startNewThread(runnable: Runnable) : Thread {
val th = Thread(runnable)
th.isDaemon = false
th.priority = Thread.MAX_PRIORITY
th.start()
return th
}在需要的地方检查线程的完成情况，如下所示：
val notAliveThreads = ArrayList<Thread>()
for (t in threads)
if (!t.isAlive)
notAliveThreads.add(t)
threads.removeAll(notAliveThreads)
if (threads.size == 0){
// The size is 0 -> there is no alive threads.
}