CountDownLatch、CyclicBarrier和Semaphore区别

下面对上面说的三个辅助类进行一个总结：

　　1）CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

　　　　CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

　　　　而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

　　　　另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

　　2）Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。

package com.concurrent;

import java.util.concurrent.CountDownLatch;

/**
 * Created by jc6a on 2016/1/29.
 */
public class CountDownLatchTest {
    public static void main(String[] args)
    {
        final CountDownLatch latch = new CountDownLatch(2);
        new Thread(){
          public void run(){

              try {
                  System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                  Thread.sleep(3000);
                  System.out.println("子线程"+this.getName()+"执行完毕");
                  latch.countDown();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }

          }
        }.start();
        new Thread()
        {
          public void run()
          {
              try {
                  System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                  Thread.sleep(3000);
                  System.out.println("子线程"+this.getName()+"执行完毕");
                  latch.countDown();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
        }.start();

        try {
            System.out.println("等待2个子线程执行完毕...");
            latch.await();
            System.out.println("2个子线程已经执行完毕");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}





package com.concurrent;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * Created by jc6a on 2016/1/30.
 */
//回环栅栏
public class CyclicBarrierTest {
    public static void main(String[] args)
    {
            int N=4;
            CyclicBarrier cyclicBarrier = new CyclicBarrier(N);
            for(int i=0;i<N;i++)
            {
                new Writer(cyclicBarrier).start();
            }
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier)
        {
            this.cyclicBarrier = cyclicBarrier;
        }
        public void run()
        {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据。。。");
            try {
                Thread.sleep(1000);
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                try {
                    cyclicBarrier.await();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("所有线程写入完毕，继续处理其他任务。。。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}





package com.concurrent;

import java.util.concurrent.Semaphore;

/**
 * Created by jc6a on 2016/1/30.
 */
public class SemaphoreTest {
    public static void main(String[] args)
    {
        int N=8;
        Semaphore semaphore = new Semaphore(5);
        for(int i=0;i<N;i++)
        {
            new Worker(i,semaphore).start();
        }
    }
    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore)
        {
            this.num = num;
            this.semaphore = semaphore;
        }
        public void run()
        {
            try {
                semaphore.acquire();
                System.out.println("工人:"+this.num+"占用一个机器在生产");
                Thread.sleep(2000);
                System.out.println("工人:"+this.num+"释放出机器");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}