Lock_安科网

之前对于synchronized的实现和运用有所了解，但是也发现了一些缺陷，由于synchronized是在JVM层面上实现同步互斥，是以关键字形式加锁，导致其颗粒度过大，有的时候不需要这么大范围的加锁，在中断和线程阻塞处理上也有所欠缺，在JDK1.5之后，Java引入了Lock，作为对于synchronized的补充。

实现原理

Lock是Java的一个接口类，而继承它实现的也是一个Java类，因此Lock的实现不是基于JVM的，而是在应用层，接口源码如下

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

这几个方法就是Lock的核心实现。而Lock的实现类是ReentrantLock，这里需要讲一下ReentrantLock的结构，ReentrantLock把对Lock的实现交给了继承AbstractQueuedSynchronizer抽象类的Sync类，而为了实现公平锁和和非公平锁，又加入了FairSync和NonfairSync两个继承Sync的类来重写lock()方法。

abstract static class Sync extends AbstractQueuedSynchronizer
static final class NonfairSync extends Sync
static final class FairSync extends Sync

而ReentrantLock的加锁解锁原理则是利用AbstractQueuedSynchronizer类的方法，把所有的请求线程构成一个CLH队列(虚拟队列，将每个线程内容包装成一个Node类)，运行线程不包括在内，如果有新进程加入，则阻塞并加入到队列尾部，如果运行线程结束，就从队列中获取下个线程。

Lock

在了解加锁和解锁过程之前首先需要了解Lock怎么阻塞线程，源码中显示调用了LockSupport.park()，在深入结果是调用sun.misc.Unsafe.park()本地方法，从而调用系统互斥锁。下面就是加锁和解锁的过程

加锁

对于加锁过程，非公平锁和公平锁机制不同，这里分开描述。 非公平锁

在开始就先尝试当前线程获取锁，如果成功，那么直接将锁锁定，不成功再进入队列调用的流程。进入队列调用的第一步是获取当前锁的状态，如果锁状态值为0，尝试获取锁，如果成功的话，将锁赋给当前线程，失败就阻塞后进入队列尾部排队。

如果锁状态值为1，先看是否为存在重入锁的情况，即线程和运行线程相同，如果是，那么锁状态加1，如果不是，那么阻塞后进入队列尾部排队。

//ReentrantLock.java文件
final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();//获取当前线程
    int c = getState();//获取锁状态值
    if (c == 0) { //如果锁状态为0，那么没有线程占用锁
        if (compareAndSetState(0, acquires)) {//CAS尝试获得锁
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //如果锁状态不为0
    else if (current == getExclusiveOwnerThread()) {//如果当前线程就是锁的线程，进入重入锁状态
        int nextc = c + acquires;//锁状态值加1
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}
//AbstractQueuedSynchronizer.java文件
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
    acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    selfInterrupt();
}

公平锁

不尝试获取锁，直接进入队列流程在队列流程中，同样获取锁的状态值，如果状态值为0，并且队列中没有排队的线程，那么尝试获取锁，如果有线程，那么就阻塞线程并放在队列尾部排队

如果状态值不为0，先看是否为存在重入锁的情况，即线程和运行线程相同，如果是，那么锁状态加1，如果不是，那么阻塞后进入队列尾部排队。

//ReentrantLock.java文件
 final void lock() {
    acquire(1);
}

/**
 * Fair version of tryAcquire.  Don't grant access unless
 * recursive call or no waiters or is first.
 */
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
    //如果锁状态值为0和队列中没有线程，获取锁
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //重入锁情况
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}
//AbstractQueuedSynchronizer.java文件
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
    acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    selfInterrupt();
}

解锁

获取当前线程的状态值，然后减1

如果结果为0，那么释放这个锁，如果不为0，那么存在重入锁情况，不释放锁

//ReentrantLock.java文件
public void unlock() {
sync.release(1);
}
protected final boolean tryRelease(int releases) {
    //状态值-1
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    //判断重入锁情况
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}
//AbstractQueuedSynchronizer.java文件
public final boolean release(int arg) {
if (tryRelease(arg)) {
//获取排队线程的头线程，运行线程
    Node h = head;
    if (h != null && h.waitStatus != 0)
        unparkSuccessor(h);
    return true;
}
return false;
}

Lock应用

Lock接口有lock()、unlock()、tryLock()、tryLock(long time, TimeUnit unit) 和 lockInterruptibly()这些方法进行加锁和解锁，这里逐个分析（Condition()用于线程间通信，这里暂时不解释）

lock()和unlock()

这两个方法基本都是一起出现的，因为这里放在一起讲，lock()就是用来对代码块进行加锁，而unlock()是对锁的释放，而在它们之间就是加锁的代码，一般会加上try...catch方式，而unlock()一般会出现在finally中，基本格式如下

Lock lock = new Lock();
lock.lock();
try{
//加锁代码块
...
}catch(Exception e){
}finally{
lock.unlock();   //释放锁
}

tryLock()和tryLock(long time, TimeUnit unit)

tryLock()是有返回值的，如果当前锁未被占用，那么就尝试获取锁，这里和lock()一样，并返回true，但是如果锁被占用，那么直接返回false，不阻塞在那里，这是和synchronized区别部分之一，是对加锁的灵活运用。 tryLock(long time, TimeUnit unit)是加上了等待时间，就是在tryLock()基础上加上了尝试获取的等待时间，如果锁获取失败，会等待一段时间，如果等待过程中获取到锁，那么返回true，如果还是没有，那么返回false。一般格式如下

Lock lock = new Lock();
if(lock.tryLock()) {
 try{
     //加锁代码块
...
 }catch(Exception e){
 }finally{
     lock.unlock(); 
 } 
}else {
//不加锁的处理
...
}

lockInterruptibly()

lockInterruptibly()和lock()的机制是一样的，如果没有特殊情况，就是一般的加锁，但是如果在加锁后使用Thread.interrupt中断线程，就会抛异常InterruptedException，因为lock优先考虑获取锁，在等待获取锁的过程中，忽略中断请求，只有成功获得锁之后才响应中断。lockInterruptibly允许在等待获取锁的过程中由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回。

Lock lock = new Lock();
lock.lockInterruptibly();
try{
//加锁代码块
...
}catch(InterruptedException e){
}finally{
lock.unlock();   //释放锁
}