阻塞队列LinkedBlockingQueue

作者: 激情的狼王 | 来源:发表于2017-09-01 10:57 被阅读0次

    LinkedBlockingQueue应该是比较常用的队列了。

    阻塞队列的基本方法:

    add 增加一个元索如果队列已满,则抛出一个IIIegaISlabEepeplian异常

    remove 移除并返回队列头部的元素如果队列为空,则抛出一个 NoSuchElementException异常

    element返回队列头部的元素如果队列为空,则抛出一个NoSuchElementException异常

    offer添加一个元素并返回true如果队列已满,则返回false

    poll移除并返问队列头部的元素如果队列为空,则返回null

    peek返回队列头部的元素如果队列为空,则返回null

    put添加一个元素如果队列满,则阻塞

    take移除并返回队列头部的元素如果队列为空,则阻塞

    示例:

    package yxxy.queuue;
    
    import java.util.Arrays;
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.TimeUnit;
    
    public class TEST {
        
        public static void main(String[] args) throws Exception {
            
            BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
            
            Thread[] ths = new Thread[6];
            for(int i=0;i<ths.length-1;i++){
                Runnable task = new Runnable() {
                    
                    @Override
                    public void run() {
                        while(true){
                            try {
                                int i = queue.poll(1, TimeUnit.SECONDS);
                            } catch (Exception e) {
                                System.out.println("err");
                                break;
                            }
                        }
                    }
                    
                };
                ths[i] = new Thread(task);
            }
            Runnable task = new Runnable() {
                
                @Override
                public void run() {
                    for(int i=0;i<99999;i++){
                        try {
                            queue.put(i);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                
            };
            ths[5] = new Thread(task);
            long a = System.currentTimeMillis();
            runAndComputeTime(ths);
            long b = System.currentTimeMillis();
            System.out.println(b-a);
        }
        
        
        static void runAndComputeTime(Thread[] ths) {
            Arrays.asList(ths).forEach(t->t.start());
            Arrays.asList(ths).forEach(t->{
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            
        }
    }
    

    相关文章

      网友评论

        本文标题:阻塞队列LinkedBlockingQueue

        本文链接:https://www.haomeiwen.com/subject/gomhjxtx.html