同步工具类闭锁用途可用于命令一组线程在同一个时刻开始执行某个任务或者等待一组相关的操作结束尤其适合计算并发执行某个任务的耗时。public class CountDownLatchTest { public void timeTasks(int nThreads, final Runnable task) throws InterruptedException { final CountDownLatch startGate new CountDownLatch(1); final CountDownLatch endGate new CountDownLatch(nThreads); for (int i 0; i nThreads; i) { Thread t new Thread() { Override public void run() { try { // 阻塞等待startGate.countDown()的执行 startGate.await(); try { task.run(); } finally { // 每次执行完毕后计数器减1表示有一个事件已经完成 endGate.countDown(); } } catch(InterruptedException e) { System.out.println(Throw Exception, e: e.toString()); } } }; // 启动线程 t.start(); } long start System.nanoTime(); System.out.println(打开闭锁); startGate.countDown(); // 打开开关进入startGate.await()后面的逻辑 endGate.await(); // 等待所有线程endGate.countDown()全部执行完毕 long end System.nanoTime(); System.out.println(闭锁退出共耗时 (end-start)); } class RunnableTask implements Runnable { Override public void run() { System.out.println(当前线程为 Thread.currentThread().getName()); } } public static void main(String args[]) throws InterruptedException { CountDownLatchTest test new CountDownLatchTest(); test.timeTasks(5, test.new RunnableTask()); } } // 输出 // 打开闭锁 // 当前线程为Thread-0 // 当前线程为Thread-2 // 当前线程为Thread-1 // 当前线程为Thread-3 // 当前线程为Thread-4 // 闭锁退出共耗时1985771里面的注释其实已经很清晰了简单总结一下流程初始化startGate和endGate的计数器分别为1和5开启5个线程去执行RunnableTask任务5个线程启动后会全部阻塞在startGate.await()当调用startGate.countDown()startGate计数器为0线程阀门放开开始一起去执行每个线程任务task.run()每个线程执行完毕后会调用endGate.countDown()每调用一次endGate的计数器减去1线程执行过程中主线程通过endGate.await()阻塞当所有线程执行完毕endGate计数器为0主线程endGate.await()阻塞放开执行后面收尾流程流程结束。这个和Go的sync.WaitGroup简直一毛一样啊看来语言的设计很多都差不多。FutureTaskFutureTask也可以用作闭锁它是通过Callabale来实现相当于一种可以生成结果的Runnable并且可以处于以下3种状态等待状态正在运行和运行完成。Future.get的行为取决于任务的状态如果任务已经完成那么get会立即返回结果否则get将阻塞到任务进入完成状态然后返回结果或者抛出异常。Data Service public class Cat { private String catName; } public class Preloader { private final FutureTaskCat future new FutureTaskCat(new CallableCat() { Override public Cat call() throws InterruptedException { Cat cat new Cat(); cat.setCatName(罗小黑); for (int i 1; i 5; i ) { // 睡眠1秒方便大家看执行效果 Thread.sleep(1000L); System.out.println(Sleep i 秒); } return cat; } }); private final Thread thread new Thread(future); public void start() { System.out.println(启动Start); thread.start(); } public Cat get() throws ExecutionException, InterruptedException { Cat cat null; try { System.out.println(开始获取数据); // 阻塞等待线程执行完毕 cat future.get(); System.out.println(获取数据成功); } catch (ExecutionException e) { // 异常处理省略... } return cat; } public static void main(String args[]) throws ExecutionException, InterruptedException { Preloader preloader new Preloader(); preloader.start(); Cat cat preloader.get(); System.out.println(cat.toString()); } } // 输出 // 启动Start // 开始获取数据 // Sleep 1 秒 // Sleep 2 秒 // Sleep 3 秒 // Sleep 4 秒 // Sleep 5 秒 // 获取数据成功 // Cat(catName罗小黑)我们可以看到获取Cat数据时主线程一直阻塞住直到Cat成功构造好数据后才正常返回简单总结一下流程初始化线程对象Thread和FutureTask静态对象其中FutureTask的Callable是构造Cat数据启动线程thread.start()开始执行future中Callable.call()方法开始构造Cat数据在Cat数据构造成功前future.get()会一直阻塞直到future中Callable.call()成功返回阻塞结束。信号量用途用来控制同时访问某个特定资源的操作数量或者同时执行某个指定操作的数量。计数信号量可以用来实现某种资源池或者对容器施加边界。public class SemaphoreTestT { public final SetT set; private final Semaphore sema; public SemaphoreTest(int bound){ this.set Collections.synchronizedSet(new HashSetT()); this.sema new Semaphore(bound); } public boolean add(T o) throws InterruptedException{ sema.acquire(); boolean wasAdded false; try{ wasAdded set.add(o); return wasAdded; }finally{ if(!wasAdded){ sema.release(); } } } public boolean remove(T o){ boolean wasRemoved set.remove(o); if(wasRemoved){ sema.release(); } return wasRemoved; } public static void main(String[] args) throws InterruptedException{ int permits 5; SemaphoreTestInteger test new SemaphoreTestInteger(permits); for(int i 0; i 10; i){ test.add(i); System.out.println(set: test.set); } } } // 输出 // set:[0] // set:[0, 1] // set:[0, 1, 2] // set:[0, 1, 2, 3] // set:[0, 1, 2, 3, 4]这个示例就很简单描述一下流程先初始化信号量sema的许可个数为5通过add()添加数据每添加一个数据就消耗sema的一个许可当5个许可全部消耗完毕后如果需要再添加数据因为sema的许可为0阻塞请求。备注如果这个时候调用了sema.release()会释放一个许可那么add()会继续添加一个元素之后的请求继续阻塞直到有新的许可释放。栅栏上面介绍的都是闭锁的几种实现方式栅栏类似于闭锁它能阻塞一组线程直到某个时间发生。栅栏和闭锁的关键区别在于所有线程必须同时到达栅栏位置才能继续执行。书中有一句哈总结的很好闭锁用于等待事件而栅栏用于等待其它线程。用途用于阻塞一组线程直到某个事件发生。所有线程必须同时到达栅栏位置才能继续执行下一步操作且能够被重置以达到重复利用。而闭锁式一次性对象一旦进入终止状态就不能被重置。public class CyclicBarrierWorker implements Runnable { private int id; private CyclicBarrier barrier; public CyclicBarrierWorker(int id, final CyclicBarrier barrier) { this.id id; this.barrier barrier; } Override public void run() { try { if (id 5) { // 让第5个线程sleep 10秒 Thread.sleep(10000); } System.out.println(id people wait); barrier.await(); // 大家等待最后一个线程到达 } catch (InterruptedException | BrokenBarrierException e) { e.printStackTrace(); } } } class TestCyclicBarrier { public static void main(String[] args) { int num 10; // 新建一个栅栏 CyclicBarrier barrier new CyclicBarrier(num, new Runnable() { Override public void run() { // num个线程全部执行完毕且都调用barrier.await()才会去执行该方法 // 可以理解为计数器初始值为num每调用一次barrier.await()计数器-1直到计数器等于0 System.out.println(go on together!); } }); for (int i 1; i num; i) { new Thread(new CyclicBarrierWorker(i, barrier)).start(); } } } // 输出 // 1 people wait // 3 people wait // 4 people wait // 2 people wait // 6 people wait // 7 people wait // 8 people wait // 9 people wait // 10 people wait // 5 people wait // go on together!我故意让第5个线程sleep了10秒所以大家都等第五个线程全部执行完毕后再一起去执行栅栏中的任务简单总结一下流程新建一个栅栏第一个参数num是线程个数第二个参数是栅栏需要执行的任务启动10个线程每个线程传入栅栏变量这10个线程开始执行然后都阻塞在barrier.await()大家都在等待最后一个线程的到达当最后一个线程到达barrier.await()后阻塞放开开始执行栅栏中的方法。创建线程的三种方式如果大家对线程创建非常清楚可以直接跳过“创建线程的三种方式”这部分内容该部分内容主要给Java小白扫盲。继承Thread类继承Thread类并复写run()方法是一种很简单的方式代码如下public class MyThread extends Thread { public MyThread(String name) { super(name); } Override public void run() { String name Thread.currentThread().getName(); System.out.println(name 已经运行); } public static void main(String[] args) { new MyThread(线程一).start(); } } // 输出 // 线程一已经运行实现Runnable接口这个是我们经常使用的方式之一代码如下public class MyTask implements Runnable { Override public void run() { String name Thread.currentThread().getName(); System.out.println(name 已经运行); } public static void main(String[] args) { new Thread(new MyTask(),线程二).start(); } } // 输出 // 线程二已经运行Callable与Future创建线程我们看到不管是Thread还是Runable接口其run()都是无返回值的并且无法抛出异常的如果我们有需要返回值或者抛出异常怎么办这个时候就需要用到Callable与Feature了。先来看类的继承关系:可以看到Callable是一个接口里面有个V call()方法这个V就是我们返回值类型同时还有Future相关的类注意观察FutureTask类的构造函数我们发现其中一个构造函数的参数是Callable类型这里就把两个内联系起来了。Callable与Future的用法如下public class CallableTest { private void callTest() { //这里指定返回String类型 CallableString callable new CallableString() { Override public String call() throws Exception { System.out.println(Callable 已经运行啦); return this is Callable is running; } }; FutureTaskString futureTask new FutureTaskString(callable); futureTask.run(); try { if (futureTask.isDone()){ //任务完成 System.out.println(futureTask.get()); } } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } public static void main(String[] args) { CallableTest test new CallableTest(); test.callTest(); } }用法一般都先new一个Callable对象并重写里面的call()方法这个方法需要借助FutureTask来执行当通过Callable对象生成FutureTask对象后直接执行futureTask.run()即可调用Callable对象的call()方法。我们还可以通过Future提供的接口对任务进行如下操作public interface FutureV { // 取消任务如果任务正在运行的mayInterruptIfRunning为true时表明这个任务会被打断的并返回true // 为false时会等待这个任务执行完返回true若任务还没执行取消任务后返回true如任务执行完返回false boolean cancel(boolean mayInterruptIfRunning); // 判断任务是否被取消了,正常执行完不算被取消 boolean isCancelled(); // 判断任务是否已经执行完成任务取消或发生异常也算是完成返回true boolean isDone(); // 获取任务返回结果如果任务没有执行完成则等待完成将结果返回如果获取的过程中发生异常就抛出异常 // 比如中断就会抛出InterruptedException异常等异常 V get() throws InterruptedException, ExecutionException; // 在规定的时间如果没有返回结果就会抛出TimeoutException异常 V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }原理其实FutureTask内部实现比较简单Callable就是他的任务而FutureTask内部维护了一个任务状态所有的状态都是围绕这个任务来进行的随着任务的进行状态也在不断的更新。任务发起者调用get()方法时如果任务没有执行完成会将当前线程放入阻塞队列等待当任务执行完后会唤醒阻塞队列中的线程。总结这篇文章讲解了Java常用的同步工具类这是很多是《Java并发编程实战》书里面的内容但是当我看书时感觉书中讲的知识并不容易懂对于不懂的地方我就到网上找一些相关示例或者对一些基础知识做一些扫盲。所以大家看书时不懂的地方可以跳过去然后再单独对于不懂的知识点到网上查阅资料因为网上有很多博客写的真的是非常好比很多书籍作者表述的要好很多这个也算是我看书的一点点心得。