Queue队列的简单应用

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

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

//ArrayBlockingQueue阻塞定长序列
ArrayBlockingQueue<String> array = new ArrayBlockingQueue<String>(5);//存放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));//意思是3秒内 能放入返回true,放不进去返回false

结果如下

LinkedBlockingQueue

LinkedBlockingQueue阻塞队列(如果不给初始化限制就是无界限,一直放入元素)

//阻塞队列
        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());

运用drainTo()方法 将容器中部分数据取出变为List也可以是其他容器

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);
        }

SynchronousQueue

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();     

技术选型

就好比一个城市,其中的公路就像是队列,车辆就是服务,
1.早晚高峰高峰时车辆非常的多,公路处理需要更快的处理信息,并且车辆却多,行驶的越慢,所以用ArrayBlockingQueue定长队列.
2.中午的时候车辆不是很多,公路也可以运行,那就选型LinkedBlockingQueue
3.如果是凌晨路上的只是几个,选中SynchronousQueue,模拟虚拟的队列,其实也用不上队列,用任务就执行就Ok了

PriorityBlockingQueue

Task.java

public class Task implements Comparable<Task>{

    private int id ;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Task task) {
        return this.id > task.id ? 1 : (this.id < task.id ? -1 : 0);  
    }

    public String toString(){
        return this.id + "," + this.name;
    }

}

UsePriorityBlockingQueue.java

import java.util.concurrent.PriorityBlockingQueue;

public class UsePriorityBlockingQueue {


    public static void main(String[] args) throws Exception{


        PriorityBlockingQueue<Task> q = new PriorityBlockingQueue<Task>();

        Task t1 = new Task();
        t1.setId(3);
        t1.setName("id为3");
        Task t2 = new Task();
        t2.setId(4);
        t2.setName("id为4");
        Task t3 = new Task();
        t3.setId(1);
        t3.setName("id为1");

        //return this.id > task.id ? 1 : 0;
        q.add(t1);  //3
        q.add(t2);  //4
        q.add(t3);  //1

        // 1 3 4
        System.out.println("容器：" + q);
        System.out.println(q.take().getId());
        System.out.println("容器：" + q);
//      System.out.println(q.take().getId());
//      System.out.println(q.take().getId());



    }
}

DelayQueue

用小孩上网举例子到点了会被拿出来,takei方法是一直阻塞的状态