Java线程同步 2

CyclicBarrier用于设置一个Barrier，达到Barrier的线程将等待，当所有线程都达到Barrier时，所有线程继续执行。

 

1.       创建CyclicBarrier时通过构造函数指定线程的数量n。

2.       每个线程调用await方法等待其他线程。

3.       当有n个await方法被调用时，所有处于await的线程都将继续执行。

1. import java.util.concurrent.BrokenBarrierException;
2. import java.util.concurrent.CyclicBarrier;
4. public class CyclicBarrierTest
5. {
6.     private static CyclicBarrier barrier = null;
7.     
8.     public static void main(String[] args)
9.     {
10.         // 初始化
11.         barrier = new CyclicBarrier(10);
12.         
13.         // 启动10个线程
14.         System.out.println("main: starting 10 threads.");
15.         for (int i = 0; i < 10; i++)
16.         {
17.             Thread th = new Thread(new TestRunnable(), "thread " + i);
18.             th.start();
19.         }
20.     }
21.     
22.     private static class TestRunnable implements Runnable
23.     {
24.         @Override
25.         public void run()
26.         {
27.             String thName = Thread.currentThread().getName();
29.             try
30.             {
31.                 // 随机等待5-14秒
32.                 int n = (int)(Math.random() * 10 + 5);
33.                 System.out.printf("%s: sleep for %d seconds. /n", thName, n);
34.                 Thread.sleep(n * 1000);
35.                 
36.                 // 等待其他线程
37.                 System.out.printf("%s: waiting for other threads. /n", thName);
38.                 barrier.await();
39.                 
40.                 // 结束
41.                 System.out.printf("%s: end. /n", thName);
42.             }
43.             catch (InterruptedException e)
44.             {
45.                 System.out.printf("%s: interrupted. /n", thName);
46.                 return;
47.             }
48.             catch (BrokenBarrierException e)
49.             {
50.                 System.out.printf("%s: broken barrier. /n", thName);
51.                 return;
52.             }
53.         }
54.     }
55. }

 

1.       在调用await方法时设置超时时间。

2.       当有一个await方法超时，所有处于await等待的线程将收到BrokenBarrierException，超时的线程自身将收到TimeoutException。

3.       BrokenBarrier之后的所有await调用将直接抛出BrokenBarrierException。

 

 

1. import java.util.concurrent.BrokenBarrierException;
2. import java.util.concurrent.CyclicBarrier;
3. import java.util.concurrent.TimeUnit;
4. import java.util.concurrent.TimeoutException;
6. public class CyclicBarrierBrokenTest
7. {
8.     private static CyclicBarrier barrier = null;
9.     
10.     public static void main(String[] args)
11.     {
12.         // 初始化
13.         barrier = new CyclicBarrier(10);
14.         
15.         // 启动10个线程
16.         System.out.println("main: starting 10 threads.");
17.         for (int i = 0; i < 10; i++)
18.         {
19.             Thread th = new Thread(new TestRunnable(), "thread " + i);
20.             th.start();
21.         }
22.     }
23.     
24.     private static class TestRunnable implements Runnable
25.     {
26.         @Override
27.         public void run()
28.         {
29.             String thName = Thread.currentThread().getName();
31.             try
32.             {
33.                 // 随机等待5-14秒
34.                 int n = (int)(Math.random() * 10 + 5);
35.                 System.out.printf("%s: sleep for %d seconds. /n", thName, n);
36.                 Thread.sleep(n * 1000);
37.                 
38.                 // 等待其他线程
39.                 System.out.printf("%s: waiting for other threads. /n", thName);
40.                 barrier.await(5, TimeUnit.SECONDS);
41.                 
42.                 // 结束
43.                 System.out.printf("%s: end. /n", thName);
44.             }
45.             catch (InterruptedException e)
46.             {
47.                 System.out.printf("%s: interrupted. /n", thName);
48.                 return;
49.             }
50.             catch (BrokenBarrierException e)
51.             {
52.                 System.out.printf("%s: broken barrier. /n", thName);
53.                 return;
54.             }
55.             catch (TimeoutException e)
56.             {
57.                 System.out.printf("%s: timeout. /n", thName);
58.                 return;
59.             }
60.         }
61.     }
62. }

当调用await线程达到CyclicBarrier的设置之后，CyclicBarrier将被重置，重新等待n个await调用。

 

1. import java.util.concurrent.BrokenBarrierException;
2. import java.util.concurrent.CyclicBarrier;
4. public class CyclicBarrierResetTest
5. {
6.     private static CyclicBarrier barrier = null;
7.     
8.     public static void main(String[] args) throws Exception
9.     {
10.         barrier = new CyclicBarrier(2);
11.         
12.         Thread th1 = new Thread(new TestRunnable(), "thread 1");
13.         Thread th2 = new Thread(new TestRunnable(), "thread 2");
14.         
15.         th1.start();
16.         th2.start();
17.         
18.         Thread.sleep(60 * 1000);
19.         
20.         th1.interrupt();
21.         th2.interrupt();
22.         
23.         th1.join();
24.         th2.join();
25.     }
26.     
27.     private static class TestRunnable implements Runnable
28.     {
29.         @Override
30.         public void run()
31.         {
32.             String thName = Thread.currentThread().getName();
33.             System.out.printf("%s: start. /n", thName);
34.             
35.             try
36.             {
37.                 while (true)
38.                 {
39.                     // 随机产生1-100的整数。
40.                     int c = (int)(Math.random() * 100) + 1;
41.                     
42.                     // 随机等待0-4秒。
43.                     int t = (int)(Math.random() * 5);
44.                     System.out.printf("%s: sleep for %d seconds./n", thName, t);
45.                     Thread.sleep(t * 1000);
46.                     
47.                     // 等待另1线程。
48.                     barrier.await();
49.                     
50.                     // 输出产生的整数。
51.                     System.out.printf("%s: %d /n", thName, c);
52.                     
53.                     // 等待其他线程输出。
54.                     Thread.sleep(100);
55.                 }
56.             }
57.             catch (InterruptedException e)
58.             {
59.                 System.out.printf("%s: interrupted. /n", thName);
60.             }
61.             catch (BrokenBarrierException e)
62.             {
63.                 e.printStackTrace();
64.             }
65.             
66.             System.out.printf("%s: end. /n", thName);
67.         }
68.     }
69. }

 

1.       在创建CyclicBarrier的时候指定通过Barrier时需要执行的语句。

2.       通过构造方法的Runnable参数指定。

3.       Runnable中的语句将由最后达到Barrier的线程执行。

 

1. import java.util.concurrent.BrokenBarrierException;
2. import java.util.concurrent.CyclicBarrier;
4. public class CyclicBarrierActionTest
5. {
6.     private static CyclicBarrier barrier = null;
7.     
8.     public static void main(String[] args) throws Exception
9.     {
10.         barrier = new CyclicBarrier(10, new BarrierAction());
11.         
12.         for (int i = 0; i < 10; i++)
13.         {
14.             Thread th = new Thread(new TestRunnable(), "thread " + i);
15.             th.start();
16.         }
17.     }
18.     
19.     private static class TestRunnable implements Runnable
20.     {
21.         @Override
22.         public void run()
23.         {
24.             try
25.             {
26.                 String thName = Thread.currentThread().getName();
27.                 // System.out.printf("%s: start. /n", thName);
28.                 
29.                 // 随机等待0-9秒
30.                 int t = (int)(Math.random() * 10);
31.                 System.out.printf("%s: sleep for %d seconds. /n", thName, t);
32.                 Thread.sleep(t * 1000);
33.                 
34.                 // 等待barrier
35.                 barrier.await();
36.                 System.out.printf("%s: end. /n", thName);
37.             }
38.             catch (InterruptedException e)
39.             {
40.                 e.printStackTrace();
41.                 return;
42.             }
43.             catch (BrokenBarrierException e)
44.             {
45.                 e.printStackTrace();
46.                 return;
47.             }
48.         }
49.     }
50.     
51.     private static class BarrierAction implements Runnable
52.     {
53.         @Override
54.         public void run()
55.         {
56.             String thName = Thread.currentThread().getName();
57.             
58.             System.out.printf("%s: barrier action. /n", thName);
59.         }
60.     }
61. }