多线程高并发笔记三

Queue: (数组，链表)  ConcurrentLinkedQueue

import java.util.Queue;
import java.util.concurrent.*;

public class QueueTest {
    private static Queue<String> total = new ConcurrentLinkedQueue<>();//单向队列
    private static Queue<String> total1 = new ConcurrentLinkedDeque<>();//双向队列

    /**
     * 非并发，不加锁：ArrayList，LinkedList
     * 并发小：Collections.synchronizedXXX
     * 读取量特别大，写入量特别少：CopyOnWriteXXXX
     * 高并发用的多的队列
     *  Queue:
     *    ConcurrentLinkedQueue 并发加锁，非阻塞
     *    BlockingQueue: 阻塞队列  put如果满了，新线程进来就会等待; take如果拿了,新线程进来就会等待
     *      LinkedBlockingQueue:无界队列
     *      ArrayBlockingQueue：有界队列；
     *                          如果队列已经满了:
     *                              add : 再加入数据会报异常
     *                              offer : 再加入数据不会报异常，但不会加入(offer还可以设置，如果多少时间内加不进去则不再加入 pp.offer("aaa",1,TimeUnit.SECONDS))
     *                              put : 加不进去，则线程阻塞
     *      DelayQueue:非阻塞，无界队列 可以设置每个存入的数据多少时间后可以取出。每个元素需要实现Delayed类，以及实现相应方法。可以用来做定时执行任务
     *      TransferQueue: 先启动消费者，再赋值
     *        LinkedTransferQueue:
     *      SynchronousQueue : 容量为0的队列，立马交给消费者消费
     */

    static {
        for (int i=0;i<10000;i++) total.add("火车票 编号："+(i+1));
    }

    public static void main(String[] args) throws Exception{
//        for (int i = 0;i<10;i++){
//            new Thread(()->{
//                while (true){
//                    String s = total.poll();
//                    if ( s == null) break;
//                    else System.out.println(s);
//                }
//            }).start();
//        }
        //new QueueTest1().test2();
//        new QueueTest1().test3();
        new QueueTest1().test4();
    }
}

class QueueTest1{
    void test(){
        Queue<String> queue = new ConcurrentLinkedQueue<>();
        queue.offer("hello"); //类似于 add。 但ArrayList 元素最多有个数限制。但offer可以通过返回值判断是否加入，是无界队列，FIFO
        String s1 = queue.peek(); //取出一个数据
        String s2 = queue.poll(); //删除一个数据，并把删除的数据返回
    }

    void test2() throws InterruptedException {
        BlockingQueue queue = new DelayQueue<>();
        TTT t1 = new TTT(1000L);
        TTT t2 = new TTT(2000L);
        TTT t3 = new TTT(3000L);

        queue.put(t3);
        queue.put(t2);
        queue.put(t1);
        System.out.println(queue);
        for (int i = 0;i<3;i++) System.out.println(queue.take());

    }
    class TTT implements Delayed{
        private Long waitTime;

        public TTT(Long waitTime) {
            this.waitTime = waitTime;
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(waitTime - System.currentTimeMillis(),TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            if (this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MILLISECONDS)) return -1;
            else if (this.getDelay(TimeUnit.MILLISECONDS) == o.getDelay(TimeUnit.MILLISECONDS)) return 0;
            else return 0;
        }

        @Override
        public String toString() {
            return "TTT{" +"waitTime=" + waitTime + '}';
        }
    }


    //实时消息处理用的多
    void test3(){
        TransferQueue<String> queue = new LinkedTransferQueue();
        new Thread(() ->{
            try {
                System.out.println(queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        try {
            queue.transfer("123"); //找不到消费者，线程将阻塞在这里
//            queue.add("123"); //不会阻塞
//            queue.put("123");//不会阻塞
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

//        new Thread(() ->{
//            try {
//                System.out.println(queue.take());
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }).start();

    }

    void test4() throws InterruptedException {
        BlockingQueue<String> queue = new SynchronousQueue<>();

        new Thread(()->{
            try {
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        queue.put("aaa");//没有消费者则阻塞
//        queue.add("aaa"); //会报错 java.lang.IllegalStateException: Queue full
        System.out.println(queue.size());
    }

}