Java高并发编程---锁

Lock接口

 Java SE 5之后，并发包中新增了Lock接口（以及相关实现类）用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要显式地获取和释放锁。虽然它缺少了（通过synchronized块或者方法所提供的）隐式获取释放锁的便捷性，但是却拥有了锁获取与释放的可操作性、可中断的获取锁以及超时获取锁等多种synchronized关键字所不具备的同步特性。

简单使用：LockUseCase.java

	Lock lock = new ReentrantLock();
	lock.lock();			//不要将获取锁的过程写在try块中，因为如果在获取锁（自定义锁的实现）时发生了异常，
							//异常抛出的同时，也会导致锁无故释放。
	try {
	} finally {
		lock.unlock();		//在finally块中释放锁，目的是保证在获取到锁之后，最终能够被释放。
	}

Lock接口的优势特性

Lock的API

 Lock接口的实现基本都是通过聚合了一个同步器的子类来完成线程访问控制的。
 

队列同步器

 队列同步器AbstractQueuedSynchronizer（以下简称同步器），是用来构建锁或者其他同步组件的基础框架，它使用了一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。
 同步器的主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态，在抽象方法的实现过程中免不了要对同步状态进行更改，这时就需要使用同步器提供的3个方法（getState()、setState(int newState)和compareAndSetState(int expect,int update)）来进行操作，因为它们能够保证状态的改变是安全的。
 同步器是实现锁（也可以是任意同步组件）的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义。

 锁是面向使用者的，它定义了使用者与锁交互的接口，隐藏了实现细节；同步器面向的是锁的实现者，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。

队列同步器的接口与示例

同步器常用的三个方法：

• getState()：获取当前同步状态。
• setState(int newState)：设置当前同步状态。
• compareAndSetState(int expect,int update)：使用CAS设置当前状态，该方法能够保证状态设置的原子性。

同步器可重写的方法

同步器提供的模板方法

 模板方法基本上分为3类：独占式获取与释放同步状态、共享式获取与释放同步状态 和 查询同步队列中的等待线程情况。

独占锁

 顾名思义，独占锁就是在同一时刻只能有一个线程获取到锁，而其他获取锁的线程只能处于同步队列中等待，只有获取锁的线程释放了锁，后继的线程才能够获取锁。
示例代码：Mutex.java

class Mutex implements Lock {
	// 静态内部类，自定义同步器
	private static class Sync extends AbstractQueuedSynchronizer {
		// 是否处于占用状态
		protected boolean isHeldExclusively() {
			return getState() == 1;
		}
		
		// 当状态为0的时候获取锁
		public boolean tryAcquire(int acquires) {
			if (compareAndSetState(0, 1)) {
				setExclusiveOwnerThread(Thread.currentThread());
				return true;
			}
			return false;
		}
		// 释放锁，将状态设置为0
		protected boolean tryRelease(int releases) {
			if (getState() == 0) throw new
			IllegalMonitorStateException();
			setExclusiveOwnerThread(null);
			setState(0);
			return true;
		}
		// 返回一个Condition，每个condition都包含了一个condition队列
		Condition newCondition() { return new ConditionObject(); }
	}
	
		// 仅需要将操作代理到Sync上即可
		private final Sync sync = new Sync();
		public void lock() { sync.acquire(1); }
		public boolean tryLock() { return sync.tryAcquire(1); }
		public void unlock() { sync.release(1); }
		public Condition newCondition() { return sync.newCondition(); }
		public boolean isLocked() { return sync.isHeldExclusively(); }
		public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
		public void lockInterruptibly() throws InterruptedException {
			sync.acquireInterruptibly(1);
		}
		public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
			return sync.tryAcquireNanos(1, unit.toNanos(timeout));
		}
}

 上述示例中，独占锁Mutex是一个自定义同步组件，它在同一时刻只允许一个线程占有锁。Mutex中定义了一个静态内部类，该内部类继承了同步器并实现了独占式获取和释放同步状态。