Java 锁机制详解

public interface Lock {
    void lock();                // 阻塞获取锁（不可中断）
    // 可中断地获取锁。
    //线程在等待获取锁的过程中，可以响应中断（interrupt()），从而提前退出等待，而不是像 lock() 那样“死等”下去
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();          // 尝试获取锁，立即返回 true/false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException; // 带超时的尝试
    void unlock();              // 释放锁（必须手动调用！）
    Condition newCondition();   // 创建等待/通知条件对象
}

Lock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区
} finally {
    lock.unlock(); // 必须！
}

public ReentrantLock() {
    sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

//非公平锁
static final class NonfairSync extends Sync {

    final void lock() {
        //判断是不是第一次获取锁，如果是之直接独占
        //compareAndSetState方法的意思是：以原子的方式对比state的值是否是0.如果是的话就设置为acquires
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    //可以看到
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}
=====================================================================
//公平锁
static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            //核心！！！！！！！
            //先判断是否有线程排队，然后再对比state的值
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        //这说明线程有锁
        else if (current == getExclusiveOwnerThread()) {
            //增加重试的次数
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            //次数设置到state里面
            setState(nextc);
            return true;
        }
        return false;
    }
}

    abstract static class Sync extends AbstractQueuedSynchronizer {

        //获取锁
        abstract void lock();

        //非公平的方式获取锁
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //获取state值，这个state是记录线程获取的次数
            int c = getState();
            if (c == 0) {
        //compareAndSetState方法的意思是：以原子的方式对比state的值是否是0.如果是的话就设置为acquires
                if (compareAndSetState(0, acquires)) {
                    //设置锁被当前线程独占
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //这说明线程有锁
            else if (current == getExclusiveOwnerThread()) {
                //增加重试的次数
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                //次数设置到state里面
                setState(nextc);
                return true;
            }
            return false;
        }

    }