《张孝祥Java多线程与并发库高级应用视频教程》里面关于CyclicBarrier同步工具的应用中，当运行线程改为5个时，运行结果出现不在同一地点就出发了，谁能解释一下？

1. package cn.itcast.heima2;
   
2. 
   
3. import java.util.concurrent.CyclicBarrier;
   
4. import java.util.concurrent.ExecutorService;
   
5. import java.util.concurrent.Executors;
   
6. 
   
7. public class CyclicBarrierTest {
   
8. 
   
9.         public static void main(String[] args) {
   
10.                 ExecutorService service = Executors.newCachedThreadPool();
    
11.                 final CyclicBarrier cb = new CyclicBarrier(3);
    
12.                 for (int i = 0; i < 5; i++) {
    
13.                         Runnable runnable = new Runnable() {
    
14.                                 public void run() {
    
15.                                         try {
    
16.                                                 Thread.sleep((long) (Math.random() * 1000));
    
17.                                                 System.out.println("线程"
    
18.                                                                 + Thread.currentThread().getName()
    
19.                                                                 + "即将到达集合地点1，当前已有"
    
20.                                                                 + (cb.getNumberWaiting() + 1)
    
21.                                                                 + "个已经到达，"
    
22.                                                                 + (cb.getNumberWaiting() == 2 ? "都到齐了，继续走啊"
    
23.                                                                                 : "正在等候"));
    
24.                                                 cb.await();
    
25. 
    
26.                                                 Thread.sleep((long) (Math.random() * 1000));
    
27.                                                 System.out.println("线程"
    
28.                                                                 + Thread.currentThread().getName()
    
29.                                                                 + "即将到达集合地点2，当前已有"
    
30.                                                                 + (cb.getNumberWaiting() + 1)
    
31.                                                                 + "个已经到达，"
    
32.                                                                 + (cb.getNumberWaiting() == 2 ? "都到齐了，继续走啊"
    
33.                                                                                 : "正在等候"));
    
34.                                                 cb.await();
    
35.                                                 Thread.sleep((long) (Math.random() * 1000));
    
36.                                                 System.out.println("线程"
    
37.                                                                 + Thread.currentThread().getName()
    
38.                                                                 + "即将到达集合地点3，当前已有"
    
39.                                                                 + (cb.getNumberWaiting() + 1)
    
40.                                                                 + "个已经到达，"
    
41.                                                                 + (cb.getNumberWaiting() == 2 ? "都到齐了，继续走啊"
    
42.                                                                                 : "正在等候"));
    
43.                                                 cb.await();
    
44.                                         } catch (Exception e) {
    
45.                                                 e.printStackTrace();
    
46.                                         }
    
47.                                 }
    
48.                         };
    
49.                         service.execute(runnable);
    
50.                 }
    
51.                 service.shutdown();
    
52.         }
    
53. }
    
54. /*结果：
    
55. 线程pool-1-thread-1即将到达集合地点1，当前已有1个已经到达，正在等候
    
56. 线程pool-1-thread-5即将到达集合地点1，当前已有2个已经到达，正在等候
    
57. 线程pool-1-thread-3即将到达集合地点1，当前已有3个已经到达，都到齐了，继续走啊
    
58. 线程pool-1-thread-4即将到达集合地点1，当前已有1个已经到达，正在等候
    
59. 线程pool-1-thread-2即将到达集合地点1，当前已有2个已经到达，正在等候
    
60. 线程pool-1-thread-3即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊
    
61. 线程pool-1-thread-5即将到达集合地点2，当前已有1个已经到达，正在等候
    
62. 线程pool-1-thread-3即将到达集合地点3，当前已有2个已经到达，正在等候
    
63. 线程pool-1-thread-2即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊
    
64. 线程pool-1-thread-5即将到达集合地点3，当前已有1个已经到达，正在等候
    
65. 线程pool-1-thread-1即将到达集合地点2，当前已有2个已经到达，正在等候
    
66. 线程pool-1-thread-4即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊
    
67. 线程pool-1-thread-4即将到达集合地点3，当前已有1个已经到达，正在等候
    
68. 线程pool-1-thread-2即将到达集合地点3，当前已有2个已经到达，正在等候
    
69. 线程pool-1-thread-1即将到达集合地点3，当前已有3个已经到达，都到齐了，继续走啊*/
    

复制代码

因为线程等待值为3，线程为5，每次只要满3个线程就运行，而cb.await();是同一个对象的等待方法，虽然关卡cb.await()出现的地方不同，但都视为同一关卡
                                             
线程   A     B     C      D      E
          |       |       |       |       |
关卡  CB   CB  CB       |       |  （DE没赶上，等下一趟车）   （ABC）第一次
         |       |        |       |       |
关卡  |       |        CB   CB  CB    （二缺一C搭上了DE的车，AB没搭上）   （DE）第一次，C第二次
         .....................