Java并发系列（5）ReentrantLock源码分析

public void doSomething() {
    //默认是获取一个非公平锁
    ReentrantLock lock = new ReentrantLock();
    try{
        //执行前先加锁
        lock.lock();   
        //执行操作...
    }finally{
        //最后释放锁
        lock.unlock();
    }
}

//获取锁的操作
public void lock() {
    sync.lock();
}
//释放锁的操作
public void unlock() {
    sync.release(1);
}

public class ReentrantLock implements Lock, java.io.Serializable {
    
    private final Sync sync;

    abstract static class Sync extends AbstractQueuedSynchronizer {
        abstract void lock();
    }
    
    //实现非公平锁的同步器
    static final class NonfairSync extends Sync {
        final void lock() {
            ...
        }
    }
    
    //实现公平锁的同步器
    static final class FairSync extends Sync {
        final void lock() {
            ...
        }
    }
}

//默认无参构造器
public ReentrantLock() {
    sync = new NonfairSync();
}

//有参构造器
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

//释放锁的操作(独占模式)
public final boolean release(int arg) {
    //拨动密码锁, 看看是否能够开锁
    if (tryRelease(arg)) {
        //获取head结点
        Node h = head;
        //如果head结点不为空并且等待状态不等于0就去唤醒后继结点
        if (h != null && h.waitStatus != 0) {
            //唤醒后继结点
            unparkSuccessor(h);
        }
        return true;
    }
    return false;
}

//尝试释放锁
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    //如果持有锁的线程不是当前线程就抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread()) {
        throw new IllegalMonitorStateException();
    }
    boolean free = false;
    //如果同步状态为0则表明锁被释放
    if (c == 0) {
        //设置锁被释放的标志为真
        free = true;
        //设置占用线程为空
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

//非公平同步器
static final class NonfairSync extends Sync {
    //实现父类的抽象获取锁的方法
    final void lock() {
        //使用CAS方式设置同步状态
        if (compareAndSetState(0, 1)) {
            //如果设置成功则表明锁没被占用
            setExclusiveOwnerThread(Thread.currentThread());
        } else {
            //否则表明锁已经被占用, 调用acquire让线程去同步队列排队获取
            acquire(1);
        }
    }
    //尝试获取锁的方法
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

//以不可中断模式获取锁(独占模式)
public final void acquire(int arg) {
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
        selfInterrupt();
    }
}

//非公平的获取锁
final boolean nonfairTryAcquire(int acquires) {
    //获取当前线程
    final Thread current = Thread.currentThread();
    //获取当前同步状态
    int c = getState();
    //如果同步状态为0则表明锁没有被占用
    if (c == 0) {
        //使用CAS更新同步状态
        if (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;
}

//实现公平锁的同步器
static final class FairSync extends Sync {
    //实现父类的抽象获取锁的方法
    final void lock() {
        //调用acquire让线程去同步队列排队获取
        acquire(1);
    }
    //尝试获取锁的方法
    protected final boolean tryAcquire(int acquires) {
        //获取当前线程
        final Thread current = Thread.currentThread();
        //获取当前同步状态
        int c = getState();
        //如果同步状态0则表示锁没被占用
        if (c == 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;
    }
}

public class BoundedBuffer {

    final Lock lock = new ReentrantLock();
    final Condition notFull = lock.newCondition();   //条件谓词：notFull
    final Condition notEmpty = lock.newCondition();  //条件谓词：notEmpty
    final Object[] items = new Object[100];
    int putptr, takeptr, count;

    //生产方法
    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await();  //队列已满, 线程在notFull队列上等待
            items[putptr] = x;
            if (++putptr == items.length) putptr = 0;
            ++count;
            notEmpty.signal(); //生产成功, 唤醒notEmpty队列的结点
        } finally {
            lock.unlock();
        }
    }

    //消费方法
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await(); //队列为空, 线程在notEmpty队列上等待
            Object x = items[takeptr];
            if (++takeptr == items.length) takeptr = 0;
            --count;
            notFull.signal();  //消费成功, 唤醒notFull队列的结点
            return x;
        } finally {
            lock.unlock();
        }
    }
    
}

//创建条件队列
public Condition newCondition() {
    return sync.newCondition();
}

abstract static class Sync extends AbstractQueuedSynchronizer {
    //新建Condition对象
    final ConditionObject newCondition() {
        return new ConditionObject();
    }
}