并发编程（四）------并发quene

在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue接口！

ConcurrentLinkedQueue：

　　是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue。它是一个基于链接节点的无界线程安全队列。

　　该队列的元素遵循先进先出的原则，头是最先加入的，尾是最近加入的，该队列不允许null元素。

ConcurrentLinkedQueue重要方法：
add() 和 offer() 都是加入元素的方法 （在ConcurrentLinkedQueue中，这俩个方法没有任何区别）
poll() 和 peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。

BlockingQueue：

BlockingQueue接口的重要方法

offer(anObject): 表示如果可能的话, 将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳, 则返回true, 否则返回false.（本方法不阻塞当前执行方法的线程）

offer(E o, long timeout, TimeUnit unit), 可以设定等待的时间，如果在指定的时间内，还不能往队列中加入BlockingQueue，则返回失败。

put(anObject): 把anObject加到BlockingQueue里, 如果BlockQueue没有空间, 则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续.

poll(long timeout, TimeUnit unit)：从BlockingQueue取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据。否则知道时间超时还没有数据可取，返回失败。

take(): 取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到BlockingQueue有新的数据被加入;

drainTo(): 一次性从BlockingQueue获取所有可用的数据对象（还可以指定获取数据的个数），通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁。

MyQueueTest

package com.bfxy.thread.cord.collection;

public class MyQueueTest {
    
    public static void main(String[] args) throws InterruptedException {
        MyQueue mq = new MyQueue(5);
        mq.put("a");
        mq.put("b");
        mq.put("c");
        mq.put("d");
        mq.put("e");
        
        System.err.println("当前元素的个数"+mq.size());
        
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                mq.put("f");
                mq.put("g");
                
            }
        },"t1");
        
        Thread.sleep(1000);
        
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    Object o1=mq.take();
                    Thread.sleep(1000);
                    Object o2=mq.take();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                    
            }
        },"t2");
        
        t1.start();
        Thread.sleep(1000);
        t2.start();
        Thread.sleep(5000);
        
        System.err.println(mq.getQueueList().toString());
    }
    

}

MyQueue

package com.bfxy.thread.cord.collection;

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

public class MyQueue {
    //1 就是我们整个队列的容器
    private final LinkedList<Object> list =new LinkedList<>();
    
    //2计数器
    private final AtomicInteger count = new AtomicInteger();
    
    private final int maxSize; //最大容量限制
    
    
    private final int minSize = 0;
    
    private final Object lock = new Object(); //锁
    
    public  MyQueue(int maxSize) {
        this.maxSize = maxSize;        
    }
    
    public void put(Object obj) {
        synchronized (lock) {
            while (count.get() ==this.maxSize) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }    
            }
            //添加新的元素进到容器里
            list.add(obj);
            count.getAndIncrement();//i++
            System.err.println("元素"+obj+"已经添加容器中");
            //进行唤醒可能正在等待的take方法操作中的线程
            lock.notify();
            
        }
        
    }
    
    public Object take() {
        Object temp= null;
        synchronized (lock) {
            while (count.get() ==this.minSize) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }    
            }
            temp=list.removeFirst();
            count.getAndDecrement();//i--
            System.err.println("元素"+temp+"已经从容器中取走");
            //进行唤醒可能正在等待的put方法操作中的线程
            lock.notify();
            
        }
        
        return temp;
    }
    
    public int size() {
        return count.get();
    }
    
    public List<Object> getQueueList() {
        return list;
    }
    

}