Lock源码
public interface Lock { //获取锁 void lock(); /** *当前线程的锁没有中断才能获取锁 * if (Thread.interrupted()) * throw new InterruptedException(); */ void lockInterruptibly() throws InterruptedException; //获取锁是否成功。true表示获取到锁，false表示没有获取到锁 boolean tryLock(); // 尝试获取锁，并等待指定的时间 boolean tryLock(long time, TimeUnit unit) throws InterruptedException; // 释放锁 void unlock(); // LOCK条件 Condition newCondition();}ReentrantLock源码
public class ReentrantLock implements Lock, java.io.Serializable { // 同步器，是整个锁机制的实现者 private final Sync sync; // 定义的抽象静态内部类。实现基本的功能 abstract static class Sync extends AbstractQueuedSynchronizer { // 抽象方法。由公平锁和非公平锁自己实现 abstract void lock(); // 释放锁 protected final boolean tryRelease(int releases) { // 锁的计数器。释放一次计数器减1，直到为0，则整个锁完全释放，才能被其他线程获取该锁。 int c = getState() - releases; // 此类型锁是可重入锁。因此是以thread为粒度的。必须判断当前线程是否与持有锁线程一致。 if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; // 当锁的计数器为0时，整个锁释放。 if (c == 0) { free = true; setExclusiveOwnerThread(null); } setState(c); return free; } // 默认实现的一个非公平锁的获取尝试获取方法 final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); // 如果锁的计数器为0，则表示没有锁。 if (c == 0) { // compareAndSetState方法实际调用的是unsafe.compareAndSwapInt(this, stateOffset, expect, update); // 直接操作的JVM。并给当前线程持有锁。 if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } // 如果计数器不为0，但当前线程就是持有锁的线程。则锁的计数器增加。 else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } // 如果计数器不为0,同时当前线程不是持有锁的线程。则加锁失败。 return false; } } // 非公平所的实现器 static final class NonfairSync extends Sync { // 加锁。 final void lock() { 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 { // 加锁，队列 final void lock() { acquire(1); } // 试着加锁 protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); 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; } }}AbstractQueuedSynchronizer源码
// 存储队列锁的存储node.是一个双向的链表结构。 static final class Node { // 前一个node volatile Node prev; // 后一个node volatile Node next; // 该node所对应的线程 volatile Thread thread; } // 整个队列锁的第一个node. private transient volatile Node head; // 整个队列锁的第后个node. private transient volatile Node tail; // 锁的状态。计数器 private volatile int state; // 加锁的关键点。通过navtive 方法unsafe直接操作CPU。 protected final boolean compareAndSetState(int expect, int update) { return unsafe.compareAndSwapInt(this, stateOffset, expect, update); }总结
Lock这种以类的方式来实现锁的机制。
优点：
1.加锁和释放锁独立，可以分开来控制。
2.tryLock的方法可以尝试加锁，不会像sychnorized一致阻塞。
3.实现了公平锁和非公平锁。sychnorized只能是非公平锁。
缺点：
1.增加了代码的复杂度。
2.相比sychnorized的自动加锁和释放锁，Lock需要手动，容易忘记，从而出现重大的隐患。
经过JDK的不断更新，sychnorized与lock的性能相差不大，官方建议使用sychnorized方法加锁。