多线程学习七——实现独占锁

独占锁获取锁：当一个线程持有锁时其他线程处于等待，当线程释放锁时，其他线程自动竞争锁，竞争成功的继续执行，竞争失败则继续等待。
实现独占锁思路：
1.使用state标识锁的状态，并通过原子操作保证持有锁的线程只有一个。
2.通过双向链表来存储等待队列，每个线程都通过自旋来检查前一个线程的状态来获取是否需要参与竞争锁的信息，达到自动竞争锁的目的。
3.执行完的线程释放锁。
AbstractQueuedSynchronizer独占锁实现思路：
1.首先尝试获取锁，获取锁主要是通过对锁的状态state进行原子操作（compareAndSetState），操作成功则加锁成功，操作失败则加锁失败
2.加锁失败后放到等待队列的尾部，等待队列是由node（双向队列）构成，每一个node有waitStatus：CANCELLED（终止）1，SIGNAL（唤醒）-1，CONDITION（等待）-2状态
每一个等待线程都是一个node，每一个node都通过自旋来检查前一个node是不是head，当线程的前一个node是head时就会再次尝试获取锁，如果获取成功则当前
线程的node变成head并终止自旋返回中断状态，如果当前线程的前一个node不是head或是head但没有成功获取锁则判断是否需要吊起，需要挂起时进行线程挂起并检查
线程是否中断，然后再继续自旋直到获取锁成功并终止自旋返回中断状态。

独占锁释放锁：
1.释放锁时把锁的状态state设置成初始状态。
2.把下一个非终止的node线程从挂起状态唤醒。

package day1;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class MutexLock implements Lock {
	// 静态内部类，自定义同步器
	private static class Sync extends AbstractQueuedSynchronizer {
		/**
		 * 
		 */
		private static final long serialVersionUID = 1L;

		// 是否处于占用状态
		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));
	}
}

如果是一个回调方法的话，会形成死锁，如：

package day1;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MutexLockTest {
	private static MutexLock lock = new MutexLock();
	public static void main(String[] args) {
		ExecutorService executor = Executors.newFixedThreadPool(2);
		executor.execute(new Thread1());
		executor.shutdown();
	}

	static class Thread1 implements Runnable {

		@Override
		public void run() {
			try {
				lock.lock();
				//在此处会形成死锁，因为独占锁只能获得一次
				lock.lock();
				System.out.println(sumNum(1,100));
			} finally {
				lock.unlock();
			}

		}
		int sum = 0;
		public int sumNum(int start,int end) {
			if(start <=end) {
				sum = sum+start;
				sumNum(start+1,end);
			}
			return sum;
		}

	}
}