基于ReentrantLock 队列笔记

package org.vic.queue.core;

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 
 * @author Vic Chu
 *
 * @param <T>
 */
public class Queue<T> {
	public Queue(int size){
		this.size = size;
	}
	private int size = 10;
	private final ReentrantLock lock = new ReentrantLock();
	private final Condition notEmpty = lock.newCondition();  //非空
	private final Condition notFull = lock.newCondition();	 //非满
	private Long take_waittingMillis = 0L;
	private Long put_warttingMillis = 0L;
	
	private LinkedList<T> queue = new LinkedList<T>();
	
	public void put(T t) throws InterruptedException{
		lock.lock();
		try{
		if(queue.size()>=size){
			//不能放入，线程阻塞
			System.out.println("当前队列 已满，无法加入新的数据。");
			notFull.await(); //非满状态 线程阻塞（已经满了）
		}else{
			//放入
			notEmpty.signal(); //非空状态 线程阻塞（没有放满）
			System.out.println("队列处于非满状态，可以放入数据");
			Thread.sleep(this.put_warttingMillis);
			queue.add(t);
			System.out.println("数据成功被放入队列中...");
		}
		}finally{
			lock.unlock();
		}
	}
	
    public T take() throws InterruptedException{
    	lock.lock();
    	try{
	    	if(queue.size()==0){
	    		//线程阻塞
	    		System.out.println("队列中无数据...");
	    		notEmpty.await();
	    		return null;
	    	}else{
	    		//唤醒线程
	    		notFull.signal();
	    		Thread.sleep(this.take_waittingMillis);
	    		T t = queue.getFirst();
	    		queue.removeFirst();
	    		System.out.println("线程唤醒，成功获取到数据");
	    		return t;
	    	}
    	}finally{
    		lock.unlock();
    	}
    }
    
    public int queueLength(){
    	return queue.size();
    }
    
    public void take_waittingMills(Long val){
    	this.take_waittingMillis = val;
    }
    
    public void put_waittingMills(Long val){
    	this.put_warttingMillis = val;
    }
    
    
}