[TOC]
Java同步组件详情
- CountDownLatch : 是闭锁,通过一个计数来保障线程是否始终阻塞
- Semaphore: 管制同一时间,并发线程数量
- CyclicBarrier:字面意思是回环栅栏,通过它能够实现让一组线程期待至某个状态之后再全副同时执行。
- ReentrantLock:是一个重入锁,一个线程取得了锁之后依然能够重复加锁,不会呈现本人阻塞本人的状况。
- Condition:配合
ReentrantLock,实现期待/告诉模型 - FutureTask:FutureTask实现了接口Future，同Future一样，代表异步计算的后果。
CyclicBarrier介绍
CycliBarrier是一个同步辅助类,它容许一组线程互相期待,直到达到某个公共的屏障点(common barrier point),也称之为栅栏点。通过它能够多个线程之间的互相期待,只有当每个线程都准备就绪后,能力各自实现后续的操作。它和CountDownLatch有类似的中央,都是通过计数器实现。当某个线程调用await()办法之后,该线程就进去了期待状态,计数器执行的是加一操作,当计数器达到初始值,后面调用await()的线程会被唤醒,继续执行前面的操作。因为CyclicBarrier在期待线程开释后,能够被重用,所以被称为循环屏障。
与CountDownLatch比拟
相同点
- 都是同步辅助类
- 应用计数器实现
不同点
CyclicBarrier容许一个或多个线程,期待其它一组线程实现操作,再继续执行。CyclicBarrier容许一组线程之间互相期待,达到一个共同点,再继续执行。CountDownLatch不能被复用。CyclicBarrier适宜更简单的业务场景,如计算产生谬误,通过重置计数器,并让线程从新执行。CyclicBarrier还提供其它有用的办法,比方getNumberWaiting办法能够取得CyclicBarrier阻塞的线程数量,isBroken办法用来晓得阻塞的线程是否被中断。
CountDownLatch和CyclicBarrier的场景比拟
CyclicBarrier: 好比一扇门，默认状况下敞开状态，堵住了线程执行的路线，直到所有线程都就位，门才关上，让所有线程一起通过。
CyclicBarrier能够用于多线程计算数据，最初合并计算结果的利用场景。比方咱们用一个Excel保留了用户所有银行流水，每个Sheet保留一个帐户近一年的每笔银行流水，当初须要统计用户的日均银行流水，先用多线程解决每个sheet里的银行流水，都执行完之后，失去每个sheet的日均银行流水，最初，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水。
CountDownLatch: 监考老师发下去试卷，而后坐在讲台旁边玩着手机期待着学生答题，有的学生提前交了试卷，并约起打球了，等到最初一个学生交卷了，老师开始整顿试卷，贴封条
代码演示
package com.rumenz.task.CyclicBarrier;import java.util.concurrent.CyclicBarrier;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class CyclicBarrierExample { public static void main(String[] args) { CyclicBarrier cyclicBarrier=new CyclicBarrier(2,new Runnable(){ @Override public void run() { System.out.println("汇总计算----"); } }); ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(()->{ try{ System.out.println("计算昨天的数据"); Thread.sleep(5000); cyclicBarrier.await(); }catch (Exception e){ e.printStackTrace(); } }); executorService.execute(()->{ try{ System.out.println("计算明天的数据"); Thread.sleep(3000); cyclicBarrier.await(); }catch (Exception e){ e.printStackTrace(); } }); executorService.shutdown(); }}//计算昨天的数据//计算明天的数据//汇总计算----ReentrantLock可重入锁
JAVA中的锁分两类:synchronized关键字与J.U.C所提供的锁。J.U.C的外围锁是ReentrantLock,实质上都是lock与unlock的操作。
ReentrantLock(可重入锁)和synchronized的区别
可重入性：ReentrantLock字面意思即为再进入锁，称为可重入锁，其实synchronize所应用的锁也是能够重入的，两者对于这个区别不大，它们都是同一个线程进入一次，锁的计数器进行自增，要等到锁的计数器降落为零时，能力开释锁锁的实现：synchronized依赖于JVM实现无奈理解底层源码，而ReentrantLock基于JDK实现。通过浏览源码，区别就相似于操作系统管制实现与用户应用代码实现。
性能区别：在synchronized优化以前，性能比ReentrantLock差很多，但自从synchronize引入了偏差锁、轻量级锁（自选锁）后 ，也就是自循锁后，两者性能差不多（JDK1.6当前，为了缩小取得锁和开释锁所带来的性能耗费，进步性能，引入了“轻量级锁”和“偏差锁”）。在两种场景下都能够应用，官网更举荐应用synchronized，因为写法更容易。synchronized的优化其实是借鉴了ReentrantLock中的CAS技术，都是试图在用户态就把加锁问题解决，防止进入内核态的线程阻塞。
ReentrantLock与synchronized的性能区别
synchronized更加便当,它由编译器保障加锁与开释。ReentrantLock须要手动申明和开释锁,所以为了防止遗记手动开释锁造成死锁,所以最好在finally中申明开释锁。ReentrantLock的锁粒度更细更灵便。
ReentrantLock特有性能
ReentrantLock能够指定为偏心或者非偏心,synchronized是能是非偏心锁。(偏心锁的意思就是先期待的锁先取得锁)- 提供一个
Condition类,它能够分组唤醒须要唤醒的线程。不像synchronized要么随机唤醒一个,要么全副唤醒。 - 提供可能中断期待锁的线程的机制，通过lock.lockInterruptibly()实现，这种机制ReentrantLock是一种自选锁，通过循环调用CAS操作来实现加锁。性能比拟好的起因是防止了进入内核态的阻塞状态。想进方法防止线程进入内核阻塞状态， 是咱们剖析和了解锁设计的要害
如果满足ReentrantLock三个独有的性能，那么必须应用ReentrantLock。其余状况下能够依据性能、业务场景等等来抉择synchronized还是ReentrantLock
synchronized的应用场景
synchronized能做的，ReentrantLock都能做；而ReentrantLock能做的，而synchronized却不肯定做得了。性能方面，ReentrantLock不比synchronized差
- J.U.C包中的锁定类是用于高级状况和高级用户的工具，除非说你对Lock的高级个性有特地分明的理解以及有明确的须要，或这有明确的证据表明同步曾经成为可伸缩性的瓶颈的时候，否则咱们还是持续应用synchronized
- 相比拟这些高级的锁定类，synchronized还是有一些劣势的，比方synchronized不可能遗记开释锁。 在退出synchronized块时，JVM会主动开释锁，会很容易遗记要应用finally开释锁，这对程序十分无害。
- 还有当JVM应用synchronized治理锁定申请和开释时，JVM在生成线程转储时可能包含锁定信息，这些信息对调试十分有价值，它们能够标识死锁以及其余异样行为的起源。 而Lock类常识一般的类，JVM不晓得哪个线程具备Lock对象，而且简直每个开发人员都是比拟相熟synchronized
代码演示
package com.rumenz.task;import com.google.common.net.InternetDomainName;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Semaphore;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class ReentrantLockExample { private static Integer clientTotal=5000; private static Integer threadTotal=200; public static Integer count=0; // 申明锁的实例,调用构造方法，默认生成一个不偏心的锁 private final static Lock lock=new ReentrantLock(); public static void main(String[] args) throws Exception{ ExecutorService executorService = Executors.newCachedThreadPool(); final Semaphore semaphore=new Semaphore(threadTotal); final CountDownLatch countDownLatch=new CountDownLatch(clientTotal); for (int i = 0; i < clientTotal; i++) { executorService.execute(()->{ try{ semaphore.acquire(); update(); semaphore.release(); }catch (Exception e){ e.printStackTrace(); } countDownLatch.countDown(); }); } countDownLatch.await(); executorService.shutdown(); System.out.println("count:"+count); } private static void update() { lock.lock(); try{ count++; }finally { lock.unlock(); } }}//count:5000ReentrantLock罕用办法
tryLock()：仅在调用时锁定未被另一个线程放弃的状况下才获取锁定。tryLock(long timeout, TimeUnit unit)：如果锁定在给定的工夫内没有被另一个线程放弃且以后线程没有被中断，则获取这个锁定。lockInterruptbily()：如果以后线程没有被中断的话，那么就获取锁定。如果中断了就抛出异样。isLocked()：查问此锁定是否由任意线程放弃isHeldByCurrentThread：查问以后线程是否放弃锁定状态。isFair：判断是不是偏心锁ReentrantReadWriteLock 读写锁
public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable { /** 外部类提供的读锁 */ private final ReentrantReadWriteLock.ReadLock readerLock; /** 外部类提供的读锁 */ private final ReentrantReadWriteLock.WriteLock writerLock;}ReentrantReadWriteLock提供了ReadLock和WriteLock,在没有任何读写锁时,才能够获得写入锁。如果进行读取时,可能有另外一个写入的申请,为了放弃同步,读取锁定。
ReentrantReadWriteLock写锁是互斥的,也就是说,读和读是不互斥的,然而读和写,写和读是互斥的。在没有任何读写锁的时候才能够获得写入锁(乐观读取，容易写线程饥饿)，也就是说如果始终存在读操作，那么写锁始终在期待没有读的状况呈现，这样我的写锁就永远也获取不到，就会造成期待获取写锁的线程饥饿。所以，此类不能乱用，在应用是肯定要把握其个性与实现形式。
ReentrantReadWriteLock是Lock的另一种实现形式，咱们曾经晓得了ReentrantLock是一个排他锁，同一时间只容许一个线程拜访，而ReentrantReadWriteLock容许多个读线程同时拜访，但不容许写线程和读线程、写线程和写线程同时拜访。绝对于排他锁，进步了并发性。在理论利用中，大部分状况下对共享数据（如缓存）的拜访都是读操作远多于写操作，这时ReentrantReadWriteLock可能提供比排他锁更好的并发性和吞吐量。
ReentrantReadWriteLock代码演示
package com.rumenz.task.reentrant;import java.util.Map;import java.util.Set;import java.util.TreeMap;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Semaphore;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReentrantLockExample { private static Integer clientTotal=5000; private static Integer threadTotal=200; private static LockMap map=new LockMap(); public static void main(String[] args) throws Exception { ExecutorService executorService = Executors.newCachedThreadPool(); final CountDownLatch countDownLatch=new CountDownLatch(clientTotal); final Semaphore semaphore=new Semaphore(threadTotal); for (int i = 0; i < 2500; i++) { final Integer m=i; executorService.execute(()->{ try{ semaphore.acquire(); map.put(m+"",m+""); semaphore.release(); }catch (Exception e){ e.printStackTrace(); } countDownLatch.countDown(); }); } for (int j = 0; j< 2500; j++) { final Integer n=j; executorService.execute(()->{ executorService.execute(()->{ try{ semaphore.acquire(); String s = map.get(n + ""); System.out.println("===="+s); semaphore.release(); }catch (Exception e){ e.printStackTrace(); } countDownLatch.countDown(); }); }); } countDownLatch.await(); executorService.shutdown(); }}//线程平安的一个Mapclass LockMap { private final Map<String,String> map=new TreeMap<>(); //申明读写锁 private final ReentrantReadWriteLock reentrantReadWriteLock=new ReentrantReadWriteLock(); //取得读写锁中的读锁 private final Lock rlock=reentrantReadWriteLock.readLock(); //取得读写锁中的写锁 private final Lock wlock=reentrantReadWriteLock.writeLock(); //读取数据 public String get(String key){ rlock.lock(); try{ return map.get(key); }finally { rlock.unlock(); } } //写入数据 public String put(String k,String v){ wlock.lock(); try{ return map.put(k,v); }finally { wlock.unlock(); } } //读取数据 public Set<String> getAllKeys(){ rlock.lock(); try { return map.keySet(); }finally { rlock.unlock(); } }}StampedLock介绍
在JDK1.8中，新增 StampedLock ，它是ReentrantReadWriteLock的增强版，是为了解决ReentrantReadWriteLock的一些有余。正因为ReentrantReadWriteLock呈现了读和写是互斥的状况，须要优化，因而就呈现了StampedLock！它管制锁有三种模式（写、读、乐观读）。一个StempedLock的状态是由版本和模式两个局部组成。锁获取办法返回一个数字作为票据（stamp），他用相应的锁状态示意并管制相干的拜访。数字0示意没有写锁被锁写访问，在读锁上分为乐观锁和乐观锁。
乐观读： 如果读的操作很多写的很少，咱们能够乐观的认为读的操作与写的操作同时产生的状况很少，因而不乐观的应用齐全的读取锁定。程序能够查看读取材料之后是否受到写入材料的变更，再采取之后的措施。
它的思维是读写锁中读不仅不阻塞读，同时也不应该阻塞写。 在读的时候如果产生了写，则该当重读而不是在读的时候间接阻塞写。应用StampedLock就能够实现一种无障碍操作，即读写之间不会阻塞对方，然而写和写之间还是阻塞的
StampedLock源码中的一个案例
package com.rumenz.task.stampedLock;import java.util.concurrent.locks.StampedLock;class Point { private double x, y; // 锁实例 private final StampedLock sl = new StampedLock(); // 排它锁-写锁（writeLock） void move(double deltaX, double deltaY) { long stamp = sl.writeLock(); try { x += deltaX; y += deltaY; } finally { sl.unlockWrite(stamp); } } //乐观读锁（tryOptimisticRead） double distanceFromOrigin() { // 尝试获取乐观读锁（1） long stamp = sl.tryOptimisticRead(); // 将全副变量拷贝到办法体栈内（2）将两个字段读入本地局部变量 double currentX = x, currentY = y; // 查看在（1）获取到读锁票据后，锁有没被其余写线程排它性抢占（3） if (!sl.validate(stamp)) { // 如果被抢占则获取一个共享读锁（乐观获取）（4） stamp = sl.readLock(); try { currentX = x; // 将两个字段读入本地局部变量(5) currentY = y; // 将两个字段读入本地局部变量(5) } finally { // 开释共享读锁（6） sl.unlockRead(stamp); } } // 返回计算结果（7） return Math.sqrt(currentX * currentX + currentY * currentY); } // 应用乐观锁获取读锁，并尝试转换为写锁 void moveIfAtOrigin(double newX, double newY) { // 这里能够应用乐观读锁替换（1） long stamp = sl.readLock(); try { // 如果以后点在原点则挪动（2） while (x == 0.0 && y == 0.0) { // 尝试将获取的读锁降级为写锁（3） long ws = sl.tryConvertToWriteLock(stamp); // 降级胜利，则更新票据，并设置坐标值，而后退出循环（4） if (ws != 0L) { //这是确认转为写锁是否胜利 stamp = ws; //如果胜利 替换票据 x = newX; //进行状态扭转 y = newY; //进行状态扭转 break; } else { // 读锁降级写锁失败则开释读锁，显示获取独占写锁，而后循环重试（5） sl.unlockRead(stamp); //咱们显式开释读锁 stamp = sl.writeLock(); //显式间接进行写锁 而后再通过循环再试 } } } finally { sl.unlock(stamp); //开释读锁或写锁(6) } }}总结
- synchronized是在JVM层面上实现的，岂但能够通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会主动开释锁定；
- ReentrantLock、ReentrantReadWriteLock,、StampedLock都是对象层面的锁定，要保障锁定肯定会被开释，就必须将unLock()放到finally{}中；
- StampedLock 对吞吐量有微小的改良，特地是在读线程越来越多的场景下；
- StampedLock有一个简单的API，对于加锁操作，很容易误用其余办法;
- 当只有大量竞争者的时候，synchronized是一个很好的通用的锁实现;
- 当线程增长可能预估，ReentrantLock是一个很好的通用的锁实现;
关注微信公众号:【入门小站】,解锁更多知识点