Java.concurrent.*

Java concurrent

 

CountDownLatch 使用详解

CountDownLatch下面例子比较简单

Java代码   import  java.util.concurrent.CountDownLatch;      public   class  CountDownLatchTest {             static   class  SimpleThread  extends  Thread {              private  CountDownLatch latch;              public  SimpleThread(CountDownLatch latch){               this .latch = latch;           }                     @Override            public   void  run() {               System.out.println(this  +  " RUNNING." );               latch.countDown();           }                 }          public   static   void  main(String[] args)  throws  InterruptedException {           CountDownLatch latch = new  CountDownLatch( 5 );                     for ( int  i= 0 ; i< 5 ; i++) {               new  SimpleThread(latch).start();           }                     //等待所有子线程处理完成。            latch.await();           System.out.println("Over" );       }   }      运行结果：   Thread[Thread-2 , 5 ,main] RUNNING.   Thread[Thread-0 , 5 ,main] RUNNING.   Thread[Thread-1 , 5 ,main] RUNNING.   Thread[Thread-4 , 5 ,main] RUNNING.   Thread[Thread-3 , 5 ,main] RUNNING.   Over 

CyclicBarrier使用详解

Java代码   import  java.util.Random;   import  java.util.concurrent.CyclicBarrier;      /** */ /**    * CyclicBarrier类似于CountDownLatch也是个计数器，    * 不同的是CyclicBarrier数的是调用了CyclicBarrier.await()进入等待的线程数，    * 当 等待的 线程数达到了CyclicBarrier初始时规定的数目时，所有进入等待状态的线程被唤醒并继续。    * CyclicBarrier就象它名字的意思一样，可看成是个障碍，    * 所有的线程必须到齐后才能一起通过这个障碍。    * CyclicBarrier初始时还可带一个Runnable的参数，    * 此Runnable任务在CyclicBarrier的 等待的线 数目达到 初始时规定的数目 后，所有其它线程被唤醒前被执行。    */    public   class  CyclicBarrierTest {          public   static   class  ComponentThread  implements  Runnable {           CyclicBarrier barrier;// 计数器            int  ID;     // 组件标识            int [] array;     // 数据数组               // 构造方法            public  ComponentThread(CyclicBarrier barrier,  int [] array,  int  ID) {               this .barrier = barrier;               this .ID = ID;               this .array = array;           }              public   void  run() {               try  {                   array[ID] = new  Random().nextInt( 100 );                   System.out.println("Component "  + ID +  " generates: "  + array[ID]);                   // 在这里等待Barrier处                    System.out.println("Component "  + ID +  " sleep" );                   barrier.await();                   System.out.println("Component "  + ID +  " awaked" );                   // 计算数据数组中的当前值和后续值                    int  result = array[ID] + array[ID +  1 ];                   System.out.println("Component "  + ID +  " result: "  + result);               } catch  (Exception ex) {               }           }       }       /** */ /**        * 测试CyclicBarrier的用法        */        public   static   void  testCyclicBarrier() {           final   int [] array =  new   int [ 3 ];           CyclicBarrier barrier = new  CyclicBarrier( 2 ,  new  Runnable() {               // 在所有线程都到达Barrier时执行                public   void  run() {                   System.out.println("testCyclicBarrier run" );                   array[2 ] = array[ 0 ] + array[ 1 ];               }           });              // 启动线程            new  Thread( new  ComponentThread(barrier, array,  0 )).start();           new  Thread( new  ComponentThread(barrier, array,  1 )).start();       }          public   static   void  main(String[] args) {           CyclicBarrierTest.testCyclicBarrier();       }   }   说明：在main中执行testCyclicBarrier方法 执行到CyclicBarrier barrier = new CyclicBarrier(2, new Runnable()...)时 Runnable的参数是在CyclicBarrier的数目达到2时并且所有被CyclicBarrier.await()进入等待的线程被唤醒前执行。 所以继续执行下面的两个线程 new Thread(new ComponentThread(barrier, array, 0)).start(); new Thread(new ComponentThread(barrier, array, 1)).start(); 执行public void run()方法，分别执行，互不影响 执行到barrier.await();时该线程进入等待状态，当两个线程都执行完barrier.await();时，进入到new CyclicBarrier(2, new Runnable()...)里面的方法， 执行完里面的方法后，等待的两个线程再次被唤醒，继续各自执行线程后面的语句。