import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;

import com.xiaoleilu.hutool.util.StrUtil;

/**
 * 使用 notify() 和 wait() 實現(xiàn)自定義阻塞隊列
 *
 * @author Yangkai.Shen
 * @version 1.0
 * @date 2017.08.02 at 11:51:14
 */
public class MyQueue {

	// 1. 承載數(shù)據(jù)的容器
	private LinkedList<Object> queue = new LinkedList<Object>();

	// 2. 計數(shù)器，用于判定邊界
	private AtomicInteger count = new AtomicInteger(0);
	private final int minSize = 0;

	// 3. 初始化一個對象，用于加鎖
	private final Object lock = new Object();
	private final int maxSize;

	public MyQueue(int maxSize) {
		this.maxSize = maxSize;
	}

	/**
	 * 添加一個元素到隊列中，如果隊列元素已滿，則調(diào)用此方法的線程被阻塞，直到存在多余空間了，再進(jìn)行添加
	 *
	 * @param obj 添加 obj 到隊列尾部
	 */
	public void put(Object obj) {
		synchronized (lock) {
			// 1.沒有多余空間，就阻塞線程
			while (count.get() == this.maxSize) {
				try {
					lock.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			// 2.添加元素
			queue.add(obj);
			// 3.計數(shù)器累加
			count.incrementAndGet();
			System.out.println(StrUtil.format("新加入的元素為：{}", obj));
			// 4.喚醒其他線程（若本來元素為空，有線程調(diào)用 get 方法，那么原本被阻塞的，需要在此時被喚醒）
			lock.notify();
		}
	}

	/**
	 * 獲取一個元素，如果隊列元素為空，則調(diào)用此方法的線程被阻塞，直到添加新元素了，再進(jìn)行獲取
	 *
	 * @return 返回隊列的第一個元素
	 */
	public Object get() {
		Object ret = null;

		synchronized (lock) {
			// 1.沒有元素，就阻塞線程
			while (count.get() == this.minSize) {
				try {
					lock.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			// 2.取第一個元素
			ret = queue.removeFirst();
			// 3.計數(shù)器遞減
			count.decrementAndGet();
			System.out.println(StrUtil.format("移除的元素為：{}", ret));
			// 4.喚醒其他線程（若元素本來已滿，有線程調(diào)用 put 方法，那么原本被阻塞的，需要在此時被喚醒）
			lock.notify();
		}

		return ret;
	}

	public int getSize() {
		return this.count.get();
	}

}

import com.xiaoleilu.hutool.util.StrUtil;

import java.util.concurrent.TimeUnit;

public class MyQueueTest {
	public static void main(String[] args) {
		final MyQueue queue = new MyQueue(5);

		queue.put("a");
		queue.put("b");
		queue.put("c");
		queue.put("d");
		queue.put("e");

		System.out.println(StrUtil.format("當(dāng)前隊列的長度: {}", queue.getSize()));
		Thread t1 = new Thread(() -> {
			queue.put("f");
			queue.put("g");
			queue.put("h");
		}, "t1");
 Thread t2 = new Thread(() -> {
  queue.get();
  queue.get();
 });

 t1.start();
 try {
  TimeUnit.SECONDS.sleep(2);
 } catch (InterruptedException e) {
  e.printStackTrace();
 }
 t2.start();
}