Java中等待所有线程都执行结束

原文地址:http://blog.csdn.net/liweisnake/article/details/12966761

  今天看到一篇文章,是关于java中如何等待所有线程都执行结束,文章总结得很好,原文如下http://software.intel.com/zh-cn/blogs/2013/10/15/java-countdownlatchcyclicbarrier/?utm_campaign=CSDN&utm_source=intel.csdn.net&utm_medium=Link&utm_content=others-%20Java

  看过之后在想java中有很大的灵活性,应该有更多的方式可以做这件事。

  这个事情的场景是这样的:许多线程并行的计算一堆问题,然后每个计算存在一个队列,在主线程要等待所有计算结果完成后排序并展示出来。这样的问题其实很常见。

  1. 使用join。这种方式其实并不是那么的优雅,将所有线程启动完之后还需要将所有线程都join,但是每次join都会阻塞,直到被join线程完成,很可能所有被阻塞线程已经完事了,主线程还在不断地join,貌似有点浪费,而且两个循环也不太好看。

[java]  view plain  copy
  1.        @Test  
  2. public void testThreadSync1() {  
  3.   
  4.     final Vector<Integer> list = new Vector<Integer>();  
  5.     Thread[] threads = new Thread[TEST_THREAD_COUNT];  
  6.     try {  
  7.         for (int i = 0; i < TEST_THREAD_COUNT; i++) {  
  8.             final int num = i;  
  9.             threads[i] = new Thread(new Runnable() {  
  10.                 public void run() {  
  11.                     try {  
  12.                         Thread.sleep(random.nextInt(100));  
  13.                     } catch (InterruptedException e) {  
  14.                         e.printStackTrace();  
  15.                     }  
  16.                     list.add(num);  
  17.                     System.out.print(num + " add.\t");  
  18.                 }  
  19.             });  
  20.             threads[i].start();  
  21.         }  
  22.         for (int i = 0; i < threads.length; i++) {  
  23.             threads[i].join();  
  24.             System.out.print(i + " end.\t");  
  25.         }  
  26.     } catch (InterruptedException ie) {  
  27.         ie.printStackTrace();  
  28.     }  
  29.     printSortedResult(list);  
  30. }  

[java]  view plain  copy
  1. 9 add.  7 add.  3 add.  5 add.  4 add.  1 add.  0 add.  0 end.  1 end.  8 add.  2 add.  2 end.  3 end.  4 end.  5 end.  6 add.  6 end.  7 end.  8 end.  9 end.    
  2. before sort  
  3. 9   7   3   5   4   1   0   8   2   6     
  4. after sort  
  5. 0   1   2   3   4   5   6   7   8   9  

  2. 使用wait/notifyAll,这个方式其实跟上面是类似的,只是比较底层些吧(join实际上也是wait)。

[java]  view plain  copy
  1. @Test  
  2. public void testThreadSync2() throws IOException, InterruptedException {  
  3.     final Object waitObject = new Object();  
  4.     final AtomicInteger count = new AtomicInteger(TEST_THREAD_COUNT);  
  5.     final Vector<Integer> list = new Vector<Integer>();  
  6.     Thread[] threads = new Thread[TEST_THREAD_COUNT];  
  7.     for (int i = 0; i < TEST_THREAD_COUNT; i++) {  
  8.         final int num = i;  
  9.         threads[i] = new Thread(new Runnable() {  
  10.             public void run() {  
  11.                 try {  
  12.                     Thread.sleep(random.nextInt(100));  
  13.                 } catch (InterruptedException e) {  
  14.                     e.printStackTrace();  
  15.                 }  
  16.                 list.add(num);  
  17.                 System.out.print(num + " add.\t");  
  18.                 synchronized (waitObject) {  
  19.                     int cnt = count.decrementAndGet();  
  20.                     if (cnt == 0) {  
  21.                         waitObject.notifyAll();  
  22.                     }  
  23.                 }  
  24.             }  
  25.         });  
  26.         threads[i].start();  
  27.     }  
  28.     synchronized (waitObject) {  
  29.         while (count.get() != 0) {  
  30.             waitObject.wait();  
  31.         }  
  32.     }  
  33.     printSortedResult(list);  
  34. }  
  3. 使用CountDownLatch,这其实是最优雅的写法了,每个线程完成后都去将计数器减一,最后完成时再来唤醒。

[java]  view plain  copy
  1. @Test  
  2. public void testThreadSync3() {  
  3.     final Vector<Integer> list = new Vector<Integer>();  
  4.     Thread[] threads = new Thread[TEST_THREAD_COUNT];  
  5.     final CountDownLatch latch = new CountDownLatch(TEST_THREAD_COUNT);  
  6.     for (int i = 0; i < TEST_THREAD_COUNT; i++) {  
  7.         final int num = i;  
  8.         threads[i] = new Thread(new Runnable() {  
  9.             public void run() {  
  10.                 try {  
  11.                     Thread.sleep(random.nextInt(100));  
  12.                 } catch (InterruptedException e) {  
  13.                     e.printStackTrace();  
  14.                 }  
  15.                 list.add(num);  
  16.                 System.out.print(num + " add.\t");  
  17.                 latch.countDown();  
  18.             }  
  19.         });  
  20.         threads[i].start();  
  21.     }  
  22.     try {  
  23.         latch.await();  
  24.     } catch (InterruptedException e) {  
  25.         e.printStackTrace();  
  26.     }  
  27.     printSortedResult(list);  
  28. }  

  4. 使用CyclicBarrier。这里其实类似上面,这个berrier只是在等待完成后自动调用传入CyclicBarrier的Runnable。

[java]  view plain  copy
  1. @Test  
  2. public void testThreadSync4() throws IOException {  
  3.     final Vector<Integer> list = new Vector<Integer>();  
  4.     Thread[] threads = new Thread[TEST_THREAD_COUNT];  
  5.     final CyclicBarrier barrier = new CyclicBarrier(TEST_THREAD_COUNT,  
  6.             new Runnable() {  
  7.                 public void run() {  
  8.                     printSortedResult(list);  
  9.                 }  
  10.             });  
  11.     for (int i = 0; i < TEST_THREAD_COUNT; i++) {  
  12.         final int num = i;  
  13.         threads[i] = new Thread(new Runnable() {  
  14.             public void run() {  
  15.                 try {  
  16.                     Thread.sleep(random.nextInt(100));  
  17.                 } catch (InterruptedException e) {  
  18.                     e.printStackTrace();  
  19.                 }  
  20.                 list.add(num);  
  21.                 System.out.print(num + " add.\t");  
  22.                 try {  
  23.                     barrier.await();  
  24.                 } catch (InterruptedException e) {  
  25.                     e.printStackTrace();  
  26.                 } catch (BrokenBarrierException e) {  
  27.                     e.printStackTrace();  
  28.                 }  
  29.             }  
  30.         });  
  31.         threads[i].start();  
  32.     }  
  33.     System.in.read();  
  34. }  
  实际上这些方法也是跟那篇文章说的类似,不过都写出来可以稍微参考下。而且我相信还有更多其它方式。
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页