Android多线程-------同步辅助类

一、循环栅栏 CyclicBarrier
CyclicBarrier是一个同步辅助类，允许一组线程互相等待，直到达到某个公共屏障点。因为该Barrier在释放等待线程后可以重用，所以，称它为循环的Barrier
示例:

public class CyclicBarrierTest {
    private static final int SIZE = 5;
    private static CyclicBarrier mCyclicBarrier ;

    public static void main(String[] args){
        mCyclicBarrier = new CyclicBarrier(SIZE, new Runnable() {
            @Override
            public void run() {
                System.out.println("---->满足条件，执行特定操作。参与者: " +mCyclicBarrier.getParties());
            }
        }) ;

        //创建5个任务
        for (int i = 0; i < SIZE; i++) {
            new WorkerThread().start();
        }
    }
    static class WorkerThread extends  Thread{
        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName()+" 等待 CyclicBarrier.");
                mCyclicBarrier.await();
                System.out.println(Thread.currentThread().getName() +" 继续执行.");
            }catch (BrokenBarrierException e){
                    e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
执行结果:
Thread-0 等待 CyclicBarrier.
Thread-4 等待 CyclicBarrier.
Thread-1 等待 CyclicBarrier.
Thread-2 等待 CyclicBarrier.
Thread-3 等待 CyclicBarrier.
---->满足条件，执行特定操作。参与者: 5
Thread-3 继续执行.
Thread-1 继续执行.
Thread-4 继续执行.
Thread-0 继续执行.
Thread-2 继续执行.

二、闭锁 CountDownLatch
CountDownLatch也是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直在等待，直到线程被满足。
示例:

public class CountDownLatchTest {

    private static int LATCH_SIZE = 5;

    public static void main(String[] args) {

        try {
            CountDownLatch latch = new CountDownLatch(LATCH_SIZE);
            //新建5个任务
            for (int i = 0; i < LATCH_SIZE; i++) {
                new WorkerThread(latch).start();
            }
            System.out.println("主线程等待.");
            latch.await();
            System.out.println("主线程继续执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class WorkerThread extends Thread {
        CountDownLatch mLatch;

        public WorkerThread(CountDownLatch latch) {
            mLatch = latch;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " 执行操作.");
                //将CountDownLatch 的数值减1
                mLatch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
执行结果:
主线程等待.
Thread-0 执行操作.
Thread-3 执行操作.
Thread-2 执行操作.
Thread-1 执行操作.
Thread-4 执行操作.
主线程继续执行

CountDownLatch与CyclicBarrier的不同点：
（1）CountDownLatch的作用是允许1个或N个线程等待其他线程完成执行，而CyclicBarrier 则是允许N个线程相互等待。
（2)CountDownLatch的计数器无法被重置，CyclicBarrier的技术器可以被重置后使用，因此他被称为循环的Barrier。