一文看懂JUC之AQS机制

 class X {   // 创建独占锁实例   private final ReentrantLock lock = new ReentrantLock();   // ...
   public void m() {     lock.lock();  // block until condition holds     try {       // ... method body     } finally {       // 必须要释放锁，unlock与lock成对出现       lock.unlock()     }   } }

class CachedData {   Object data;   volatile boolean cacheValid;   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
   void processCachedData() {     rwl.readLock().lock();     if (!cacheValid) {       // Must release read lock before acquiring write lock       rwl.readLock().unlock();       rwl.writeLock().lock();       try {         // Recheck state because another thread might have         // acquired write lock and changed state before we did.         if (!cacheValid) {           data = ...           cacheValid = true;         }         // Downgrade by acquiring read lock before releasing write lock         rwl.readLock().lock();       } finally {         rwl.writeLock().unlock(); // Unlock write, still hold read       }     }
     try {       use(data);     } finally {       rwl.readLock().unlock();     }   } }

public class Point {    private final StampedLock stampedLock = new StampedLock();
    private double x;    private double y;
    public void move(double deltaX, double deltaY) {        long stamp = stampedLock.writeLock(); // 获取写锁        try {            x += deltaX;            y += deltaY;        } finally {            stampedLock.unlockWrite(stamp); // 释放写锁        }    }
    public double distanceFromOrigin() {        long stamp = stampedLock.tryOptimisticRead(); // 获得一个乐观读锁        // 注意下面两行代码不是原子操作        // 假设x,y = (100,200)        double currentX = x;        // 此处已读取到x=100，但x,y可能被写线程修改为(300,400)        double currentY = y;        // 此处已读取到y，如果没有写入，读取是正确的(100,200)        // 如果有写入，读取是错误的(100,400)        if (!stampedLock.validate(stamp)) { // 检查乐观读锁后是否有其他写锁发生            stamp = stampedLock.readLock(); // 获取一个悲观读锁            try {                currentX = x;                currentY = y;            } finally {                stampedLock.unlockRead(stamp); // 释放悲观读锁            }        }        return Math.sqrt(currentX * currentX + currentY * currentY);    }}

// 此类实现类似阻塞队列（ArrayBlockingQueue）class BoundedBuffer { final Lock lock = new ReentrantLock(); final Condition notFull  = lock.newCondition();  final Condition notEmpty = lock.newCondition(); 
 final Object[] items = new Object[100]; int putptr, takeptr, count;
 public void put(Object x) throws InterruptedException {   lock.lock();   try {     while (count == items.length)       notFull.await();     items[putptr] = x;     if (++putptr == items.length) putptr = 0;     ++count;     notEmpty.signal();   } finally {     lock.unlock();   } }
 public Object take() throws InterruptedException {   lock.lock();   try {     while (count == 0)       notEmpty.await();     Object x = items[takeptr];     if (++takeptr == items.length) takeptr = 0;     --count;     notFull.signal();     return x;   } finally {     lock.unlock();   } }}

class Driver { // ...   void main() throws InterruptedException {     CountDownLatch startSignal = new CountDownLatch(1);     CountDownLatch doneSignal = new CountDownLatch(N);
     for (int i = 0; i < N; ++i) // create and start threads       new Thread(new Worker(startSignal, doneSignal)).start();
     doSomethingElse();            // don't let run yet     startSignal.countDown();      // let all threads proceed     doSomethingElse();     doneSignal.await();           // wait for all to finish   }}
class Worker implements Runnable {   private final CountDownLatch startSignal;   private final CountDownLatch doneSignal;   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {     this.startSignal = startSignal;     this.doneSignal = doneSignal;   }   public void run() {     try {       startSignal.await();       doWork();       doneSignal.countDown();     } catch (InterruptedException ex) {} // return;   }
   void doWork() { ... }}

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

// 尝试获取独占锁protected boolean tryAcquire(int)// 尝试释放独占锁protected boolean tryRelease(int)

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

// 尝试获取共享锁protected int tryAcquireShared(int)// 尝试释放共享锁protected boolean tryReleaseShared(int)