java常用同步工具类

阻塞队列：

BlockingQueue接口定义了可阻塞的put和take方法，同时也提供了非阻塞式的offer和poll方法。如果队列已满，那么put方法将阻塞直到有空间可用，如果队列为空那么take方法将会阻塞直到队列中有元素可以使用。而offer以及poll两个方法当队列已满或者队列为空而存储失败的时候，返回false。因此阻塞队列是利用队列的存储状态来控制线程的执行状态。

可以利用阻塞队列使用生产者——消费者模式，生产者把数据放入队列，而消费者从队列中读取数据，生产者不需要知道消费者的状态和数量，消费者同样不需要知道生产者是谁，只是从队列中读取数据进行使用。

package com.pingan.home.demo;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

public class BlockQueueShow {

static BlockingQueue<Integer> blockingQueue = new LinkedBlockingDeque<Integer>();;

public static void main(String[] args) {
Thread product = new Thread(new BlockQueueCreate());
Thread consumer = new Thread(new BlockQueueConsumer());
product.start();
consumer.start();
}

}

class BlockQueueCreate implements Runnable {

@Override
public void run() {
try {
for (int i = 0; i < 10; i++) {
BlockQueueShow.blockingQueue.put(i);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}

}

class BlockQueueConsumer implements Runnable {

@Override
public void run() {
try {
while (true) {
System.out.println("Take:"+BlockQueueShow.blockingQueue.take());
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}

}

闭锁

闭锁可以延迟线程的进度直到其到达终止状态，闭锁相当于一扇门，初始状态为关闭的，没有任何线程可以通过，当满足一定的条件之后，闭锁这扇门会打开，允许所有的线程通过。闭锁可以确保某些任务知道其他的任务都完成之后才继续执行。

CountDownLatch是闭锁的一种实现，其状态包括一个计数器，该计数器在创建闭锁的时候被初始化为一个正整数，表示需要等待的事件数量。countDown方法用来改变闭锁的状态，调用一个闭锁的计数器就会递减，await方法会一直阻塞直到计数器变为0才开始执行。

package com.pingan.home.demo;

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

public class CountDownLatchShow {

/* 模拟了100米赛跑，10名选手已经准备就绪，只等裁判一声令下。当所有人都到达终点时，比赛结束。 */
public static void main(String[] args) throws InterruptedException {

ExecutorService runners = Executors.newFixedThreadPool(10);
/* 十名选手 */
for (int i = 0; i < 10; i++) {
Runner runner=new Runner();
runners.submit(runner);
}
/* begin减一，开始游戏 */
CountDownLatchUtil.begin.countDown();
long beginTime = System.nanoTime();
/* 等待end变为0，即所有选手到达终点 */
CountDownLatchUtil.end.await();
long lastEndTime = System.nanoTime();
System.out.println(lastEndTime - beginTime);
runners.shutdown();
}

}
class CountDownLatchUtil{
/* 开始的倒数锁 */
final static CountDownLatch begin = new CountDownLatch(1);
/* 结束的倒数锁 */
final static CountDownLatch end = new CountDownLatch(10);
}
class Runner implements Runnable {

@Override
public void run() {

try {
System.out.println(Thread.currentThread().getName()+ ":准备好");
long everyoneStartTime = System.nanoTime();
/**
* 1.如果当前计数为零，则此方法立即返回,顺序执行下面代码。
* 2.等待(begin.countDown()代码后才会释放所有等待线程)
*/
CountDownLatchUtil.begin.await();
Thread.sleep((long) (Math.random() * 1000));
long everyoneEndTime = System.nanoTime();
System.out.println(Thread.currentThread().getName()+ "：跑完"+ (everyoneEndTime - everyoneStartTime));
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
/* 每个选手到达终点时，end就减一 */
CountDownLatchUtil.end.countDown();
}
}

}

信号量

计数信号量（Counting Semaphore）用来控制同时访问某个特定资源的操作数量，或者同时执行某个指定操作的数量，计数信号量还可以用来实现某种资源池或者对容器施加边界。

Semaphore中管理者一组虚拟的许可，通过构造函数来进行初始化。在执行操作的时候可以首先获得许可（r如果还有剩余的许可），并在使用后释放许可，如果没有许可那么acquire方法将阻塞直到有许可。release方法将返回一个许可信号量。因此我们可用使用Semaphore将任何容器变成有界的阻塞容器。

package com.pingan.home.demo;

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

public class SemaphoreShow {

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 NO = index;
Runnable run = new Runnable() {
public void run() {
try {
// 获取许可
semp.acquire();
System.out.println("Accessing: " + NO);
Thread.sleep((long) (Math.random() * 10000));
// 访问完后，释放 ，如果屏蔽下面的语句，则在控制台只能打印5条记录，之后线程一直阻塞
semp.release();
} catch (InterruptedException e) {
}
}
};
exec.execute(run);
}
// 退出线程池
exec.shutdown();
}
}