多线程(九) Lock家族

public interface Lock {

	// 直接加锁 
	void lock();

	// 支持可中断的加锁
	void lockInterruptibly() throws InterruptedException;

	// 尝试一次加锁
	boolean tryLock();

	// 尝试一次加锁(支持超时停止阻塞)
	boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

	// 解锁
	void unlock();

	// 创建一个Condition(作用于线程通信，后面会讲)
	Condition newCondition();

public class ReentrantLock implements Lock, java.io.Serializable {

	private final Sync sync;

	// 定义一个顶级同步器(内部包含一个非公平加锁方法，一个释放锁方法)
	abstract static class Sync extends AbstractQueuedSynchronizer {

		private static final long serialVersionUID = -5179523762034025860L;

		abstract void lock();

		// 非公平方式尝试一次加锁
		final boolean nonfairTryAcquire(int acquires) {

			// 获取试图尝试加锁的线程
			final Thread current = Thread.currentThread();

			// 获取公共资源状态
			int c = getState();

			// 如果没其他线程持有锁，进行加锁
			if (c == 0) {
				// 加锁前并没有校验等待队列是否已经有节点在等待了，这个if完全体现了非公平性
				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");
				setState(nextc);
				return true;
			}

			// 到这里说明锁被其他线程占了，直接返回false
			return false;
		}

		// 释放锁
		protected final boolean tryRelease(int releases) {

			// 计算递减后的重入次数
			int c = getState() - releases;

			// 如果释放锁线程不是持有锁线程，抛异常(一般能执行这方法的都是持有锁线程)
			if (Thread.currentThread() != getExclusiveOwnerThread())
				throw new IllegalMonitorStateException();

			// 如果递减后为0，那就是真的释放锁了，清空自己的独占状态并返回
			boolean free = false;
			if (c == 0) {
				free = true;
				setExclusiveOwnerThread(null);
			}
			setState(c);
			return free;
		}

		// 返回调用此方法的线程是否持有锁
		protected final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        // 其他方法...
	}

	// 定义一个非公平同步器，继承顶级同步器
	static final class NonfairSync extends Sync {

		private static final long serialVersionUID = 7316153563782823691L;

		// 实现顶级同步器的lock加锁方法
		final void lock() {

			// 尝试CAS 如果成功说明之前没线程加锁
			if (compareAndSetState(0, 1))
				setExclusiveOwnerThread(Thread.currentThread());

			// 失败就在尝试获取一次，这里调用AQS的acquire()方法，
			// AQS的acquire()方法又调用下面重写的tryAcquire方法
			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) {
				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 ReentrantLock() {
        sync = new NonfairSync();
    }

    // 参数构造器，自行选择是否公平
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    // 加锁
    public void lock() {
        sync.lock();
    }

	// 支持可中断加锁
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

	// 尝试一次加锁 
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    // 支持超时的加锁
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    // 解锁
    public void unlock() {
        sync.release(1);
    }

    // 其他方法....
}