package conditions;

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

public class ThreadTest2 {
	
	public static void main(String[] args) {
		final Business business = new Business();
		//子线程
		new Thread(new Runnable() {
			@Override
			public void run() {
				threadExecute(business, "sub");
			}
		}).start();
		//主线程
		threadExecute(business, "main");
	}

	public static void threadExecute(Business business, String threadType) {
		for (int i = 0; i < 5; i++) {
			try {
				if ("main".equals(threadType)) {
					business.main(i);
				} else {
					business.sub(i);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class Business {
	private boolean bool = true;
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();

	public void main(int loop) throws InterruptedException {
		lock.lock();
		try {
			while (bool) {
				condition.await();// this.wait();
			}
			for (int i = 0; i < 3; i++) {
				System.out.println("main thread seq of " + i + ", loop of " + loop);
			}
			bool = true;
			condition.signal();// this.notify();
		} finally {
			lock.unlock();
		}
	}

	public void sub(int loop) throws InterruptedException {
		lock.lock();
		try {
			while (!bool) {
				condition.await();// this.wait();
			}
			for (int i = 0; i < 3; i++) {
				System.out.println("-- sub thread seq of " + i + ", loop of " + loop);
			}
			bool = false;
			condition.signal();// this.notify();
		} finally {
			lock.unlock();
		}
	}
}

package conditions;

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

class BoundedBuffer {
	final Lock lock = new ReentrantLock();// 锁对象
	final Condition notFull = lock.newCondition();// 写线程条件
	final Condition notEmpty = lock.newCondition();// 读线程条件

	final Object[] items = new Object[100];// 缓存队列
	int putptr/* 写索引 */, takeptr/* 读索引 */, count/* 队列中存在的数据个数 */;

	public void put(Object x) throws InterruptedException {
		lock.lock();
		try {
			while (count == items.length){
				// 如果队列满了
				notFull.await();// 阻塞写线程
			}
			items[putptr] = x;// 赋值
			if (++putptr == items.length){
				putptr = 0;// 如果写索引写到队列的最后一个位置了，那么置为0
			}
			++count;// 个数++
			notEmpty.signal();// 唤醒读线程
		} finally {
			lock.unlock();
		}
	}

	public Object take() throws InterruptedException {
		lock.lock();
		try {
			while (count == 0){
				// 如果队列为空
				notEmpty.await();// 阻塞读线程
			}
			Object x = items[takeptr];// 取值
			if (++takeptr == items.length){
				takeptr = 0;// 如果读索引读到队列的最后一个位置了，那么置为0
			}
			--count;// 个数--
			notFull.signal();// 唤醒写线程
			return x;
		} finally {
			lock.unlock();
		}
	}
}

package conditions;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
		public static void main(String[] args) {
			final ReentrantLock reentrantLock =new ReentrantLock();
			final Condition condition=reentrantLock.newCondition();
			
			Thread thread1 = new Thread(new Runnable() {
				@Override
				public void run() {
					try {
						reentrantLock.lock();
						System.out.println("我要等一个新信号！"+this);
						condition.await();
					} catch (Exception e) {
						e.printStackTrace();
					}
					System.out.println("拿到一个信号！"+this);
					reentrantLock.unlock();
				}
			});
			
			thread1.start();
			
			Thread thread2 = new Thread(new Runnable() {
				@Override
				public void run() {
					reentrantLock.lock();
					System.out.println("我拿到锁！"+this);
					try {
						 Thread.sleep(3000);
					} catch (Exception e) {
						e.printStackTrace();
					}
					condition.signalAll();
					System.out.println("我发一个信号！"+this);
					reentrantLock.unlock();
					System.out.println(" ------------- thread 2 unlock 结束");
				}
			});
			thread2.start();
		}
}

/**
 * Returns a {@link Condition} instance for use with this
 * {@link Lock} instance.
 *
 * <p>The returned {@link Condition} instance supports the same
 * usages as do the {@link Object} monitor methods ({@link
 * Object#wait() wait}, {@link Object#notify notify}, and {@link
 * Object#notifyAll notifyAll}) when used with the built-in
 * monitor lock.
 *
 * <ul>
 *
 * <li>If this lock is not held when any of the {@link Condition}
 * {@linkplain Condition#await() waiting} or {@linkplain
 * Condition#signal signalling} methods are called, then an {@link
 * IllegalMonitorStateException} is thrown.
 *
 * <li>When the condition {@linkplain Condition#await() waiting}
 * methods are called the lock is released and, before they
 * return, the lock is reacquired and the lock hold count restored
 * to what it was when the method was called.
 *
 * <li>If a thread is {@linkplain Thread#interrupt interrupted}
 * while waiting then the wait will terminate, an {@link
 * InterruptedException} will be thrown, and the thread's
 * interrupted status will be cleared.
 *
 * <li> Waiting threads are signalled in FIFO order.
 *
 * <li>The ordering of lock reacquisition for threads returning
 * from waiting methods is the same as for threads initially
 * acquiring the lock, which is in the default case not specified,
 * but for <em>fair</em> locks favors those threads that have been
 * waiting the longest.
 *
 * </ul>
 *
 * @return the Condition object
 */
public Condition newCondition() {
    return sync.newCondition();
}

     /**
      * Implements interruptible condition wait.
      * <ol>
      * <li> If current thread is interrupted, throw InterruptedException.
      * <li> Save lock state returned by {@link #getState}.
      * <li> Invoke {@link #release} with
      *      saved state as argument, throwing
      *      IllegalMonitorStateException if it fails.
      * <li> Block until signalled or interrupted.
      * <li> Reacquire by invoking specialized version of
      *      {@link #acquire} with saved state as argument.
      * <li> If interrupted while blocked in step 4, throw InterruptedException.
      * </ol>
      */
     public final void await() throws InterruptedException {
         if (Thread.interrupted())
             throw new InterruptedException();
// 1
         Node node = addConditionWaiter();
// 2
         int savedState = fullyRelease(node);
         int interruptMode = 0;
// 3
         while (!isOnSyncQueue(node)) {
             LockSupport.park(this);
             if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                 break;
         }
// 4
         if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
             interruptMode = REINTERRUPT;
         if (node.nextWaiter != null) // clean up if cancelled
             unlinkCancelledWaiters();
         if (interruptMode != 0)
             reportInterruptAfterWait(interruptMode);
     }

/**
 * Adds a new waiter to wait queue.
 * @return its new wait node
 */
private Node addConditionWaiter() {
    Node t = lastWaiter;
    // If lastWaiter is cancelled, clean out.
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

/**
 * Invokes release with current state value; returns saved state.
 * Cancels node and throws exception on failure.
 * @param node the condition node for this wait
 * @return previous sync state
 */
final int fullyRelease(Node node) {
    boolean failed = true;
    try {
        int savedState = getState();
        if (release(savedState)) {
            failed = false;
            return savedState;
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}

/**
 * Returns true if a node, always one that was initially placed on
 * a condition queue, is now waiting to reacquire on sync queue.
 * @param node the node
 * @return true if is reacquiring
 */
final boolean isOnSyncQueue(Node node) {
    if (node.waitStatus == Node.CONDITION || node.prev == null)
        return false;
    if (node.next != null) // If has successor, it must be on queue
        return true;
    /*
     * node.prev can be non-null, but not yet on queue because
     * the CAS to place it on queue can fail. So we have to
     * traverse from tail to make sure it actually made it.  It
     * will always be near the tail in calls to this method, and
     * unless the CAS failed (which is unlikely), it will be
     * there, so we hardly ever traverse much.
     */
    return findNodeFromTail(node);
}

/**
 * Returns true if node is on sync queue by searching backwards from tail.
 * Called only when needed by isOnSyncQueue.
 * @return true if present
 */
private boolean findNodeFromTail(Node node) {
    Node t = tail;
    for (;;) {
        if (t == node)
            return true;
        if (t == null)
            return false;
        t = t.prev;
    }
}

/*
 * Various flavors of acquire, varying in exclusive/shared and
 * control modes.  Each is mostly the same, but annoyingly
 * different.  Only a little bit of factoring is possible due to
 * interactions of exception mechanics (including ensuring that we
 * cancel if tryAcquire throws exception) and other control, at
 * least not without hurting performance too much.
 */

/**
 * Acquires in exclusive uninterruptible mode for thread already in
 * queue. Used by condition wait methods as well as acquire.
 *
 * @param node the node
 * @param arg the acquire argument
 * @return {@code true} if interrupted while waiting
 */
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

/**
* Moves the longest-waiting thread, if one exists, from the
* wait queue for this condition to the wait queue for the
* owning lock.
*
* @throws IllegalMonitorStateException if {@link #isHeldExclusively}
*         returns {@code false}
*/
public final void signal() {
	if (!isHeldExclusively())
		throw new IllegalMonitorStateException();
	// 1
	Node first = firstWaiter;
	if (first != null)
		doSignal(first);
}

/**
       * Removes and transfers nodes until hit non-cancelled one or
       * null. Split out from signal in part to encourage compilers
       * to inline the case of no waiters.
       * @param first (non-null) the first node on condition queue
       */
      private void doSignal(Node first) {
          do {
              if ( (firstWaiter = first.nextWaiter) == null)
                  lastWaiter = null;
              first.nextWaiter = null;
          } while (!transferForSignal(first) &&
                   (first = firstWaiter) != null);
      }

  /**
   * Transfers a node from a condition queue onto sync queue.
   * Returns true if successful.
   * @param node the node
   * @return true if successfully transferred (else the node was
   * cancelled before signal).
   */
  final boolean transferForSignal(Node node) {
      /*
       * If cannot change waitStatus, the node has been cancelled.
       */
      if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
          return false;

      /*
       * Splice onto queue and try to set waitStatus of predecessor to
       * indicate that thread is (probably) waiting. If cancelled or
       * attempt to set waitStatus fails, wake up to resync (in which
       * case the waitStatus can be transiently and harmlessly wrong).
       */
      Node p = enq(node);
      int ws = p.waitStatus;
// 1
      if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
          LockSupport.unpark(node.thread);
      return true;
  }