package com.lzq.newInterview;

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

public class MyLinkedBlockingQueue<E> {

    private Node<E> head;// 队头
    private Node<E> tail;// 队尾

    private static final int DEFALT_SIZE = 20;
    private int size;// 队列最大长度

    private int count;// 队列当前容量

    private ReentrantLock lock = new ReentrantLock();
    private Condition empty = lock.newCondition();
    private Condition full = lock.newCondition();

    public MyLinkedBlockingQueue() {
        head = null;
        tail = null;
        size = DEFALT_SIZE;
    }

    public MyLinkedBlockingQueue(int size) {
        head = null;
        tail = null;
        this.size = size;
    }

    // 队列尾部插入元素
    public void offer(E e) {
        if (e == null)
            return;
        try {
            lock.lock();
            while (count == size) {
                full.await();
            }
            if (head == null && tail == null) {
                Node<E> node = new Node<E>(e, null);
                head = node;
                tail = node;
            } else {
                Node<E> node = new Node<E>(e, null);
                tail.next = node;
                tail = node;
            }
            count++;
            System.out.println("offer: count=" + this.count);
            empty.signal();
        } catch (Exception exp) {
            exp.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public E poll() {
        try {
            lock.lock();
            while (count == 0) {
                empty.await();
            }
            E oldValue = head.value;
            head = head.next;
            if (head == null)
                tail = null;
            count--;
            System.out.println("poll: count=" + this.count);
            full.signal();
            return oldValue;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return null;
    }

    static class Node<E> {
        Node<E> next;
        E value;

        Node(E value, Node<E> next) {
            this.value = value;
            this.next = next;
        }
    }

    public static void main(String[] args) {
        final MyLinkedBlockingQueue<Integer> queue = new MyLinkedBlockingQueue<Integer>();
        for (int i = 0; i < 100; i++) {
            final int num = i;
            Thread t = new Thread(new Runnable() {
                public void run() {
                    queue.offer(num);
                }
            });
            t.start();
        }
        for (int i = 0; i < 100; i++) {
            Thread t = new Thread(new Runnable() {
                public void run() {
                    queue.poll();
                }
            });
            t.start();
        }
    }
}