java queue

并发Queue 

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

　　　　　　　　　　　　　　　　　　　　　　

ConcurrentLinkedQueue,适合高并发场景下的队列,通过无锁的方式实现了高并发状态下的高性能.它是基于链接节点的无界线程安全队列.该队列的元素遵循先进先出的原则,头是最先加入的,尾是最后加入的,改队列不允许有null元素.

　　ConcurrentLinkedQueue两个重要的方法

　　　　add()和offer()都是加入元素的方法(在ConcurrentLinkedQueue中这两个方法没有任何区别);

　　　　poll()和peek()都是去头元素的节点,区别在与前者会删除元素,后者不会.

BlockingQueue接口

　　ArrayBlockingQueue : 基于数组的阻塞队列的实现,它是有界的.

　　LinkedBlockingQueue :　基于列表的阻塞队列，它是一个无界队列．

public static void main(String[] args) {
        /*ArrayBlockingQueue<String> arrayBlock = new ArrayBlockingQueue<>(5);
        arrayBlock.add("a");
        arrayBlock.add("b");
        arrayBlock.add("c");
        arrayBlock.add("d");
        arrayBlock.add("e");
        System.out.println(arrayBlock.offer("f", 2, TimeUnit.SECONDS));
        */
        
        //阻塞队列
        LinkedBlockingDeque<String> q = new LinkedBlockingDeque<>();
        q.add("a");
        q.add("b");
        q.add("c");
        q.add("d");
        q.add("e");
        
        System.out.println(q.size());
        
        for (Iterator iterator = q.iterator(); iterator.hasNext();) {
            String string = (String) iterator.next();
            System.out.println(string);
        }
        
        List<String> list = new ArrayList<>();
        System.out.println(q.drainTo(list, 3));   //将队列中的元素copy到list集合中
        System.out.println(list.size());
        for (String string : list) {
            System.out.println(string);
        }
        
        SynchronousQueue<String> syn = new SynchronousQueue<>();
        syn.add("asda");  //加元素会报错
    }

 

　　SynchronousQueue　：　是一种没有缓存的队列，生产者生产的数据直接会被消费者获取并消费．

    //这里的Synchronousqueue 是没有容器大小的 这里add不是向容器添加元素而是将元素扔给另一个线程task用来取
        final SynchronousQueue<String> sync = new SynchronousQueue<>();
        Thread t1 = new Thread(new Runnable() {
            
            public void run() {
                try {
                    System.out.println(sync.take());
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                sync.add("wqeqe");    
            }
        });
        t2.start();
        

 

PriorityBlockingQueue : 基于优先级的阻塞队列(优先级的判断通过构造函数传入的Cpmpator对象来决定的,也就是传入的对象必须实现Comparable接口)内部控制线程同步的锁采用的公平锁,是一个无界的队列.

　　

public class Task implements Comparable<Task> {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer 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 static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Task> p = new PriorityBlockingQueue<Task>();
        
        Task task1 = new Task();
        task1.setId(1);
        task1.setName("任务一");
        
        Task task2 = new Task();
        task2.setId(3);
        task2.setName("任务二");
        
        Task task3 = new Task();
        task3.setId(5);
        task3.setName("任务三");
        
        p.add(task1);
        p.add(task2);
        p.add(task3);
        
        /*for (Iterator iterator = p.iterator(); iterator.hasNext();) {
            Task task = (Task) iterator.next();
            System.out.println(task.getName());
        }*/
        //优先级队列不是  比较排序的(添加元素的时候是不会排序的)  而是取task的时候进行排序(这里是个坑)
        System.out.println(p.take().getId());
        System.out.println(p.take().getId());
    }

 

DelayQueue : 带有延迟时间的Queue 其中的元素只有当其指定的延迟时间到了,才能够从队列中获取到该元素,DelayQueue中的元素必须实现delayed接口,Delayedqueue 是一个大小没有限制队列,应用场景比较多,比如对缓存超时的数据进行移除,任务超时进行处理,空闲连接的关闭等等.

eg:

public class Wangmin implements Delayed {
    
    
    private String name;
    
    //生分证
    private String id;
    
    //截止时间
    private long endTime;
    
    //定义时间工具类
    private TimeUnit timeUnit = TimeUnit.SECONDS;
    
    public long getEndTime() {
        return endTime;
    }

    public void setEndTime(long endTime) {
        this.endTime = endTime;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
    
    public Wangmin(String name,String id,long endTime){
        this.name = name;
        this.id = id;
        this.endTime = endTime;
    }
    //用来判断是否到了截止时间
    public int compareTo(Delayed delayed) {
        Wangmin wangmin = (Wangmin)delayed;
        return this.getDelay(this.timeUnit) - wangmin.getDelay(this.timeUnit) > 0 ? 1 : 0;
    }
    //相互比较排序用
    public long getDelay(TimeUnit unit) {
        return  (endTime - System.currentTimeMillis());
    }

}

public class DelayedQueueDemo implements Runnable{
    
    private DelayQueue<Wangmin> delayQueue = new DelayQueue<>();
    
    public boolean yinye = true;
    
    public void shangJi(String name , String id , int money){
        Wangmin wangming = new Wangmin(name, id, 1000*money + System.currentTimeMillis());
        System.out.println("网名"+wangming.getName()+"身份证"+wangming.getId()+"交钱"+money+"快,开始上网!");
        this.delayQueue.add(wangming);
    }
    
    public void xiaJi(Wangmin wangMing){
        System.out.println("网名"+wangMing.getName()+"身份证"+wangMing.getId()+"时间到下机");
    }
    

    @Override
    public void run() {
        while(yinye){
            try {
                Wangmin take = delayQueue.take();
                xiaJi(take);
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }
    public static void main(String[] args) {
        try {
            
            System.out.println("网吧开始营业");
            DelayedQueueDemo wangba = new DelayedQueueDemo();
            Thread thread = new Thread(wangba);
            thread.start();
            
            wangba.shangJi("路人甲", "1", 1);
            wangba.shangJi("路人乙", "2", 3);
            wangba.shangJi("路人丙", "3", 6);
            
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}