一文看懂JUC之AQS机制

 为了解决原子性的问题，Java加入了锁机制，同时保证了可见性和顺序性。JDK1.5的并发包中新增了Lock接口以及相关实现类来实现锁功能，比synchronized更加灵活，开发者可根据实际的场景选择相应的实现类。

在红安等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供网站制作、做网站 网站设计制作按需求定制设计,公司网站建设,企业网站建设,品牌网站建设,成都全网营销推广,成都外贸网站建设,红安网站建设费用合理。

本文注重讲解其不同衍生类的使用场景以及其内部AQS的原理。并发问题引入以及synchronized相关的知识请看上一篇文章一文看懂Java锁机制。

Lock特性

可重入

像synchronized和ReentrantLock都是可重入锁，可重入性表明了锁的分配机制是基于线程的分配，而不是基于方法调用的分配。

举个简单的例子，当一个线程已经获取到锁，当后续再获取同一个锁，直接获取成功。但获取锁和释放锁必须要成对出现。

可响应中断

当线程因为获取锁而进入阻塞状态，外部是可以中断该线程的，调用方通过捕获InterruptedException可以捕获中断

可设置超时时间

获取锁时，可以指定超时时间，可以通过返回值来判断是否成功获取锁

公平性

提供公平性锁和非公平锁（默认）两种选择。

  •  公平锁，线程将按照他们发出请求的顺序来获取锁，不允许插队；
  •  非公平锁，则允许插队：当一个线程发生获取锁的请求的时刻，如果这个锁是可用的，那这个线程将跳过所在队列里等待线程并获得锁。

考虑这么一种情况：A线程持有锁，B线程请求这个锁，因此B线程被挂起；A线程释放这个锁时，B线程将被唤醒，因此再次尝试获取锁；与此同时，C线程也请求获取这个锁，那么C线程很可能在B线程被完全唤醒之前获得、使用以及释放这个锁。

这是种双赢的局面，B获取锁的时刻（B被唤醒后才能获取锁）并没有推迟，C更早地获取了锁，并且吞吐量也获得了提高。在大多数情况下，非公平锁的性能要高于公平锁的性能。

另外，这个公平性是针对线程而言的，不能依赖此来实现业务上的公平性，应该由开发者自己控制，比如通过FIFO队列来保证公布。

读写锁

允许读锁和写锁分离，读锁与写锁互斥，但是多个读锁可以共存，适用于读频次远大于写频次的场景

丰富的API

提供了多个方法来获取锁相关的信息，可以帮助开发者监控和排查问题

  •  isFair()：判断锁是否是公平锁
  •  isLocked()：判断锁是否被任何线程获取了
  •  isHeldByCurrentThread()：判断锁是否被当前线程获取了
  •  hasQueuedThreads()：判断是否有线程在等待该锁
  •  getHoldCount()：查询当前线程占有lock锁的次数
  •  getQueueLength()：获取正在等待此锁的线程数

锁的使用

ReentrantLock

独占锁的实现，拥有上面列举的除读写锁之外的所有特性，使用比较简单 

 
 
 
 
    
  
  
  
  
  1. class X {  
    2. 
  
  
  
  
  2.    // 创建独占锁实例  
    3. 
  
  
  
  
  3.    private final ReentrantLock lock = new ReentrantLock();  
    4. 
  
  
  
  
  4.    // ...  
    5. 
  
  
  
  
  5.    public void m() {  
    6. 
  
  
  
  
  6.      lock.lock();  // block until condition holds  
    7. 
  
  
  
  
  7.      try {  
    8. 
  
  
  
  
  8.        // ... method body  
    9. 
  
  
  
  
  9.      } finally {  
    10. 
  
  
  
  
  10.        // 必须要释放锁，unlock与lock成对出现  
    11. 
  
  
  
  
  11.        lock.unlock()  
    12. 
  
  
  
  
  12.      } 
    13. 
  
  
  
  
  13.    }  
    14. 
  
  
  
  
  14.  } 
    15.

ReentrantReadWriteLock

读写锁的实现，拥有上面列举的所有特性。并且写锁可降级为读锁，反之不行。 

 
 
 
 
    
  
  
  
  
  1. class CachedData {  
    2. 
  
  
  
  
  2.    Object data;  
    3. 
  
  
  
  
  3.    volatile boolean cacheValid;  
    4. 
  
  
  
  
  4.    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();  
    5. 
  
  
  
  
  5.    void processCachedData() {  
    6. 
  
  
  
  
  6.      rwl.readLock().lock();  
    7. 
  
  
  
  
  7.      if (!cacheValid) {  
    8. 
  
  
  
  
  8.        // Must release read lock before acquiring write lock  
    9. 
  
  
  
  
  9.        rwl.readLock().unlock();  
    10. 
  
  
  
  
  10.        rwl.writeLock().lock(); 
    11. 
  
  
  
  
  11.         try {  
    12. 
  
  
  
  
  12.          // Recheck state because another thread might have  
    13. 
  
  
  
  
  13.          // acquired write lock and changed state before we did.  
    14. 
  
  
  
  
  14.          if (!cacheValid) {  
    15. 
  
  
  
  
  15.            data = ...  
    16. 
  
  
  
  
  16.            cacheValid = true;  
    17. 
  
  
  
  
  17.          }  
    18. 
  
  
  
  
  18.          // Downgrade by acquiring read lock before releasing write lock  
    19. 
  
  
  
  
  19.          rwl.readLock().lock();  
    20. 
  
  
  
  
  20.        } finally { 
    21. 
  
  
  
  
  21.          rwl.writeLock().unlock(); // Unlock write, still hold read  
    22. 
  
  
  
  
  22.        }  
    23. 
  
  
  
  
  23.      }  
    24. 
  
  
  
  
  24.      try {  
    25. 
  
  
  
  
  25.        use(data);  
    26. 
  
  
  
  
  26.      } finally {  
    27. 
  
  
  
  
  27.        rwl.readLock().unlock();  
    28. 
  
  
  
  
  28.      }  
    29. 
  
  
  
  
  29.    }  
    30. 
  
  
  
  
  30.  } 
    31.

StampedLock

StampedLock也是一种读写锁，提供两种读模式：乐观读和悲观读。乐观读允许读的过程中也可以获取写锁后写入！这样一来，我们读的数据就可能不一致，所以，需要一点额外的代码来判断读的过程中是否有写入。

乐观锁的意思就是乐观地估计读的过程中大概率不会有写入，因此被称为乐观锁。反过来，悲观锁则是读的过程中拒绝有写入，也就是写入必须等待。显然乐观锁的并发效率更高，但一旦有小概率的写入导致读取的数据不一致，需要能检测出来，再读一遍就行。 

 
 
 
 
    
  
  
  
  
  1. public class Point {  
    2. 
  
  
  
  
  2.     private final StampedLock stampedLock = new StampedLock();  
    3. 
  
  
  
  
  3.     private double x;  
    4. 
  
  
  
  
  4.     private double y; 
    5. 
  
  
  
  
  5.     public void move(double deltaX, double deltaY) {  
    6. 
  
  
  
  
  6.         long stamp = stampedLock.writeLock(); // 获取写锁  
    7. 
  
  
  
  
  7.         try {  
    8. 
  
  
  
  
  8.             x += deltaX;  
    9. 
  
  
  
  
  9.             y += deltaY;  
    10. 
  
  
  
  
  10.         } finally {  
    11. 
  
  
  
  
  11.             stampedLock.unlockWrite(stamp); // 释放写锁  
    12. 
  
  
  
  
  12.         }  
    13. 
  
  
  
  
  13.     }  
    14. 
  
  
  
  
  14.     public double distanceFromOrigin() { 
    15. 
  
  
  
  
  15.         long stamp = stampedLock.tryOptimisticRead(); // 获得一个乐观读锁  
    16. 
  
  
  
  
  16.         // 注意下面两行代码不是原子操作  
    17. 
  
  
  
  
  17.         // 假设x,y = (100,200)  
    18. 
  
  
  
  
  18.         double currentX = x;  
    19. 
  
  
  
  
  19.         // 此处已读取到x=100，但x,y可能被写线程修改为(300,400)  
    20. 
  
  
  
  
  20.         double currentY = y;  
    21. 
  
  
  
  
  21.         // 此处已读取到y，如果没有写入，读取是正确的(100,200)  
    22. 
  
  
  
  
  22.         // 如果有写入，读取是错误的(100,400)  
    23. 
  
  
  
  
  23.         if (!stampedLock.validate(stamp)) { // 检查乐观读锁后是否有其他写锁发生  
    24. 
  
  
  
  
  24.             stamp = stampedLock.readLock(); // 获取一个悲观读锁  
    25. 
  
  
  
  
  25.             try {  
    26. 
  
  
  
  
  26.                 currentX = x;  
    27. 
  
  
  
  
  27.                 currentY = y;  
    28. 
  
  
  
  
  28.             } finally {  
    29. 
  
  
  
  
  29.                 stampedLock.unlockRead(stamp); // 释放悲观读锁 
    30. 
  
  
  
  
  30.             }  
    31. 
  
  
  
  
  31.         }  
    32. 
  
  
  
  
  32.         return Math.sqrt(currentX * currentX + currentY * currentY);  
    33. 
  
  
  
  
  33.     }  
    34. 
  
  
  
  
  34. } 
    35.

Condition

Condition成为条件队列或条件变量，为一个线程挂起执行（等待）提供了一种方法，直到另一线程通知某些状态条件现在可能为真为止。由于对该共享状态信息的访问发生在不同的线程中，因此必须由互斥锁对其其进行保护。

await方法：必须在获取锁之后的调用，表示释放当前锁，阻塞当前线程；等待其他线程调用锁的signal或signalAll方法，线程唤醒重新获取锁。

Lock配合Condition，可以实现synchronized 与 对象（wait，notify）同样的效果，来进行线程间基于共享变量的通信。但优势在于同一个锁可以由多个条件队列，当某个条件满足时，只需要唤醒对应的条件队列即可，避免无效的竞争。 

 
 
 
 
    
  
  
  
  
  1. // 此类实现类似阻塞队列（ArrayBlockingQueue）  
    2. 
  
  
  
  
  2. class BoundedBuffer {  
    3. 
  
  
  
  
  3.  final Lock lock = new ReentrantLock();  
    4. 
  
  
  
  
  4.  final Condition notFull  = lock.newCondition();   
    5. 
  
  
  
  
  5.  final Condition notEmpty = lock.newCondition();   
    6. 
  
  
  
  
  6.  final Object[] items = new Object[100];  
    7. 
  
  
  
  
  7.  int putptr, takeptr, count;  
    8. 
  
  
  
  
  8.  public void put(Object x) throws InterruptedException {  
    9. 
  
  
  
  
  9.    lock.lock();  
    10. 
  
  
  
  
  10.    try {  
    11. 
  
  
  
  
  11.      while (count == items.length)  
    12. 
  
  
  
  
  12.        notFull.await();  
    13. 
  
  
  
  
  13.      items[putptr] = x;  
    14. 
  
  
  
  
  14.      if (++putptr == items.length) putptr = 0;  
    15. 
  
  
  
  
  15.      ++count;  
    16. 
  
  
  
  
  16.      notEmpty.signal();  
    17. 
  
  
  
  
  17.    } finally {  
    18. 
  
  
  
  
  18.      lock.unlock();  
    19. 
  
  
  
  
  19.    }  
    20. 
  
  
  
  
  20.  }  
    21. 
  
  
  
  
  21.  public Object take() throws InterruptedException {  
    22. 
  
  
  
  
  22.    lock.lock();  
    23. 
  
  
  
  
  23.    try {  
    24. 
  
  
  
  
  24.      while (count == 0)  
    25. 
  
  
  
  
  25.        notEmpty.await();  
    26. 
  
  
  
  
  26.      Object x = items[takeptr];  
    27. 
  
  
  
  
  27.      if (++takeptr == items.length) takeptr = 0;  
    28. 
  
  
  
  
  28.      --count;  
    29. 
  
  
  
  
  29.      notFull.signal();  
    30. 
  
  
  
  
  30.      return x;  
    31. 
  
  
  
  
  31.    } finally {  
    32. 
  
  
  
  
  32.      lock.unlock();  
    33. 
  
  
  
  
  33.    }  
    34. 
  
  
  
  
  34.  }  
    35. 
  
  
  
  
  35. } 
    36.

BlockingQueue

BlockingQueue阻塞队列实际上是一个生产者/消费者模型，当队列长度大于指定的最大值，生产线程就会被阻塞；反之当队列元素为空时，消费线程就会被阻塞；同时当消费成功时，就会唤醒阻塞的生产者线程；生产成功就会唤醒消费者线程；

内部使用就是ReentrantLock + Condition来实现的，可以参照上面的示例。

CountDownLatch

称之为倒计时器锁，初始化指定数值，调用countDown可以对数值减一，当数值减为0时，就会唤醒所有因为调用await方法而阻塞的线程。

可以达到一组线程等待另外一组线程都完成任务的效果。 

 
 
 
 
    
  
  
  
  
  1. class Driver { // ...  
    2. 
  
  
  
  
  2.    void main() throws InterruptedException { 
    3. 
  
  
  
  
  3.      CountDownLatch startSignal = new CountDownLatch(1);  
    4. 
  
  
  
  
  4.      CountDownLatch doneSignal = new CountDownLatch(N);  
    5. 
  
  
  
  
  5.      for (int i = 0; i < N; ++i) // create and start threads  
    6. 
  
  
  
  
  6.        new Thread(new Worker(startSignal, doneSignal)).start();  
    7. 
  
  
  
  
  7.      doSomethingElse();            // don't let run yet  
    8. 
  
  
  
  
  8.      startSignal.countDown();      // let all threads proceed  
    9. 
  
  
  
  
  9.      doSomethingElse();  
    10. 
  
  
  
  
  10.      doneSignal.await();           // wait for all to finish  
    11. 
  
  
  
  
  11.    }  
    12. 
  
  
  
  
  12. }  
    13. 
  
  
  
  
  13. class Worker implements Runnable {  
    14. 
  
  
  
  
  14.    private final CountDownLatch startSignal;  
    15. 
  
  
  
  
  15.    private final CountDownLatch doneSignal;  
    16. 
  
  
  
  
  16.    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {  
    17. 
  
  
  
  
  17.      this.startSignal = startSignal;  
    18. 
  
  
  
  
  18.      this.doneSignal = doneSignal;  
    19. 
  
  
  
  
  19.    }  
    20. 
  
  
  
  
  20.    public void run() {  
    21. 
  
  
  
  
  21.      try {  
    22. 
  
  
  
  
  22.        startSignal.await();  
    23. 
  
  
  
  
  23.        doWork();  
    24. 
  
  
  
  
  24.        doneSignal.countDown(); 
    25. 
  
  
  
  
  25.      } catch (InterruptedException ex) {} // return;  
    26. 
  
  
  
  
  26.    }  
    27. 
  
  
  
  
  27.    void doWork() { ... }  
    28. 
  
  
  
  
  28. } 
    29.

CyclicBarrier

称之为同步屏障，它使得一组线程互相等待，直到到达某个公共屏障点。

初始化指定数值，调用await方法会使得线程阻塞，直到指定数量的线程都调用await方法时，所有被阻塞的线程会被唤醒，继续执行。

与CountDownLatch的区别是，CountDownLatch是一组线程等待另外一组线程，而CyclicBarrier是一组线程之间相互等待。

Semaphore

称之为信号量，与互斥锁ReentrantLock用法类似，区别就是Semaphore共享的资源是多个，允许多个线程同时竞争成功。

AQS原理

AQS 是 AbstractQueuedSynchronizer的缩写，中文 抽象队列同步器，是构建各类锁和同步器的基础实现。内部维护了共享变量state （int类型） 和 双向队列 （包含头指针和尾指针）

并发问题解决

原子性

Unsafe.compareAndSwapXXX 实现CAS更改 state 和 队列指针 内部依赖CPU提供的原子指令

可见性与有序性

volatile 修饰 state 与 队列指针 （prev/next/head/tail）

线程阻塞与唤醒

Unsafe.park Unsafe.parkNanos Unsafe.unpark

Unsafe类是在sun.misc包下，不属于Java标准。提供了内存管理、对象实例化、数组操作、CAS操作、线程挂起与恢复等功能，Unsafe类提升了Java运行效率，增强了Java语言底层的操作能力。很多Java的基础类库，包括一些被广泛使用的高性能开发库都是基于Unsafe类开发的，比如Netty、Cassandra、Hadoop、Kafka等

AQS内部有两种模式：独占模式和共享模式

AQS 的设计是基于模板方法的，使用者需要继承 AQS 并重写指定的方法。不同的自定义同步器争用共享资源的方式不同，比如可重入、公平性等都是子类来实现。

自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），由AQS内部处理。

独占模式

  •  只有一个线程都能够获取到锁
  •  锁释放后需要唤醒后继节点

AQS提供的独占模式相关的方法 

 
 
 
 
    
  
  
  
  
  1. // 获取独占锁（线程阻塞直至获取成功）  
    2. 
  
  
  
  
  2. public final void acquire(int)  
    3. 
  
  
  
  
  3. // 获取独占锁，可被中断  
    4. 
  
  
  
  
  4. public final void acquireInterruptibly(int)   
    5. 
  
  
  
  
  5. // 获取独占锁，可被中断 和 指定超时时间  
    6. 
  
  
  
  
  6. public final boolean tryAcquireNanos(int, long)   
    7. 
  
  
  
  
  7. // 释放独占锁（释放锁后，将等待队列中第一个等待节点唤醒 ）  
    8. 
  
  
  
  
  8. public final boolean release(int)  
    9.

AQS子类需要实现的独占模式相关的方法 

 
 
 
 
    
  
  
  
  
  1. // 尝试获取独占锁  
    2. 
  
  
  
  
  2. protected boolean tryAcquire(int)  
    3. 
  
  
  
  
  3. // 尝试释放独占锁  
    4. 
  
  
  
  
  4. protected boolean tryRelease(int) 
    5.

获取独占锁的流程

  •  调用子类tryAcquire尝试获取锁，获取成功，直接返回
  •  通过自旋CAS将当前线程封装成节点加入队列末尾
  •  循环等待或尝试tryAcquire获取锁
    •   判断前置节点如果为head，则尝试获取锁
    •   根据队列中节点状态，决定是否需要阻塞当前线程
    •   tryAcquire获取锁成功后，将当前节点设置为head 并 返回
  •  如果当前线程中断或超时，则执行cancelAcquire
    •   将当前节点状态置为CANCELED，并从队列删除
    •   如果前置节点为Head，则将后置节点唤醒

释放独占锁的流程

共享模式

  •  多个线程都能够获取到锁
  •  锁释放后需要唤醒后继节点
  •  锁获取后如果还有资源需要唤醒后继共享节点

AQS提供的共享模式相关的方法 

 
 
 
 
    
  
  
  
  
  1. // 获取共享锁（线程阻塞直至获取成功）  
    2. 
  
  
  
  
  2. public final void acquireShared(int)   
    3. 
  
  
  
  
  3. // 获取共享锁，可被中断  
    4. 
  
  
  
  
  4. public final acquireSharedInterruptibly(int)   
    5. 
  
  
  
  
  5. // 获取共享锁，可被中断 和 指定超时时间  
    6. 
  
  
  
  
  6. public final tryAcquireSharedNanos(int, long)    
    7. 
  
  
  
  
  7. // 获取共享锁  
    8. 
  
  
  
  
  8. public final boolean releaseShared(int)  
    9.

AQS子类需要实现的共享模式相关的方法 

 
 
 
 
    
  
  
  
  
  1. // 尝试获取共享锁  
    2. 
  
  
  
  
  2. protected int tryAcquireShared(int) 
    3. 
  
  
  
  
  3. // 尝试释放共享锁  
    4. 
  
  
  
  
  4. protected boolean tryReleaseShared(int) 
    5.

获取共享锁的流程

1.调用子类tryAcquireShared尝试获取锁，获取成功，直接返回

2.通过自旋CAS将当前线程封装成节点加入队列末尾

3.循环等待或尝试tryAcquireShared获取锁

  •  判断前置节点如果为head，则尝试获取锁
  •  根据队列中节点状态，决定是否需要阻塞当前线程
  •  tryAcquireShared获取锁成功后，将当前节点设置为head
    •   如果资源有剩余或者原先的head节点状态为SIGNAL/PROPAGATE，则调用doReleaseShared
    •   如果当前head节点状态为SIGNAL，唤醒后继节点
    •   如果当前head节点状态为ZERO，将head节点状态置为PROPAGATE
  •  如果当前线程中断或超时，则执行cancelAcquire
    •   将当前节点状态置为CANCELED，并从队列删除
    •   如果前置节点为Head，则将后置节点唤醒

释放共享锁的流程

等待队列中节点的状态变化

ReentrantLock示例

tryAcquire逻辑

tryRelease逻辑

文章标题：一文看懂JUC之AQS机制
本文URL：http://www.shufengxianlan.com/qtweb/news7/308157.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

建站公司知识

同城分类信息

bgp多线机房托管　　 　香港云服务器租用　　 　等级保护测评　　 　攀枝花网站建设　　 　子晨包装　　 　广东帝美豪门窗　　 　卡多尼人工智　　 　达州网站制作　　 　成都ssl证书认证　　 　成都门户网站建设　　 　四川雅安服务器托管　　 　橡塑板　　 　成都康明斯发电机　　 　四川成都seo网站优化　　 　网络营销公司　　 　中国电信西部信息中心机房　　 　无边发光字　　 　响应式网站建设　　 　营销型网站建设　　 　东电技服