【JavaSE】マルチスレッド(9)Conditionの待機/通知メカニズム

void await() throws InterruptedException：         ，       condition signal signalAll          Lock，  await    ；               。
long awaitNanos(long nanosTimeout)：               ，     。
boolean await(long time,TimeUnit unit)throws InterruptedException：  ，         。
boolean awaitUntil(Date deadline)throws InterruptedException：               ，         。

void signal()：       condition    ，                  ，           Lock          。
void signalAll()：        condition    。

private transient Node firstWaiter;
private transient Node lastWaiter;

public class BoundedQueue<T> {
	private Object[] items;
	//          
	private int count;
	private Lock lock = new ReentrantLock();
	private Condition empty = lock.newCondition();
	private Condition full = lock.newCondition();
	public BoundedQueue(int size) {
		items = new Object[size];
	}
	//       ，        ，           ，        
	public void add(T t,int addIndex) throws InterruptedException {
		lock.lock();
		try {
			//       ，          
			while (count == items.length) {
			full.await();
		}
		items[addIndex] = t;
		count++;
		empty.signal();
		}finally {
			lock.unlock();
		}
	}
	//       ，        ，                      
	public T remove(int removeIndex) throws InterruptedException {
		lock.lock();
		try {
			//       ，          
			while (count == 0) {
			empty.await();
			}
			Object x = items[removeIndex];
			count--;
			full.signal();
			return (T) x;
		}finally {
			lock.unlock();
		}
	}
}

public final void await() throws InterruptedException {
	if (Thread.interrupted())
		throw new InterruptedException();
	// 1.        Node，        
	Node node = addConditionWaiter();
	// 2.          lock，                 
	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) // clean up if cancelled
		unlinkCancelledWaiters();
	//       
	if (interruptMode != 0)
		reportInterruptAfterWait(interruptMode);
}

private Node addConditionWaiter() {
	Node t = lastWaiter;
	if (t != null && t.waitStatus != Node.CONDITION) {
		unlinkCancelledWaiters();
		t = lastWaiter;
	}
	//         Node
	Node node = new Node(Thread.currentThread(), Node.CONDITION);
	if (t == null)
		firstWaiter = node;
	else
		//        
		t.nextWaiter = node;
	lastWaiter = node;
	return node;
}

final int fullyRelease(Node node) {
	boolean failed = true;
	try {
		int savedState = getState();
		//   AQS         release()
		if (release(savedState)) {
			//        
			failed = false;
			return savedState;
		} else {
			//             
			throw new IllegalMonitorStateException();
		}
	} finally {
		//                       
		if (failed)
			node.waitStatus = Node.CANCELLED;
	}
}

public final void signal() {
	//           lock
	if (!isHeldExclusively())
		throw new IllegalMonitorStateException();
	//             ，             
	Node first = firstWaiter;
	if (first != null)
		doSignal(first);
}

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

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

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Goods {
	//     
	private String name;
	//       
	private int count;
	//       
	private int maxCount;
	public Goods(int maxCount) {
		this.maxCount = maxCount;
	}
	private Lock lock = new ReentrantLock();
	private Condition consumer = lock.newCondition();
	private Condition producer = lock.newCondition();
	//     
	public void setGoods(String name) {
		lock.lock();
		try {
			//                    
			while (count==maxCount) {
				System.out.println(Thread.currentThread().getName()+"        ，       ");
				producer.await();
			}
			Thread.sleep(200);
			//     
			this.name = name;
			count++;
			System.out.println(Thread.currentThread().getName()+"  "+toString());
			//        
			consumer.signalAll();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	//     
	public void getGoods() {
		lock.lock();
		try {
			//     0        
			while (count == 0) {
			System.out.println(Thread.currentThread().getName()+"       ，       ");
			consumer.await();
			}
			Thread.sleep(200);
			//     
			count--;
			System.out.println(Thread.currentThread().getName()+"  "+toString());
			//        
			producer.signalAll();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	@Override
	public String toString() {
		return "Goods{" +"name='" + name + '\'' +", count=" + count +'}';
	}
}
class Producer implements Runnable {
	private Goods goods;
	public Producer(Goods goods) {
		this.goods = goods;
	}
	@Override
	public void run() {
		while (true) {
			this.goods.setGoods("          ");
		}
	}
}
class Consumer implements Runnable {
	private Goods goods;
	public Consumer(Goods goods) {
		this.goods = goods;
	}
	@Override
	public void run() {
		while (true) {
			this.goods.getGoods();
		}
	}
}
public class Test {
	public static void main(String[] args) {
		List<Thread> list = new ArrayList<>();
		Goods goods = new Goods(10);
		Producer producer = new Producer(goods);
		Consumer consumer = new Consumer(goods);
		//   10      
		for (int i = 0;i < 10;i++) {
			Thread thread = new Thread(consumer,"   "+i);
			list.add(thread);
		}
		//   5      
		for (int i = 0;i < 5;i++) {
			Thread thread = new Thread(producer,"   "+i);
			list.add(thread);
		}
		for (Thread th : list) {
			th.start();
		}
	}
}