类图结构

J.U.C 的锁组件中 类相对较少，从 JDK 相应的包中也能看出来，下图标记了其中最主要的几个接口和类，也是本文要分析的重点。

avatar

下图 将这几个接口和类 以类图的方式展现出来，其中包含了它们所声明的主要方法。

avatar

Lock 组件

Lock 组件的结构很简单，只有一个接口和一个实现类，源码如下。

  1. public interface Lock {
  3.     /**
  4.      * 获取锁
  5.      */
  6.     void lock();
  8.     /**
  9.      * 获取锁，除非当前线程中断
  10.      */
  11.     void lockInterruptibly() throws InterruptedException;
  13.     /**
  14.      * 只有当调用时 锁是空闲的情况下，才获取锁
  15.      */
  16.     boolean tryLock();
  18.     /**
  19.      * 如果锁在给定的等待时间内空闲且当前线程未被中断，则获取该锁
  20.      */
  21.     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
  23.     /**
  24.      * 释放锁
  25.      */
  26.     void unlock();
  27. }
  29. public class ReentrantLock implements Lock, java.io.Serializable {
  31.     /** 提供所有实现机制的同步器，ReentrantLock 的主要方法都依赖于该对象进行实现 */
  32.     private final Sync sync;
  34.     /**
  35.      * ReentrantLock锁 的同步控制基础。它的两个子类分别实现了公平锁和非公平锁，如下。
  36.      */
  37.     abstract static class Sync extends AbstractQueuedSynchronizer {
  38.         private static final long serialVersionUID = -5179523762034025860L;
  40.         abstract void lock();
  42.         /**
  43.          * Performs non-fair tryLock.  tryAcquire is implemented in
  44.          * subclasses, but both need nonfair try for trylock method.
  45.          */
  46.         final boolean nonfairTryAcquire(int acquires) {
  47.             final Thread current = Thread.currentThread();
  48.             int c = getState();
  49.             if (c == 0) {
  50.                 if (compareAndSetState(0, acquires)) {
  51.                     setExclusiveOwnerThread(current);
  52.                     return true;
  53.                 }
  54.             }
  55.             else if (current == getExclusiveOwnerThread()) {
  56.                 int nextc = c + acquires;
  57.                 if (nextc < 0) // overflow
  58.                     throw new Error("Maximum lock count exceeded");
  59.                 setState(nextc);
  60.                 return true;
  61.             }
  62.             return false;
  63.         }
  65.         protected final boolean tryRelease(int releases) {
  66.             int c = getState() - releases;
  67.             if (Thread.currentThread() != getExclusiveOwnerThread())
  68.                 throw new IllegalMonitorStateException();
  69.             boolean free = false;
  70.             if (c == 0) {
  71.                 free = true;
  72.                 setExclusiveOwnerThread(null);
  73.             }
  74.             setState(c);
  75.             return free;
  76.         }
  78.         final boolean isLocked() {
  79.             return getState() != 0;
  80.         }
  81.     }
  83.     /**
  84.      * 非公平锁，基于上面的 Sync类
  85.      */
  86.     static final class NonfairSync extends Sync {
  87.         private static final long serialVersionUID = 7316153563782823691L;
  89.         final void lock() {
  90.             if (compareAndSetState(0, 1))
  91.                 setExclusiveOwnerThread(Thread.currentThread());
  92.             else
  93.                 acquire(1);
  94.         }
  96.         protected final boolean tryAcquire(int acquires) {
  97.             return nonfairTryAcquire(acquires);
  98.         }
  99.     }
  101.     /**
  102.      * 公平锁，基于上面的 Sync类
  103.      */
  104.     static final class FairSync extends Sync {
  105.         private static final long serialVersionUID = -3000897897090466540L;
  107.         final void lock() {
  108.             acquire(1);
  109.         }
  111.         protected final boolean tryAcquire(int acquires) {
  112.             final Thread current = Thread.currentThread();
  113.             int c = getState();
  114.             if (c == 0) {
  115.                 if (!hasQueuedPredecessors() &&
  116.                     compareAndSetState(0, acquires)) {
  117.                     setExclusiveOwnerThread(current);
  118.                     return true;
  119.                 }
  120.             }
  121.             else if (current == getExclusiveOwnerThread()) {
  122.                 int nextc = c + acquires;
  123.                 if (nextc < 0)
  124.                     throw new Error("Maximum lock count exceeded");
  125.                 setState(nextc);
  126.                 return true;
  127.             }
  128.             return false;
  129.         }
  130.     }
  132.     /**
  133.      * 无参初始化时，默认实例化 非公平锁
  134.      */
  135.     public ReentrantLock() {
  136.         sync = new NonfairSync();
  137.     }
  139.     /**
  140.      * 可通过参数fair 控制实例化的是 公平锁还是非公平锁
  141.      */
  142.     public ReentrantLock(boolean fair) {
  143.         sync = fair ? new FairSync() : new NonfairSync();
  144.     }
  146.     public void lock() {
  147.         sync.lock();
  148.     }
  150.     public boolean tryLock() {
  151.         return sync.nonfairTryAcquire(1);
  152.     }
  154.     public boolean tryLock(long timeout, TimeUnit unit)
  155.             throws InterruptedException {
  156.         return sync.tryAcquireNanos(1, unit.toNanos(timeout));
  157.     }
  159.     public void unlock() {
  160.         sync.release(1);
  161.     }
  163.     public boolean isLocked() {
  164.         return sync.isLocked();
  165.     }
  167.     public final boolean isFair() {
  168.         return sync instanceof FairSync;
  169.     }
  170. }

ReadWriteLock 组件

ReadWriteLock 组件的结构也很简单，与上面的 Lock 组件 不同的是，它提供了 公平的读锁写锁，以及非公平的读锁写锁。

  1. public interface ReadWriteLock {
  2.     /**
  3.      * 获取一个 读锁
  4.      */
  5.     Lock readLock();
  7.     /**
  8.      * 获取一个 写锁
  9.      */
  10.     Lock writeLock();
  11. }
  13. public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
  15.     /** 由内部类提供的读锁 */
  16.     private final ReentrantReadWriteLock.ReadLock readerLock;
  17.     /** 由内部类提供的写锁 */
  18.     private final ReentrantReadWriteLock.WriteLock writerLock;
  19.     /** 提供所有实现机制的同步器 */
  20.     final Sync sync;
  22.     /**
  23.      * 默认创建 非公平的读锁写锁
  24.      */
  25.     public ReentrantReadWriteLock() {
  26.         this(false);
  27.     }
  29.     /**
  30.      * 由参数 fair 指定读锁写锁是公平的还是非公平的
  31.      */
  32.     public ReentrantReadWriteLock(boolean fair) {
  33.         sync = fair ? new FairSync() : new NonfairSync();
  34.         readerLock = new ReadLock(this);
  35.         writerLock = new WriteLock(this);
  36.     }
  38.     /**
  39.      * 获取写锁
  40.      * 获取读锁
  41.      */
  42.     public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
  43.     public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }
  45.     abstract static class Sync extends AbstractQueuedSynchronizer {
  47.         protected final boolean tryRelease(int releases) {
  48.             if (!isHeldExclusively())
  49.                 throw new IllegalMonitorStateException();
  50.             int nextc = getState() - releases;
  51.             boolean free = exclusiveCount(nextc) == 0;
  52.             if (free)
  53.                 setExclusiveOwnerThread(null);
  54.             setState(nextc);
  55.             return free;
  56.         }
  58.         protected final boolean tryAcquire(int acquires) {
  59.             /*
  60.              * Walkthrough:
  61.              * 1. If read count nonzero or write count nonzero
  62.              *    and owner is a different thread, fail.
  63.              * 2. If count would saturate, fail. (This can only
  64.              *    happen if count is already nonzero.)
  65.              * 3. Otherwise, this thread is eligible for lock if
  66.              *    it is either a reentrant acquire or
  67.              *    queue policy allows it. If so, update state
  68.              *    and set owner.
  69.              */
  70.             Thread current = Thread.currentThread();
  71.             int c = getState();
  72.             int w = exclusiveCount(c);
  73.             if (c != 0) {
  74.                 // (Note: if c != 0 and w == 0 then shared count != 0)
  75.                 if (w == 0 || current != getExclusiveOwnerThread())
  76.                     return false;
  77.                 if (w + exclusiveCount(acquires) > MAX_COUNT)
  78.                     throw new Error("Maximum lock count exceeded");
  79.                 // Reentrant acquire
  80.                 setState(c + acquires);
  81.                 return true;
  82.             }
  83.             if (writerShouldBlock() ||
  84.                 !compareAndSetState(c, c + acquires))
  85.                 return false;
  86.             setExclusiveOwnerThread(current);
  87.             return true;
  88.         }
  90.         protected final boolean tryReleaseShared(int unused) {
  91.             Thread current = Thread.currentThread();
  92.             if (firstReader == current) {
  93.                 // assert firstReaderHoldCount > 0;
  94.                 if (firstReaderHoldCount == 1)
  95.                     firstReader = null;
  96.                 else
  97.                     firstReaderHoldCount--;
  98.             } else {
  99.                 HoldCounter rh = cachedHoldCounter;
  100.                 if (rh == null || rh.tid != getThreadId(current))
  101.                     rh = readHolds.get();
  102.                 int count = rh.count;
  103.                 if (count <= 1) {
  104.                     readHolds.remove();
  105.                     if (count <= 0)
  106.                         throw unmatchedUnlockException();
  107.                 }
  108.                 --rh.count;
  109.             }
  110.             for (;;) {
  111.                 int c = getState();
  112.                 int nextc = c - SHARED_UNIT;
  113.                 if (compareAndSetState(c, nextc))
  114.                     // Releasing the read lock has no effect on readers,
  115.                     // but it may allow waiting writers to proceed if
  116.                     // both read and write locks are now free.
  117.                     return nextc == 0;
  118.             }
  119.         }
  121.         protected final int tryAcquireShared(int unused) {
  122.             /*
  123.              * Walkthrough:
  124.              * 1. If write lock held by another thread, fail.
  125.              * 2. Otherwise, this thread is eligible for
  126.              *    lock wrt state, so ask if it should block
  127.              *    because of queue policy. If not, try
  128.              *    to grant by CASing state and updating count.
  129.              *    Note that step does not check for reentrant
  130.              *    acquires, which is postponed to full version
  131.              *    to avoid having to check hold count in
  132.              *    the more typical non-reentrant case.
  133.              * 3. If step 2 fails either because thread
  134.              *    apparently not eligible or CAS fails or count
  135.              *    saturated, chain to version with full retry loop.
  136.              */
  137.             Thread current = Thread.currentThread();
  138.             int c = getState();
  139.             if (exclusiveCount(c) != 0 &&
  140.                 getExclusiveOwnerThread() != current)
  141.                 return -1;
  142.             int r = sharedCount(c);
  143.             if (!readerShouldBlock() &&
  144.                 r < MAX_COUNT &&
  145.                 compareAndSetState(c, c + SHARED_UNIT)) {
  146.                 if (r == 0) {
  147.                     firstReader = current;
  148.                     firstReaderHoldCount = 1;
  149.                 } else if (firstReader == current) {
  150.                     firstReaderHoldCount++;
  151.                 } else {
  152.                     HoldCounter rh = cachedHoldCounter;
  153.                     if (rh == null || rh.tid != getThreadId(current))
  154.                         cachedHoldCounter = rh = readHolds.get();
  155.                     else if (rh.count == 0)
  156.                         readHolds.set(rh);
  157.                     rh.count++;
  158.                 }
  159.                 return 1;
  160.             }
  161.             return fullTryAcquireShared(current);
  162.         }
  164.         /**
  165.          * Performs tryLock for write, enabling barging in both modes.
  166.          * This is identical in effect to tryAcquire except for lack
  167.          * of calls to writerShouldBlock.
  168.          */
  169.         final boolean tryWriteLock() {
  170.             Thread current = Thread.currentThread();
  171.             int c = getState();
  172.             if (c != 0) {
  173.                 int w = exclusiveCount(c);
  174.                 if (w == 0 || current != getExclusiveOwnerThread())
  175.                     return false;
  176.                 if (w == MAX_COUNT)
  177.                     throw new Error("Maximum lock count exceeded");
  178.             }
  179.             if (!compareAndSetState(c, c + 1))
  180.                 return false;
  181.             setExclusiveOwnerThread(current);
  182.             return true;
  183.         }
  185.         /**
  186.          * Performs tryLock for read, enabling barging in both modes.
  187.          * This is identical in effect to tryAcquireShared except for
  188.          * lack of calls to readerShouldBlock.
  189.          */
  190.         final boolean tryReadLock() {
  191.             Thread current = Thread.currentThread();
  192.             for (;;) {
  193.                 int c = getState();
  194.                 if (exclusiveCount(c) != 0 &&
  195.                     getExclusiveOwnerThread() != current)
  196.                     return false;
  197.                 int r = sharedCount(c);
  198.                 if (r == MAX_COUNT)
  199.                     throw new Error("Maximum lock count exceeded");
  200.                 if (compareAndSetState(c, c + SHARED_UNIT)) {
  201.                     if (r == 0) {
  202.                         firstReader = current;
  203.                         firstReaderHoldCount = 1;
  204.                     } else if (firstReader == current) {
  205.                         firstReaderHoldCount++;
  206.                     } else {
  207.                         HoldCounter rh = cachedHoldCounter;
  208.                         if (rh == null || rh.tid != getThreadId(current))
  209.                             cachedHoldCounter = rh = readHolds.get();
  210.                         else if (rh.count == 0)
  211.                             readHolds.set(rh);
  212.                         rh.count++;
  213.                     }
  214.                     return true;
  215.                 }
  216.             }
  217.         }
  219.         final boolean isWriteLocked() {
  220.             return exclusiveCount(getState()) != 0;
  221.         }
  222.     }
  224.     /**
  225.      * 非公平锁
  226.      */
  227.     static final class NonfairSync extends Sync {
  229.         final boolean writerShouldBlock() {
  230.             return false; // writers can always barge
  231.         }
  232.         final boolean readerShouldBlock() {
  233.             /* As a heuristic to avoid indefinite writer starvation,
  234.              * block if the thread that momentarily appears to be head
  235.              * of queue, if one exists, is a waiting writer.  This is
  236.              * only a probabilistic effect since a new reader will not
  237.              * block if there is a waiting writer behind other enabled
  238.              * readers that have not yet drained from the queue.
  239.              */
  240.             return apparentlyFirstQueuedIsExclusive();
  241.         }
  242.     }
  244.     /**
  245.      * 公平锁
  246.      */
  247.     static final class FairSync extends Sync {
  249.         final boolean writerShouldBlock() {
  250.             return hasQueuedPredecessors();
  251.         }
  252.         final boolean readerShouldBlock() {
  253.             return hasQueuedPredecessors();
  254.         }
  255.     }
  257.     /**
  258.      * 读锁
  259.      */
  260.     public static class ReadLock implements Lock, java.io.Serializable {
  262.         private final Sync sync;
  264.         protected ReadLock(ReentrantReadWriteLock lock) {
  265.             sync = lock.sync;
  266.         }
  268.         public void lock() {
  269.             sync.acquireShared(1);
  270.         }
  272.         public void lockInterruptibly() throws InterruptedException {
  273.             sync.acquireSharedInterruptibly(1);
  274.         }
  276.         public boolean tryLock() {
  277.             return sync.tryReadLock();
  278.         }
  280.         public boolean tryLock(long timeout, TimeUnit unit)
  281.                 throws InterruptedException {
  282.             return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
  283.         }
  285.         public void unlock() {
  286.             sync.releaseShared(1);
  287.         }
  288.     }
  290.     /**
  291.      * 写锁
  292.      */
  293.     public static class WriteLock implements Lock, java.io.Serializable {
  295.         private final Sync sync;
  297.         protected WriteLock(ReentrantReadWriteLock lock) {
  298.             sync = lock.sync;
  299.         }
  301.         public void lock() {
  302.             sync.acquire(1);
  303.         }
  305.         public void lockInterruptibly() throws InterruptedException {
  306.             sync.acquireInterruptibly(1);
  307.         }
  309.         public boolean tryLock( ) {
  310.             return sync.tryWriteLock();
  311.         }
  313.         public boolean tryLock(long timeout, TimeUnit unit)
  314.                 throws InterruptedException {
  315.             return sync.tryAcquireNanos(1, unit.toNanos(timeout));
  316.         }
  318.         public void unlock() {
  319.             sync.release(1);
  320.         }
  321.     }
  323.     public final boolean isFair() {
  324.         return sync instanceof FairSync;
  325.     }
  327.     public boolean isWriteLocked() {
  328.         return sync.isWriteLocked();
  329.     }
  330. }

AbstractQueuedSynchronizer

最后看一下抽象类 AbstractQueuedSynchronizer，在同步组件的实现中，AQS 是核心部分，同步组件的实现者通过使用 AQS 提供的模板方法实现同步组件语义，AQS 则实现了对同步状态的管理，以及对阻塞线程进行排队，等待通知等等一些底层的实现处理。AQS 的核心包括：同步队列，独占式锁的获取和释放，共享锁的获取和释放以及可中断锁，超时等待锁获取这些特性的实现，而这些实际上则是 AQS 提供出来的模板方法。源码如下。

  1. public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
  2.     implements java.io.Serializable {
  4.     /**
  5.      * 当共享资源被某个线程占有，其他请求该资源的线程将会阻塞，从而进入同步队列。
  6.      * 就数据结构而言，队列的实现方式无外乎两者一是通过数组的形式，另外一种则是链表的形式。
  7.      * AQS中的同步队列则是通过链式方式进行实现，下面的内部类Node便是其实现的载体
  8.      */
  9.     static final class Node {
  11.         /** Marker to indicate a node is waiting in shared mode */
  12.         static final Node SHARED = new Node();
  13.         /** Marker to indicate a node is waiting in exclusive mode */
  14.         static final Node EXCLUSIVE = null;
  16.         // 节点从同步队列中取消
  17.         static final int CANCELLED =  1;
  18.         // 后继节点的线程处于等待状态，如果当前节点释放同步状态会通知后继节点，
  19.         // 使得后继节点的线程能够运行；
  20.         static final int SIGNAL    = -1;
  21.         // 当前节点进入等待队列中
  22.         static final int CONDITION = -2;
  23.         // 表示下一次共享式同步状态获取将会无条件传播下去
  24.         static final int PROPAGATE = -3;
  26.         // 节点状态
  27.         volatile int waitStatus;
  29.         // 当前节点/线程的前驱节点
  30.         volatile Node prev;
  32.         // 当前节点/线程的后驱节点
  33.         volatile Node next;
  35.         // 加入同步队列的线程引用
  36.         volatile Thread thread;
  38.         // 等待队列中的下一个节点
  39.         Node nextWaiter;
  41.         final boolean isShared() {
  42.             return nextWaiter == SHARED;
  43.         }
  45.         final Node predecessor() throws NullPointerException {
  46.             Node p = prev;
  47.             if (p == null)
  48.                 throw new NullPointerException();
  49.             else
  50.                 return p;
  51.         }
  53.         Node() {    // Used to establish initial head or SHARED marker
  54.         }
  56.         Node(Thread thread, Node mode) {     // Used by addWaiter
  57.             this.nextWaiter = mode;
  58.             this.thread = thread;
  59.         }
  61.         Node(Thread thread, int waitStatus) { // Used by Condition
  62.             this.waitStatus = waitStatus;
  63.             this.thread = thread;
  64.         }
  65.     }
  67.     /**
  68.      * AQS实际上通过头尾指针来管理同步队列，同时实现包括获取锁失败的线程进行入队，
  69.      * 释放锁时对同步队列中的线程进行通知等核心方法。
  70.      */
  71.     private transient volatile Node head;
  72.     private transient volatile Node tail;
  74.     /**
  75.      * 获取独占式锁
  76.      */
  77.     public final void acquire(int arg) {
  78.         if (!tryAcquire(arg) &&
  79.             acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
  80.             selfInterrupt();
  81.     }
  83.     /**
  84.      * 释放独占式锁
  85.      */
  86.     public final boolean release(int arg) {
  87.         if (tryRelease(arg)) {
  88.             Node h = head;
  89.             if (h != null && h.waitStatus != 0)
  90.                 unparkSuccessor(h);
  91.             return true;
  92.         }
  93.         return false;
  94.     }
  96.     /**
  97.      * 获取可中断式锁
  98.      */
  99.     public final void acquireInterruptibly(int arg)
  100.             throws InterruptedException {
  101.         if (Thread.interrupted())
  102.             throw new InterruptedException();
  103.         if (!tryAcquire(arg))
  104.             doAcquireInterruptibly(arg);
  105.     }
  107.     /**
  108.      * 获取共享锁
  109.      */
  110.     public final void acquireShared(int arg) {
  111.         if (tryAcquireShared(arg) < 0)
  112.             doAcquireShared(arg);
  113.     }
  115.     /**
  116.      * 释放共享锁
  117.      */
  118.     public final boolean releaseShared(int arg) {
  119.         if (tryReleaseShared(arg)) {
  120.             doReleaseShared();
  121.             return true;
  122.         }
  123.         return false;
  124.     }
  125. }