BlockingQueue之常用类型Demo

BlockingQueue之常用类型Demo

七大类型的Demo用法

是我自己在学习的时候写的笔记，仅供参考。

代码如下：

package com.lly.test;

import org.junit.jupiter.api.Test;
import java.util.concurrent.*;

public class BlockingQueueDemo {

    @Test
    public void test_ArrayBlockingQueue() {
        // 由数组结构组成的有界阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(2);
        blockingQueue.add("11");
        blockingQueue.add("22");
        System.out.println("begin\t"+blockingQueue.toString());
        System.out.println(blockingQueue.remove());
        System.out.println("end\t"+blockingQueue.toString());
        System.out.println(blockingQueue.remove("11"));
        System.out.println(blockingQueue.element());
    }

    @Test
    public void test_LinkedBlockingQueue() {
        // 由链表结构组成的有界(大小默认为Integer.MAX_VALUE)阻塞队列
        BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(2);
        blockingQueue.offer("11");
//        System.out.println(blockingQueue.offer("22"));
//        blockingQueue.poll();
//        System.out.println(blockingQueue.toString());
//        blockingQueue.poll();
        System.out.println(blockingQueue.peek());
    }

    @Test
    public void test_SynchronousQueue() {
        // 不存储元素的阻塞队列，也即单个元素的队列
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName());
                blockingQueue.put("11");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName()+"\t"+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "B").start();
    }

    static class User implements Comparable<User> {
        String name;
        int age;

        public User(int age, String name) {
            this.age = age;
            this.name = name;
        }

        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public int compareTo(User o) {
            if (this.age > o.getAge()) {
                return 1;
            } else if (this.age < o.getAge()) {
                return -1;
            } else {
                return 0;
            }
        }

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

    @Test
    public void test_PriorityBlockingQueue() {
        // 支持优先级排序的无界阻塞队列
        PriorityBlockingQueue<User> blockingQueue = new PriorityBlockingQueue<>();
        blockingQueue.put(new User(20, "BB"));
        blockingQueue.put(new User(17, "CC"));
        blockingQueue.put(new User(25, "AA"));
        // 输出结果：[User{name='CC', age=17}, User{name='BB', age=20}, User{name='AA', age=25}]
        System.out.println(blockingQueue.toString());
    }

    @Test
    public void test_LinkedTransferQueue() {
        // 由链表结构组成的无界阻塞队列
        LinkedTransferQueue<String> linkedTransferQueue = new LinkedTransferQueue();

        Thread t2 = new Thread(() -> {
            try {
                System.out.println(linkedTransferQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2");
        t2.start();

        Thread t1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(linkedTransferQueue.tryTransfer("aa"));
        },"t1");
        t1.start();

//        Thread t1 = new Thread(() -> {
//            try {
//                System.out.println(linkedTransferQueue.tryTransfer("aa",5,TimeUnit.SECONDS));
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        },"t1");
//        t1.start();
//
//        Thread t2 = new Thread(() -> {
//            try {
//                System.out.println(linkedTransferQueue.take());
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        },"t2");
//        t2.start();
    }

    @Test
    public void test_LinkedBlockingDeque() {
        // 由链表结构组成的双向阻塞队列
        LinkedBlockingDeque<String> blockingDeque = new LinkedBlockingDeque();
        blockingDeque.offer("11");
        blockingDeque.offer("22");
        System.out.println(blockingDeque.toString());
//
//        System.out.println(blockingDeque.getLast());
//        System.out.println();
//
//        System.out.println(blockingDeque.poll());
//
//        System.out.println();
//        System.out.println(blockingDeque.toString());
        blockingDeque.addLast("33");
        blockingDeque.addFirst("00");
        System.out.println(blockingDeque.toString());
        blockingDeque.removeLast();
        System.out.println(blockingDeque.toString());
    }

    static class DelayedElement implements Delayed {

        private final long delay; //这个就是等待时间 延迟时间
        private final long expire;  // 到期时间
        private final String msg;   //数据
        private final long now; // 创建时间

        public DelayedElement(long delay, String msg) {
            this.delay = delay;
            this.msg = msg;
            expire = System.currentTimeMillis() + delay;    //到期时间 = 当前时间+延迟时间
            now = System.currentTimeMillis();
        }

        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder("DelayedElement{");
            sb.append("delay=").append(delay);
            sb.append(", expire=").append(expire);
            sb.append(", msg='").append(msg).append('\'');
            sb.append(", now=").append(now);
            sb.append('}');
            return sb.toString();
        }

        /**
         * 需要实现的接口，获得延迟时间   用过期时间-当前时间
         * @param unit
         * @return
         */
        @Override
        public long getDelay(TimeUnit unit) {
//            System.out.println(System.currentTimeMillis());
            return unit.convert(this.expire - System.currentTimeMillis() , TimeUnit.MILLISECONDS);
        }

        /**
         * 用于延迟队列内部比较排序   当前时间的延迟时间 - 比较对象的延迟时间
         * @param o
         * @return
         */
        @Override
        public int compareTo(Delayed o) {
            return (int) (this.getDelay(TimeUnit.MILLISECONDS) -o.getDelay(TimeUnit.MILLISECONDS));
        }
    }

    @Test
    public void test_DelayQueue() throws InterruptedException {
        // 使用优先级队列实现的延迟无界阻塞队列
        DelayQueue<DelayedElement> delayQueue = new DelayQueue<>();
//        delayQueue.offer(new DelayedElement(5000, "11"));
//        delayQueue.offer(new DelayedElement(3000, "22"));
        delayQueue.offer(new DelayedElement(3000, "33"));
//        delayQueue.offer(new DelayedElement(10000, "00"));

        TimeUnit.SECONDS.sleep(2);
        System.out.println(delayQueue.toString());
//        System.out.println(delayQueue.poll());
        System.out.println(delayQueue.take());

    }

}