线程基础7

    //高性能无阻塞无界队列：ConcurrentLinkedQueue
        
ConcurrentLinkedQueue<String> q = new ConcurrentLinkedQueue<String>();
        q.offer("a");
        q.offer("b");
        q.offer("c");
        q.offer("d");
        q.add("e");
        
        System.out.println(q.poll());    //a 从头部取出元素，并从队列里删除
        System.out.println(q.size());    //4
        System.out.println(q.peek());    //b
        System.out.println(q.size());    //4    
性能很高不阻塞，无界

生产者和消费者不能同时进行，这里要注意没有实现读写分离，是有界的阻塞的队列，可以用来实现生产者和消费者模式

我们来看下面的代码：

    ArrayBlockingQueue<String> array = new ArrayBlockingQueue<String>(5);
        array.put("a");
        array.put("b");
        array.add("c");
        array.add("d");
        array.add("e");
        array.add("f");
        System.out.println(array.offer("a", 3, TimeUnit.SECONDS));

程序运行的结果是：

Exception in thread "main" java.lang.IllegalStateException: Queue full
at java.util.AbstractQueue.add(AbstractQueue.java:98)
at java.util.concurrent.ArrayBlockingQueue.add(ArrayBlockingQueue.java:283)
at com.bjsxt.base.coll013.UseQueue.main(UseQueue.java:38)

因为队列的长度就是5，现在已经了满了，使用offer在3秒之内都没有添加成功就抛出异常

想比较上面的arrayBlockingqunue ，它实现了读写分离，生产者和消费者能够同时执行，使用不同的锁。大大提高了并发的效率，并且能够实现数据长度的无效大因为采用

链表的数据结构

 

        //阻塞队列
        LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>();
        q.offer("a");
        q.offer("b");
        q.offer("c");
        q.offer("d");
        q.offer("e");
        q.add("f");
        //System.out.println(q.size());
        
    for (Iterator iterator = q.iterator(); iterator.hasNext();) {
        String string = (String) iterator.next();
        System.out.println(string);
    }

 

程序的运行结果：

a
b
c
d
e
f

千万要注意，如果给

LinkedBlockingQueue添加了数据长度，那么它就不是无界的了，看下面的代码

    //阻塞队列
        LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(5);
        q.offer("a");
        q.offer("b");
        q.offer("c");
        q.offer("d");
        q.offer("e");
        q.add("f");
        //System.out.println(q.size());
        
    for (Iterator iterator = q.iterator(); iterator.hasNext();) {
        String string = (String) iterator.next();
        System.out.println(string);
    }

 

程序的运行效果是：

Exception in thread "main" java.lang.IllegalStateException: Queue full
at java.util.AbstractQueue.add(AbstractQueue.java:98)
at com.bjsxt.base.coll013.UseQueue.main(UseQueue.java:51)

这里千万要小心

 drainTo函数能将队列中的元素提前出来放在list集合中

        //阻塞队列
        LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>();
        q.offer("a");
        q.offer("b");
        q.offer("c");
        q.offer("d");
        q.offer("e");
        q.add("f");
        
        List<String> list = new ArrayList<String>();
        System.out.println(q.drainTo(list, 3));
        System.out.println(list.size());
        for (String string : list) {
            System.out.println(string);
        }

程序的运行效果是：

3
3
a
b
c

 

使用的说明：

首先消费者线程要优先生产者运行，消费者添加的数据立刻被生产者获取并消费

    final SynchronousQueue<String> q = new SynchronousQueue<String>();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(q.take());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                q.add("asdasd");
            }
        });
        t2.start();    

 生产者产生的任务是直接将任务直接给消费者使用，add方法不是向队列里面添加元素，而是将元素直接给消费者使用，所以

使用add方法必须要先存在消费者调用take方法，否则会抛出异常