Java线程同步 2

原创 2008年10月01日 20:07:00

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

<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

 

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

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

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

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

 

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;
  5. public class CyclicBarrierBrokenTest
  6. {
  7.     private static CyclicBarrier barrier = null;
  8.     
  9.     public static void main(String[] args)
  10.     {
  11.         // 初始化
  12.         barrier = new CyclicBarrier(10);
  13.         
  14.         // 启动10个线程
  15.         System.out.println("main: starting 10 threads.");
  16.         for (int i = 0; i < 10; i++)
  17.         {
  18.             Thread th = new Thread(new TestRunnable(), "thread " + i);
  19.             th.start();
  20.         }
  21.     }
  22.     
  23.     private static class TestRunnable implements Runnable
  24.     {
  25.         @Override
  26.         public void run()
  27.         {
  28.             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(5, TimeUnit.SECONDS);
  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.             catch (TimeoutException e)
  54.             {
  55.                 System.out.printf("%s: timeout. /n", thName);
  56.                 return;
  57.             }
  58.         }
  59.     }
  60. }

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

 

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

 

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

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

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

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

 

 

 

 

 

java中线程同步的理解(非常通俗易懂)

我们可以在计算机上运行各种计算机软件程序。每一个运行的程序可能包括多个独立运行的线程(Thread)。 线程(Thread)是一份独立运行的程序,有自己专用的运行栈。线程有可能和其他线程共享一些资...
  • u012179540
  • u012179540
  • 2014年11月01日 21:20
  • 7266

Java学习笔记---多线程同步的五种方法

一、引言 前几天面试,被大师虐残了,好多基础知识必须得重新拿起来啊。闲话不多说,进入正题。 二、为什么要线程同步 因为当我们有多个线程要同时访问一个变量或对象时,如果这些线程中既有读又有写操作时,就会...
  • wenwen091100304
  • wenwen091100304
  • 2015年09月09日 18:33
  • 20020

java笔记--关于线程同步(7种同步方式)

关于线程同步(7种方式)  --如果朋友您想转载本文章请注明转载地址"http://www.cnblogs.com/XHJT/p/3897440.html"谢谢--  为何要使用同步?  ...
  • yuqi007163
  • yuqi007163
  • 2016年12月08日 16:03
  • 1290

Java多线程同步的几种方式

Java多线程同步的几种方式
  • jsqfengbao
  • jsqfengbao
  • 2015年04月02日 20:53
  • 4562

java线程同步原理

一。 java线程同步原理 java会为每个object对象分配一个monitor,当某个对象的同步方法(synchronized methods)被多个线程调用时,该对象的monitor将负责处理...
  • mxlxiao7
  • mxlxiao7
  • 2012年09月12日 14:43
  • 2714

Java 多线程同步问题的探究-经典讲解

Java 多线程同步问题的探究(五、你有我有全都有—— ThreadLocal如何解决并发安全性?)【更新重要补疑】Java 多线程同步问题的探究(四、协作,互斥下的协作——Java多线程协作(wa...
  • liuhl0910
  • liuhl0910
  • 2015年05月20日 15:39
  • 1016

Java --- 线程同步和异步的区别

1. Java 线程 同步与异步多线程并发时,多个线程同时请求同一个资源,必然导致此资源的数据不安全,A线程修改了B线程的处理的数据,而B线程又修改了A线程处理的数理。显然这是由于全局资源造成的,有时...
  • u011033906
  • u011033906
  • 2016年12月23日 15:23
  • 1268

java中实现线程同步的7种方法

同步的方法: 一、同步方法   即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁,当用此关键字修饰方法时, 内置锁会保护整个方法。在调用该方法前,需要获得内置锁...
  • QQQQQQ654
  • QQQQQQ654
  • 2017年04月12日 16:09
  • 829

Java多线程之线程安全与同步实例

1.1    线程安全与同步实例 1.1.1  购票同步对象锁 【 /*  * 用程序模拟铁路售票系统:实现通过两个售票点发售某日某次列车的50张车票,  * 一个售票点用一个线程表示  ...
  • JourneyX
  • JourneyX
  • 2016年10月29日 20:47
  • 3404

跪求,Java里面的线程同步是个啥意思?

跪求,Java里面的线程同步是个啥意思? 2011-09-30 16:59loove_java  分类:JAVA相关 | 浏览 561 次  编程语言java 小弟的分不多,但是,回...
  • evilcry2012
  • evilcry2012
  • 2015年07月30日 09:18
  • 546
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章: Java线程同步 2
举报原因:
原因补充:

(最多只允许输入30个字)