并发编程（四）：并发工具类

前言

并发工具类大致分为四种：阻塞队列、信号量（Semaphore）、栅栏（Barrier）以及闭锁（Latch）。用于Java在并发编程中各种情况下使用；

闭锁– CountDownLatch

闭锁作用相当于一扇门：在闭锁到达某一状态之前，这扇门一直是关闭的，所有的线程都会在这扇门前等待（阻塞）。只有门打开后，所有的线程才会同时继续运行。

CountDownLatch 是一种灵活的闭锁实现，闭锁状态包含一个计数器，初始化为一个正数，表示要等待的事件数量。countDown() 方法会递减计数器，表示等待的事件中发生了一件。await() 方法则阻塞，直到计数器值变为0。

package com.tgb.height.并发工具类;

import java.util.concurrent.CountDownLatch;

public class UseCountDownLatch {

    public static void main(String[] args) {

        final CountDownLatch countDown = new CountDownLatch(2);


        System.out.println("进入线程主" + "等待其他线程处理完成...");


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t2线程进行初始化操作...");
                    Thread.sleep(3000);
                    System.out.println("t2线程初始化完毕，通知主线程继续...");
                    countDown.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t3线程进行初始化操作...");
                    Thread.sleep(4000);
                    System.out.println("t3线程初始化完毕，通知主线程继续...");
                    countDown.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();
        t3.start();
        try {
            countDown.await();
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        System.out.println("主线程继续执行...");
    }
}

分析：
声明一个计数器final CountDownLatch countDown = new CountDownLatch(2);；
当主线程进行countDown.await()，则只有等待子线程进行了2次countDown.countDown();后，主线程才会继续执行；

运行结果：

阻塞队列

声明一个队列，将线程挨个放到队列中，这样可以避免并发；

信号量（Semaphore）

闭锁控制访问的时间，而信号量则用来控制访问某个特定资源的操作数量，控制空间。

闭锁只能够减少，一次性使用，而信号量则申请可释放，可增可减。
计数信号量还可以用来实现某种资源池，或者对容器施加边界。
通俗讲，信号量限定一次资源访问最多有多少个线程的数量；

package com.tgb.height.并发工具类;

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Semaphore;  

public class UseSemaphore {  

    public static void main(String[] args) {  
        // 线程池  
        ExecutorService exec = Executors.newCachedThreadPool();  
        // 只能5个线程同时访问  
        final Semaphore semp = new Semaphore(5);  
        // 模拟20个客户端访问  
        for (int index = 0; index < 20; index++) {  
            final int Num = index;  
            Runnable run = new Runnable() {  
                public void run() {  
                    try {  
                        // 获取许可  
                        semp.acquire();  
                        System.out.println("Accessing: " + Num);  
                        //模拟实际业务逻辑
                        Thread.sleep((long) ( 1000));  
                        // 访问完后，释放  
                        semp.release();  
                        System.out.println("释放资源"+Num);
                    } catch (InterruptedException e) {  
                    }  
                }  
            };  
            exec.execute(run);  
          // System.out.println("--------------");
        } 

       // System.out.println("五个线程已满，其他线程等待！");

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

        //System.out.println(semp.getQueueLength());


        // 退出线程池  
        exec.shutdown();  
    }  

}  

结果：

创建线程0
Accessing: 0
创建线程1
创建线程2
创建线程3
创建线程4
Accessing: 1
创建线程5
创建线程6
创建线程7
创建线程8
创建线程9
Accessing: 2
创建线程10
创建线程11
创建线程12
创建线程13
创建线程14
创建线程15
创建线程16
创建线程17
创建线程18
Accessing: 4
Accessing: 3
创建线程19
释放资源0
Accessing: 5
释放资源1
Accessing: 6
Accessing: 7
释放资源2
释放资源4
Accessing: 8
释放资源3
Accessing: 9
释放资源5
Accessing: 10
释放资源6
Accessing: 11
释放资源7
Accessing: 12
释放资源8
Accessing: 13
Accessing: 14
释放资源9
Accessing: 15
释放资源10
释放资源11
Accessing: 16
释放资源12
Accessing: 17
释放资源13
Accessing: 18
释放资源14
Accessing: 19
释放资源15
释放资源16
释放资源17
释放资源18
释放资源19

分析：
可以看出20个线程是优先创建出来的；
当前五个线程访问时（0,1,2,4,3），后面的线程处于等待状态；
当第一个线程释放资源时（释放资源0），第六个线程才进入；
最后时刻，最少有五个线程连续释放资源；

栅栏（Barrier）

栅栏（Bariier）类似于闭锁，它能阻塞一组线程知道某个事件发生。栅栏与闭锁的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待等待时间，而栅栏用于等待线程。

通俗讲，就是限定一个数量，当线程数达到这个数量时，一起去执行；CyclicBarrier 可以使一定数量的参与方反复的在栅栏位置汇聚，它在并行迭代算法中非常有用：将一个问题拆成一系列相互独立的子问题。当线程到达栅栏位置时，调用await() 方法，这个方法是阻塞方法，直到所有线程到达了栅栏位置，那么栅栏被打开，此时所有线程被释放，而栅栏将被重置以便下次使用。

package com.tgb.height.并发工具类;
import java.io.IOException;  
import java.util.Random;  
import java.util.concurrent.BrokenBarrierException;  
import java.util.concurrent.CyclicBarrier;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors; 
public class UseCyclicBarrier {

    static class Runner implements Runnable {  
        private CyclicBarrier barrier;  
        private String name;  

        public Runner(CyclicBarrier barrier, String name) {  
            this.barrier = barrier;  
            this.name = name;  
        }  
        @Override  
        public void run() {  
            try {  
                Thread.sleep(1000 * (new Random()).nextInt(5));  
                System.out.println(name + " 准备OK.");  
                barrier.await();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } catch (BrokenBarrierException e) {  
                e.printStackTrace();  
            }  
            System.out.println(name + " Go!!");  
        }  
    } 

    public static void main(String[] args) throws IOException, InterruptedException {  
        CyclicBarrier barrier = new CyclicBarrier(3);  
        ExecutorService executor = Executors.newFixedThreadPool(3);  

        executor.submit(new Thread(new Runner(barrier, "张三")));  
        executor.submit(new Thread(new Runner(barrier, "李四")));  
        executor.submit(new Thread(new Runner(barrier, "王五")));  

        executor.shutdown();  
    }  

}  

结果：

王五 准备OK.
张三 准备OK.
李四 准备OK.
李四 Go!!
张三 Go!!
王五 Go!!

分析：
限定了栅栏的数量为3；
只有当三个线程都执行到一定程度后，并且数量达标，才能继续执行线程各自下面的操作；
线程创建后会先进入就绪状态，所以三个线程都有可能第一个执行；