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

• 1. Lock
• 2. ReentrantLock
• 3. ReadWriteLock
• 4. ReentrantReadWriteLock

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();
}

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。就是有一个期望值，当比较当前值与期望值是否相等，当相等时，将值进行更新。所以，当多个线程同时去改变一个值的时候，肯定只有一个线程是可以成功的。因为，这些线程的期望值肯定都是一样的，当其中一个线程修改值之后，其他线程的期望值就对比不成功了。所以，每次最多一个线程能够执行成功。

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

Lock readLock();
Lock writeLock();

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

• 读操作其实是不需要同步的，只有当写操作在进行中时才需要同步等待，所以当没有写操作时，是空锁，所有线程可以同时调用。
  
• 写操作是必须同步的，所以，一次只有一个线程可以占有写锁。
  
• 读锁和写锁不能同时被持有，不管是单个线程还是不同的线程。当有读锁在读数据时，写锁也是不能被持有的，必须等待所有的读操作完成，再获得写锁。同样，当写锁被持有时，读锁也不能被持有。
  

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

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