Java多线程中ReentrantLock与Condition Java多线程中ReentrantLock与Condition详解

Lock lock = ...; 
if (lock.tryLock()) { 
try { 
// manipulate protected state 
} finally { 
lock.unlock(); 
} 
} else { 
// perform alternative actions 
} 

package cn.outofmemory.locks;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class App {
	static class NumberWrapper {
		public int value = 1;
	}
	public static void main(String[] args) {
		//初始化可重入锁
		final Lock lock = new ReentrantLock();
		//第一个条件当屏幕上输出到3
		final Condition reachThreeCondition = lock.newCondition();
		//第二个条件当屏幕上输出到6
		final Condition reachSixCondition = lock.newCondition();
		//NumberWrapper只是为了封装一个数字，一边可以将数字对象共享，并可以设置为final
		//注意这里不要用Integer, Integer 是不可变对象
		final NumberWrapper num = new NumberWrapper();
		//初始化A线程
		Thread threadA = new Thread(new Runnable() {
			@Override
						public void run() {
				//需要先获得锁
				lock.lock();
				try {
					System.out.println("threadA start write");
					//A线程先输出前3个数
					while (num.value <= 3) {
						System.out.println(num.value);
						num.value++;
					}
					//输出到3时要signal，告诉B线程可以开始了
					reachThreeCondition.signal();
				}
				finally {
					lock.unlock();
				}
				lock.lock();
				try {
					//等待输出6的条件
					reachSixCondition.await();
					System.out.println("threadA start write");
					//输出剩余数字
					while (num.value <= 9) {
						System.out.println(num.value);
						num.value++;
					}
				}
				catch (InterruptedException e) {
					e.printStackTrace();
				}
				finally {
					lock.unlock();
				}
			}
		}
		);
		Thread threadB = new Thread(new Runnable() {
			@Override
						public void run() {
				try {
					lock.lock();
					while (num.value <= 3) {
						//等待3输出完毕的信号
						reachThreeCondition.await();
					}
				}
				catch (InterruptedException e) {
					e.printStackTrace();
				}
				finally {
					lock.unlock();
				}
				try {
					lock.lock();
					//已经收到信号，开始输出4，5，6
					System.out.println("threadB start write");
					while (num.value <= 6) {
						System.out.println(num.value);
						num.value++;
					}
					//4，5，6输出完毕，告诉A线程6输出完了
					reachSixCondition.signal();
				}
				finally {
					lock.unlock();
				}
			}
		}
		);
		//启动两个线程
		threadB.start();
		threadA.start();
	}
}

voidawait()throwsInterruptedException; 
voidawaitUninterruptibly(); 
longawaitNanos(longnanosTimeout)throwsInterruptedException; 
booleanawait(longtime,TimeUnitunit)throwsInterruptedException; 
booleanawaitUntil(Datedeadline)throwsInterruptedException; 
voidsignal(); 
voidsignalAll();

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ProductQueue<T> {
	private final T[] items;
	private final Lock lock = new ReentrantLock();
	private Condition notFull = lock.newCondition();
	private Condition notEmpty = lock.newCondition();
	// 
	private int head, tail, count;
	public ProductQueue(int maxSize) {
		items = (T[]) new Object[maxSize];
	}
	public ProductQueue() {
		this(10);
	}
	public void put(T t) throws InterruptedException {
		lock.lock();
		try {
			while (count == getCapacity()) {
				notFull.await();
			}
			items[tail] = t;
			if (++tail == getCapacity()) {
				tail = 0;
			}
			++count;
			notEmpty.signalAll();
		}
		finally {
			lock.unlock();
		}
	}
	public T take() throws InterruptedException {
		lock.lock();
		try {
			while (count == 0) {
				notEmpty.await();
			}
			T ret = items[head];
			items[head] = null;
			//GC 
			// 
			if (++head == getCapacity()) {
				head = 0;
			}
			--count;
			notFull.signalAll();
			return ret;
		}
		finally {
			lock.unlock();
		}
	}
	public int getCapacity() {
		return items.length;
	}
	public int size() {
		lock.lock();
		try {
			return count;
		}
		finally {
			lock.unlock();
		}
	}
}

public final void await() throws InterruptedException { 
 if (Thread.interrupted()) 
  throw new InterruptedException(); 
 Node node = addConditionWaiter(); 
 int savedState = fullyRelease(node); 
 int interruptMode = 0; 
 while (!isOnSyncQueue(node)) { 
  LockSupport.park(this); 
  if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) 
   break; 
 } 
 if (acquireQueued(node, savedState) && interruptMode != THROW_IE) 
  interruptMode = REINTERRUPT; 
 if (node.nextWaiter != null) 
  unlinkCancelledWaiters(); 
 if (interruptMode != 0) 
  reportInterruptAfterWait(interruptMode); 
} 

private transient Node firstWaiter; 
private transient Node lastWaiter; 

private void doSignal(Node first) { 
  do { 
    if ( (firstWaiter = first.nextWaiter) == null) 
      lastWaiter = null; 
    first.nextWaiter = null; 
  } while (!transferForSignal(first) && 
       (first = firstWaiter) != null); 
} 
 
private void doSignalAll(Node first) { 
  lastWaiter = firstWaiter = null; 
  do { 
    Node next = first.nextWaiter; 
    first.nextWaiter = null; 
    transferForSignal(first); 
    first = next; 
  } while (first != null); 
} 

final boolean transferForSignal(Node node) { 
  if (!compareAndSetWaitStatus(node, Node.CONDITION, 0)) 
    return false; 
 
  Node p = enq(node); 
  int c = p.waitStatus; 
  if (c > 0 || !compareAndSetWaitStatus(p, c, Node.SIGNAL)) 
    LockSupport.unpark(node.thread); 
  return true; 
}