015.多线程-并发队列

妖狐艹你老母 2021-10-06 15:36 420阅读 0赞

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

--------------------

### ConcurrentLinkedQueue ###

ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列，  
通过无锁的方式，实现了高并发状态下的高性能，  
通常ConcurrentLinkedQueue性能好于BlockingQueue。  
它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。  
头是最先加入的，尾是最近加入的，该队列不允许null元素。

*  add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)
    
        public boolean add(E e) { 
                return offer(e);
            }
 *  poll() 和peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。
    
        package cn.qbz.thread;
        
        import java.util.concurrent.ConcurrentLinkedQueue;
        
        public class Test111904 { 
            public static void main(String[] args) { 
                ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue();
                for (int i = 0; i < 3; i++) { 
                    new ThreadTest111904(queue).start();
                }
        
                while (true) { 
                    if (queue.size() > 0) { 
                        System.out.println(queue.poll());
                    }
                }
            }
        }
        
        class ThreadTest111904 extends Thread { 
        
            private ConcurrentLinkedQueue queue;
        
            public ThreadTest111904(ConcurrentLinkedQueue queue) { 
                this.queue = queue;
            }
        
            @Override
            public void run() { 
                for (int i = 0; i < 3; i++) { 
                    queue.offer(getName() + "..." + i);
                }
            }
        }
    
    ![idea64_2018-11-19_13-41-28.png][]

--------------------

### BlockingQueue ###

在队列为空时，获取元素的线程会等待队列变为非空。  
当队列满时，存储元素的线程会等待队列可用。  
阻塞队列常用于生产者和消费者的场景

#### ArrayBlockingQueue ####

ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。  
有边界的意思是它的容量是有限的，  
我们必须在其初始化的时候指定它的容量大小，  
容量大小一旦指定就不可改变。

package cn.qbz.thread;
    
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.TimeUnit;
    
    public class Test111905 { 
        public static void main(String[] args) throws InterruptedException { 
            BlockingQueue<String> queue = new ArrayBlockingQueue(2);
            queue.add("test1");
            queue.offer("test2");
    
            Boolean isOffer = queue.offer("test3");
            System.out.println("添加test3:"+isOffer);
    
            isOffer = queue.offer("test4", 1, TimeUnit.SECONDS);
            System.out.println("添加test4:"+isOffer);
    
            for (int i = 0; i < 4; i++) { 
                System.out.println(queue.poll());
            }
        }
    }

![idea64_2018-11-19_14-21-03.png][]

**其中，add和offer的区别是：**  
**当超出队列界限时，add会抛出异常，offer只是返回false。**

--------------------

#### LinkedBlockingQueue ####

LinkedBlockingQueue阻塞队列大小的配置是可选的，  
如果我们初始化时指定一个大小，它就是有边界的，  
如果不指定，它就是无边界的。说是无边界，  
其实是采用了默认大小为Integer.MAX\_VALUE的容量 。  
它的内部实现是一个链表。

**code of demo：**

package cn.qbz.thread;
    
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingDeque;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class Test111906 { 
        public static void main(String[] args) throws InterruptedException { 
            BlockingQueue queue = new LinkedBlockingDeque(3);
            Produce111906 p1 = new Produce111906(queue);
            Consumer111906 c1 = new Consumer111906(queue);
            
            Thread produce1 = new Thread(p1);
            Thread produce2 = new Thread(p1);
            Thread consumer1 = new Thread(c1);
    
            produce1.start();
            produce2.start();
            consumer1.start();
    
            Thread.sleep(1000 * 10);
    
            p1.stop();
            c1.stop();
        }
    
    }
    
    class Produce111906 implements Runnable { 
        private BlockingQueue<String> queue;
        private volatile Boolean flag = true;
        private AtomicInteger count = new AtomicInteger();
    
        public Produce111906(BlockingQueue queue) { 
            this.queue = queue;
        }
    
        public void run() { 
            while (flag) { 
                try { 
                    int data = count.incrementAndGet();
                    System.out.println("开始生产数据:" + data);
                    Boolean isOffer = queue.offer(data + "", 2, TimeUnit.SECONDS);
                    if (isOffer) { 
                        System.out.println("写入数据：" + data + "成功");
                    } else { 
                        System.out.println("写入数据：" + data + "失败");
                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } finally { 
                    System.out.println("退出本次生产");
                }
            }
    
        }
    
        public void stop() { 
            flag = false;
        }
    }
    
    class Consumer111906 implements Runnable { 
        private BlockingQueue<String> queue;
        private volatile Boolean flag = true;
    
        public Consumer111906(BlockingQueue queue) { 
            this.queue = queue;
        }
    
        public void run() { 
            while (flag) { 
                System.out.println("开始消费数据");
                try { 
                    String data = queue.poll(2, TimeUnit.SECONDS);
                    if (data != null) { 
                        System.out.println("消费成功：" + data);
                    } else { 
                        System.out.println("消费失败");
                    }
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    
    
        public void stop() { 
            flag = false;
        }
    }

[idea64_2018-11-19_13-41-28.png]: http://upyun.qubianzhong.cn/picture/idea64_2018-11-19_13-41-28.png
[idea64_2018-11-19_14-21-03.png]: http://upyun.qubianzhong.cn/picture/idea64_2018-11-19_14-21-03.png