java中的线程(4)：常用同步类 CountDownLatch、CyclicBarrier和Semaphore

转自：

　　http://www.cnblogs.com/dolphin0520/p/3920397.html

1.简介

• CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同。
• CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行
• CyclicBarrier 回环栅栏，一般用于一组线程互相等待至某个状态，然后这一组线程再同时开始执行后续任务
• CountDownLatch 在使用完后不可重用
• CyclicBarrier 使用完后可重用
• Semaphore 信号量，一般用于控制对某组资源的访问权限。

2.CountDownLatch示例

   void testCountDownLatch() {
        final CountDownLatch latch = new CountDownLatch(2);
        new Thread() {
            public void run() {
                try {
                    Log.d(TAG, "子线程" + Thread.currentThread().getName() + "正在执行");
                    Thread.sleep(3000);
                    Log.d(TAG, "子线程" + Thread.currentThread().getName() + "执行完毕");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            ;
        }.start();

        new Thread() {
            public void run() {
                try {
                    Log.d(TAG, "子线程" + Thread.currentThread().getName() + "正在执行");
                    Thread.sleep(3000);
                    Log.d(TAG, "子线程" + Thread.currentThread().getName() + "执行完毕");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            ;
        }.start();

        try {
            Log.d(TAG, "等待2个子线程执行完毕...");
            latch.await();
            Log.d(TAG, "2个子线程已经执行完毕");
            Log.d(TAG, "继续执行主线程");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

3.CyclicBarrier示例

static class Writer extends Thread {
        private CyclicBarrier cyclicBarrier;

        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            Log.d(TAG, "线程" + Thread.currentThread().getName() + "正在写入数据...");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                Log.d(TAG, "线程" + Thread.currentThread().getName() + "写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            Log.d(TAG, "所有线程写入完毕，继续处理其他任务...");
        }
    }


    //用来阻塞当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
    void testCyclicBarrier1(){
        int N = 4;
        CyclicBarrier barrier = new CyclicBarrier(N);
        for (int i = 0; i < N; i++) {
            new Writer(barrier).start();
        }
    }

    //如果说想在所有线程写入操作完之后，进行额外的其他操作可以为CyclicBarrier提供Runnable参数
    void testCyclicBarrier2(){
        int N = 4;
        CyclicBarrier barrier = new CyclicBarrier(N, new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "当前线程" + Thread.currentThread().getName());
            }
        });

        for (int i = 0; i < N; i++){
            new Writer(barrier).start();
        }
    }

    //CyclicBarrier是可以重用的
    void testCyclicBarrier3(){
        int N = 4;
        CyclicBarrier barrier = new CyclicBarrier(N);

        for (int i = 0; i < N; i++) {
            new Writer(barrier).start();
        }

        try {
            Thread.sleep(25000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Log.d(TAG, "CyclicBarrier重用");

        for (int i = 0; i < N; i++) {
            new Writer(barrier).start();
        }
    }

    //故意让最后一个线程启动延迟，因为在前面三个线程都达到barrier之后，
    //等待了指定的时间发现第四个线程还没有达到barrier，就抛出异常并继续执行后面的任务。
    void testCyclicBarrier4(){

        int N = 4;
        CyclicBarrier barrier = new CyclicBarrier(N);

        for (int i = 0; i < N; i++) {
            if (i < N - 1)
                new Writer2(barrier).start();
            else {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                new Writer(barrier).start();
            }
        }
    }
    static class Writer2 extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer2(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            Log.d(TAG, "线程"+Thread.currentThread().getName()+"正在写入数据...");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                Log.d(TAG, "线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                try {
                    cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);//等待了指定的时间(2ms)发现第四个线程还没有达到barrier，就抛出异常并继续执行后面的任务
                } catch (TimeoutException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            Log.d(TAG, Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
        }
    }

4.Semaphore示例

    void testSemaphore() {
        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;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                Log.d(TAG,"工人" + this.num + "占用一个机器在生产...");
                Thread.sleep(2000);
                Log.d(TAG,"工人" + this.num + "释放出机器");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }