并发编程复习（八）：队列相关

package cn.lh.queue;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.*;

/**
 * @Author Lee_Hoo
 * @DATE Created in 2017/9/22
 * @Description: ConcurrentLinkedQueue是一个适用于高并发场景下的并发队列，非阻塞，通过无锁方式，实现高并发状态下的高性能，通常它
 * 的性能高于BlockingQueue，
 * 它是一个基于链接节点的无界线程安全队列，先进先出。
 * 主要方法：add()和offer()都是加入元素方法，在ConcurrentLinkedQueue中没有区别
 *          poll()和peek()都是去元素，区别是前者会删除元素，后者不会
 *          BlockingQueue:阻塞队列，有五个实现类
 *                ArrayBlockingQueue:内部维护定长数组，没有实现读写分离，生产和消费不能完全并行，可以指定先进先出或者先进后出，
 *          也叫有界队列。
 *                LinkeedBlockingQueue:基于链表的阻塞队列，采用读写分离，从而实现生产和消费完全的并行，是一个无界队列。
 *                SynchronousQueue:没有缓冲的队列，生产出的数据会直接被消费者获得被消费
 */
public class MyQueue {
    public static void main(String[] args) throws InterruptedException {
        //高性能的无界无阻赛队列：ConcurrentLinkedQueue
        Queue q = new ConcurrentLinkedQueue();
        q.add("a");
        q.offer("b");
        q.add("v");
        q.add("d");
        System.out.println(q.peek());
        System.out.println(q.size());
        System.out.println(q.poll());
        System.out.println(q.size());
        //之所以有界，在于构造时就要指定大小
        Queue<Object> q1 = new ArrayBlockingQueue(5);
        //可以有界也可以无界
        //LinkedBlockingQueue<Object> q2 = new LinkedBlockingQueue<>();
        LinkedBlockingQueue<Object> q3 = new LinkedBlockingQueue<>(5);
        q3.offer("a");
        q3.offer("b");
        q3.offer("d");
        q3.offer("c");
        q3.offer("e");
        List<Object> list = new ArrayList<>();
        q3.drainTo(list,3);
        System.out.println(list.size());
        //该队列不能添加元素，立即生产立即处理，没有数据缓存，可以这样来理解：生产者和消费者互相等待对方，握手，然后一起离开。
       /* SynchronousQueue<Object> ss = new SynchronousQueue<>();
        //ss.add("a");//会报错，如果没有线程去take会报错
        try {
            ss.put(true);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        System.out.println("----------------------------");
        //PriorityBlockingQueue:基于优先级的阻塞队列，传入的对象必须实现Comparable接口，内部控制线程同步采用的是公平锁，无界队列
        //比较产生的结果如果是负数，那么他的优先级就高
        PriorityBlockingQueue<Task> pb = new PriorityBlockingQueue<>();
        Task t1 = new Task(1,"张三");
        Task t2 = new Task(3,"李四");
        Task t3 = new Task(2,"王五");
        pb.add(t1);
        pb.add(t2);
        pb.add(t3);
        //排序情况：[Task{id=1, name='张三'}, Task{id=3, name='李四'}, Task{id=2, name='王五'}]
        System.out.println(pb);//其实内部存储最先的情况是无序的,没有进行比较排序
        //System.out.println(pb.take());//只有当调用take方法只会内部才会进行排序
        //System.out.println(pb.remove());//排序
        System.out.println(pb.peek());//不排序
        //[Task{id=2, name='王五'}, Task{id=3, name='李四'}]，进行了比较排序
        System.out.println(pb);
    }
}

Task类：

package cn.lh.queue;

import org.jetbrains.annotations.NotNull;

/**
 * @Author Lee_Hoo
 * @DATE Created in 2017/9/22
 * @Description:
 */
public class Task implements Comparable<Task>{
    private int id;
    private String name;

    public Task(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Task() {
    }

    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(@NotNull Task task) {
        return this.id>task.id?1:(this.id<task.id?-1:0);
    }

    @Override
    public String toString() {
        return "Task{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

网吧场景详解DelayQueue队列：

网吧类：

package cn.lh.queue;

import java.util.concurrent.DelayQueue;

/**
 * @Author Lee_Hoo
 * @DATE Created in 2017/9/22
 * @Description:
 */
public class WangBa implements Runnable
{
    private DelayQueue<WangMing> queue = new DelayQueue<>();
    public boolean yingye = true;

    public void shangji(String name,String id,int money){
        WangMing wm = new WangMing(id,name,1000*money+System.currentTimeMillis());
        System.out.println("网民"+name+"身份证"+id+"交钱"+money+"块"+"开始上机");
        this.queue.add(wm);
    }
    public  void xiaji(WangMing wm){
        System.out.println("网名"+wm.getName()+"身份证"+wm.getId()+"下机");
    }
    @Override
    public void run() {
        try {
            while (yingye){
                WangMing man = queue.take();
                xiaji(man);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try {
            System.out.println("开始营业");
            WangBa wb = new WangBa();
            Thread shangwang = new Thread(wb);
            shangwang.start();
            wb.shangji("张三","123",1);
            wb.shangji("李四","555",10);
            wb.shangji("王五","789",5);

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

网民类：

package cn.lh.queue;

import org.jetbrains.annotations.NotNull;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @Author Lee_Hoo
 * @DATE Created in 2017/9/22
 * @Description:
 */
public class WangMing implements Delayed {

    private String id;
    private String name;
    private long endTime;
    private TimeUnit timeUnit = TimeUnit.SECONDS;

    public WangMing(String id, String name, long endTime) {
        this.id = id;
        this.name = name;
        this.endTime = endTime;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public long getEndTime() {
        return endTime;
    }

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

    @Override
    public long getDelay(@NotNull TimeUnit unit) {
        return endTime-System.currentTimeMillis();
    }

    @Override
    public int compareTo(@NotNull Delayed o) {
        WangMing w = (WangMing) o;
        return this.getDelay(this.timeUnit)-w.getDelay(this.timeUnit)>0?1:0;
    }
}