Java并发包4--可重入锁ReentrantLock的实现原理

 1     /**
 2      * 加锁,如果加锁失败则会阻塞当前线程,直到加锁成功
 3      */
 4     void lock();
 5 
 6     /**
 7      * 同上,不过会响应中断,当线程设置中断时会抛异常退出
 8      */
 9     void lockInterruptibly() throws InterruptedException;
10 
11     /**
12      * 尝试加锁,不会阻塞当前线程,加锁失败则直接返回false,成功则返回true
13      */
14     boolean tryLock();
15 
16     /**
17      * 同上,不过有超时时间,当直到时间之后还是没有加锁成功,则返回false,成功则返回true
18      */
19     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
20 
21     /**
22      * 解锁
23      */
24     void unlock();
25 
26     /**
27      * 创建Condition对象,用于实现线程的等待/唤醒机制
28      */
29     Condition newCondition();

1         ReentrantLock lock = new ReentrantLock(true);//初始化Lock对象
2         lock.lock();//加锁操作
3         try{
4             //TODO do someThing
5         }catch (Exception e){
6             e.printStackTrace();
7         }finally {
8             lock.unlock();//解锁操作
9         }

1 /**默认构造函数,默认采用非公平锁*/
2     public ReentrantLock() {
3         sync = new NonfairSync();
4     }
5 
6     /**传入fair字段表示是否采用公平锁,true为公平锁;false为非公平锁*/
7     public ReentrantLock(boolean fair) {
8         sync = fair ? new FairSync() : new NonfairSync();
9     }

 1 /**加锁方法*/   
 2 public void lock() {
 3         sync.lock();
 4     }
 5 
 6 /**尝试加锁方法*/
 7 public boolean tryLock() {
 8         return sync.nonfairTryAcquire(1);
 9     }
10 
11 /**解锁方法*/
12 public void unlock() {
13         sync.release(1);
14     }
15 
16 /**创建Condition对象*/
17 public Condition newCondition() {
18         return sync.newCondition();
19     }
20 
21 /**判断当前线程是否独占锁*/
22 public boolean isHeldByCurrentThread() {
23         return sync.isHeldExclusively();
24     }

1 /** class FairSync * /
2 
3 /**公平锁*/
4 final void lock() {
5             acquire(1);//调用AQS的acquire方法
6         }

 1 /**公平加锁*/
 2     protected final boolean tryAcquire(int acquires) {
 3         final Thread current = Thread.currentThread();//获取当前线程
 4         int c = getState();//获取当前同步状态
 5         if (c == 0) {//当状态为0时表示锁没有被占有
 6             /**
 7              * 尝试获取锁
 8              * hasQueuedPredecessors()方法判断当前线程是否是head节点的后继节点
 9              * compareAndSetState()通过CAS来设置AQS的state值
10              * */
11             if (!hasQueuedPredecessors() &&
12                     compareAndSetState(0, acquires)) {
13                 /**设置当前线程为占用锁的线程*/
14                 setExclusiveOwnerThread(current);
15                 return true;
16             }
17         }
18         /**
19          * 当状态不为0时，表示锁已经被占用，此时判断当前线程是否是占用锁的线程
20          * getExclusiveOwnerThread()方法返回当前占用锁的线程
21          * */
22         else if (current == getExclusiveOwnerThread()) {
23             /**
24              * 如果当前线程已经占有了锁，则修改状态+1，表示占用了锁次数+1
25              * 所以可重入锁的实现原理就是state值 + 1
26              * */
27             int nextc = c + acquires;
28             if (nextc )
29                 throw new Error("Maximum lock count exceeded");
30             /**设置同步状态值 = 旧状态值 + 1*/
31             setState(nextc);
32             return true;
33         }
34         return false;
35     }

 1     /**非公平锁加锁*/
 2     final void lock() {
 3         /**直接通过CAS尝试设置同步状态,
 4          * 成功则调用setExclusiveOwnerThread方法设置当前线程为占用锁的线程*/
 5         if (compareAndSetState(0, 1))
 6             setExclusiveOwnerThread(Thread.currentThread());
 7         else
 8             /**失败则调用AQS的acquire方法，实际是调用tryAcquire方法*/
 9             acquire(1);
10     }
11 
12     protected final boolean tryAcquire(int acquires) {
13         /**调用Sync的nonfairTryAcquire方法*/
14         return nonfairTryAcquire(acquires);
15     }
16 
17     /**非公平获取同步状态*/
18     final boolean nonfairTryAcquire(int acquires) {
19         final Thread current = Thread.currentThread();
20         int c = getState();
21         if (c == 0) {
22             /**
23              * 判断当前同步状态值，值为0则表示可以获取锁
24              * 直接通过CAS设置同步状态，成功则获取锁成功
25              * */
26             if (compareAndSetState(0, acquires)) {
27                 setExclusiveOwnerThread(current);
28                 return true;
29             }
30         }
31         /**
32          * 当锁被占用后判断是否占用锁的线程是否是当前线程
33          * 如果是则状态值+1，表示锁可以重入
34          * */
35         else if (current == getExclusiveOwnerThread()) {
36             int nextc = c + acquires;
37             if (nextc // overflow
38                 throw new Error("Maximum lock count exceeded");
39             setState(nextc);
40             return true;
41         }
42         return false;
43     }

 1 /**ReentrantLock的解锁方法直接调用Sync的解锁方法
 2      * release()是父类AQS的方法,实际是调用了子类的tryRelease方法*/
 3     public void unlock() {
 4         sync.release(1);
 5     }
 6 
 7     /**Sync重写了AQS的tryRelease方法*/
 8     protected final boolean tryRelease(int releases) {
 9         /**1. 获取同步状态 -1 表示释放一次锁*/
10         int c = getState() - releases;
11         /**2. 判断当前线程是否是当前占有锁的线程*/
12         if (Thread.currentThread() != getExclusiveOwnerThread())
13             throw new IllegalMonitorStateException();
14         boolean free = false;
15         /**3. 如果同步状态值为0,表示锁完全释放了,则清除当前线程为占有锁的线程
16          *    如果同步状态值不为0，则表示加锁的次数多于解锁的次数,还需要继续解锁*/
17         if (c == 0) {
18             free = true;
19             setExclusiveOwnerThread(null);
20         }
21         /**设置同步状态值为最新的状态值*/
22         setState(c);
23         return free;
24     }