Java并发编程：Concurrent锁机制解析

Table of Contents

1. 本质

2. Lock

3. ReentrantLock

4. ReadWriteLock

5. ReentrantReadWriteLock

前面，我们讲了Java自带的对象锁机制。因为我们的方法必然是在一个对象中的，所以，通过对象的锁，可以很好的控制对方法的调用。当对象的锁被一个线程持有后，其他线程想要调用该对象的该方法，就必须进入等待池，等待当前线程执行完毕后，由系统来决定选中谁接下来继续执行。这种方法非常的直观，原理也非常的清晰。

那么，Doug Lea为什么会额外再开发一个并行包呢？

首先，我们从他的Lock锁来看一下，这么做带来的好处。

我觉得最主要的好处是：

Lock可以查询到更多的信息，包括当前持有的线程，排队等待的线程数量等，这一点很关键，极大的提高了适用范围，这是后面很多的并发类的基础；

读写锁的分离，相当于在原有的独占锁的基础上，增加了共享锁。对于不需要同步的方法，使用共享锁，所有线程可以同时调用，仅对外部方法进行同步，这一点可以极大的提高性能。

1 本质

这些锁的本质是一个AbstractQueuedSynchronizer，是一个CLH队列。当锁对象没有被线程持有时（state状态值为0），线程可以获取锁，并将state加1，这时，再有新的线程来获取锁时，就需要放到CLH队列中了，等当前运行的线程将所有的锁释放掉之后，state重新变为0.这时队列中的node可以去获取锁。

2 Lock

Concurrent包中的Lock只是一个接口类，本身并没有实现。它定义了三个主要的方法，lock(),unlock(),newCondition()。lock()用于线程获取锁，执行到该方法时，如果锁没有被线程占有，则把锁分配给线程，如果已经分配，则等待；unlock()用于解除线程锁定；newCondition()用于创建条件。线程获取锁还有三种其他的方式，如是获取之后是否可以被中断，以试探的方式去获取锁等。

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

3 ReentrantLock

ReentrantLock是对Lock接口类的一种实现，本质是一种独占锁。使用一个state来保存一个线程调用lock()的次数。当state为0时，锁可以被线程持有，持有之后将state改为1，这样其他线程就不能再次获得该锁了，只有该线程可以再次持有，这就是重入，也就是这个锁的名字的由来。当该线程调用unlock()时，state值减1，直到state再次等于0，表示该线程完全释放了锁。

这个状态量是用一个int来保存的，并且当值超过int表示的最大正整数，就会溢出变为负数，小于0就会报错。所以，同一个锁最多能重入Integer.MAX_VALUE次，也就是2147483647。

int nextc = c + acquires;
if (nextc < 0)
    throw new Error("Maximum lock count exceeded");

至于底层的实现方式，如果看过源代码的话，就会发现基本上是基于CAS实现的，就是compare and swap。就是有一个期望值，当比较当前值与期望值是否相等，当相等时，将值进行更新。所以，当多个线程同时去改变一个值的时候，肯定只有一个线程是可以成功的。因为，这些线程的期望值肯定都是一样的，当其中一个线程修改值之后，其他线程的期望值就对比不成功了。所以，每次最多一个线程能够执行成功。

4 ReadWriteLock

ReadWriteLock同样是一个接口类，有两个方法，分别返回一个读锁和一个写锁，但它们共用一个AQS队列。

Lock readLock();
Lock writeLock();

5 ReentrantReadWriteLock

读写锁的分离意义太重大了，因为很多时候，我们大部分的操作都是在读数据，只有少数情况是需要写数据，如果直接使用同步或者是重入锁，那么性能和效率会非常低。

读锁和写锁有本质的区别，读锁是共享锁，写锁是独占锁。

读操作其实是不需要同步的，只有当写操作在进行中时才需要同步等待，所以当没有写操作时，是空锁，所有线程可以同时调用。

写操作是必须同步的，所以，一次只有一个线程可以占有写锁。

锁升级是不允许的，就是当有读锁在读数据时，写锁是不能被持有的，必须等待所有的读操作完成，再获得写锁。

写锁可以降级为读锁，就是写线程可以同时获得读锁，当写锁释放之后，继续持有读锁，然后，再释放读锁。

实际上，读锁和写锁是共用一个AQS队列，状态量state也是共用一个。低16位表示写锁，高16位表示读锁。所以，写锁和读锁的可重入数最多锁65535个。

不同的是，获取锁的方式不同：

// 读锁获取锁的方式，是获取共享锁
public void lock() {
    sync.acquireShared(1);
}
// 写锁获取锁的方式，是获取独占锁
public void lock() {
    sync.acquire(1);
}

Date: 2017-07-08 10:22

Author: WEN YANG

Created: 2017-07-12 Wed 21:15

Emacs 25.2.1 (Org mode 8.2.10)

Validate