Java多线程 3.线程协作

1.Java多线程-认识Java线程

2.Java多线程-线程安全

3.Java多线程-线程协作

4.Java多线程-线程池

5.Java多线程-栅栏

6.Java多线程-Fork/Join

 

---

 

3.1 线程协作和线程安全关系

线程协作指不同线程驱动的任务相互依赖，依赖一般就是对共享资源的依赖；

有线程协作一定会有资源共享，有共享就有竞争，有竞争就会有线程安全问题；

线程安全是通过synchronized和Lock机制来保证线程安全；

线程协作通过Object的wait/notify方法，Thread的join/sleep/interrupt/yield，拥塞队列来实现；

线程安全和线程协作编码时可以互不依赖，但是更通用的场景是线程协作要添加线程安全的机制；

3.2 常见线程协作实现

　　典型的问题就是生产者-消费者问题，生产者和消费者不停地去更新（存/取）商品，商品就是依赖关系的纽带，商品也是生产者线程和消费者线程共享的资源；

　　以生产者-消费者为例，介绍线程协作的几种实现方式：生产者Producer、消费者Consumer、商品Commodity

　　>商品类

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 商品类
 */
public class Commodity {
    private String name;
    private Date productTime;

    public Commodity() {
    }

    public Commodity(String name, Date productTime) {
        this.name = name;
        this.productTime = productTime;
    }

    public String getName() {
        return name;
    }

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

    public Date getProductTime() {
        return productTime;
    }

    public void setProductTime(Date productTime) {
        this.productTime = productTime;
    }

    @Override
    public String toString() {
        return "商品：{名称：" + name + ", 生产日期：" + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.getProductTime
                ())) + "}";
    }
}

3.2.1 Thread的join/yield/sleep

join：线程联合

join为Thread的实例方法，用于线程联合，在线程thread1中调用线程thread2.join()方法，thread1会让出CPU使用进入阻塞直到thread2线程执行结束；如果调用thread2.join指定时间参数，则表示thread1的最多等待时间；

　　说明：如果join和synchronized同时使用时需要注意，线程thread1中调用thread2.join方法，thread1只让出CPU使用但不释放锁，这很容易死锁；

　　yield：线程切换

yield为Thread静态方法，线程放弃继续执行，让出cpu释放锁进入可运行状态

说明：执行yield只是让线程暂停一下，让系统重新调度，大多数情况，yield后系统会继续选择当前线程执行（所以不好验证）

sleep：线程休眠

sleep为Thread的类方法，让当前线程让出CPU使用并休眠参数指定的时间

说明：类似join方法，线程休眠期间只会让出cpu使用不会释放任何锁

sleep实现生产者消费者问题

>线程驱动生产者消费者类

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 生产者和消费者2个线程同时访问仓库这个共享资源
 * 没有添加线程安全保证，存在线程安全问题
 */
public class K1ThreadSleep {
    //仓库大小
    private static int REPO_SIZE = 10;
    //仓库
    private static List<Commodity> repo = new ArrayList(REPO_SIZE);

    public static void main(String[] args) throws Exception {
        new Thread(new Producer(repo, REPO_SIZE)).start();
        new Thread(new Consumer(repo)).start();
    }
}

/**
 * 生产者
 */
class Producer implements Runnable {
    //仓库
    private List<Commodity> repo;
    private int repoSize;

    public Producer(List<Commodity> repo, int repoSize) {
        this.repo = repo;
        this.repoSize = repoSize;
    }

    @Override
    public void run() {
        //机器一直运行着
        while (true) {
            try {
                if (repoSize == repo.size()) {
                    //如果仓库满了，机器休息5秒
                    TimeUnit.SECONDS.sleep(5);
                } else {
                    //仓库没有满，机器1秒钟生产一个产品
                    TimeUnit.SECONDS.sleep(1);
                    Commodity commodity = new Commodity("", new Date());
                    repo.add(commodity);
                    System.out.println("生产商品：" + commodity.toString());
                }
            } catch (InterruptedException e) {
                System.out.println("中断...");
            }
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable {
    //仓库
    private List<Commodity> repo;

    public Consumer(List<Commodity> repo) {
        this.repo = repo;
    }

    @Override
    public void run() {
        while (true) {
            try {
                //如果仓库空了，则饿1秒钟
                if (0 == repo.size()) {
                    TimeUnit.SECONDS.sleep(1);
                } else {
                    //如果仓库中有商品，则5秒钟用完一个
                    TimeUnit.SECONDS.sleep(5);
                    System.out.println("消费商品：" + repo.remove(0).toString());
                }
            } catch (InterruptedException e) {
                System.out.println("中断...");
            }
        }
    }
}

>运行结果：开始生产很快，运行一段时间后 每消费一个商品就生产一个

>为什么：为什么没有添加线程安全？  因为sleep不释放锁

3.2.2 Object的wait/notify

wait和notify是Object的实例方法，和线程安全、线程协作都有关系,线程安全指wait和notify方法只能在synchronized临界区内调用，线程协作指wait使当前线程释放cpu和锁进入等待阻塞，notify/notifyAll唤醒因调用当前对象wait方法进入等待阻塞的线程;

说明：

　　1. wait可以设置超时等待时间，超时后自己进入同步阻塞状态，无需其他线程唤醒

　　2. notify/notifyAll唤醒当前对象上的等待线程，使等待线程进入同步阻塞状态,同步阻塞状态的线程均等机会获取锁（恰恰说明synchronized的锁是非公平锁），notify()是随机唤醒单个线程，而notifyAll()是唤醒所有的线程。

　　3. wait和notify只能在synchronized临界区内调用，并且调用对象只能是进入synchronized临界区的锁的归属对象，否则IllegalMonitorStateException

　　　　出错场景1:synchronized(XX.class){wait()} -->> 获得类锁没有取得对象锁

　　　　出错场景2:synchronized(a){wait()} -->> 获得的是a对象的锁，而不是当前对象this的锁

　　　　出错场景3:synchronized(this){a.wait()} -->> 获得的当前对象的锁，而不是a对象的锁

　　4.sleep和wait的异同：

　　　　sleep()不释放，wait()释放锁；

　　　　都可以响应interrupt()中断，从而使线程立刻抛出InterruptedException（但不建议使用该方法）

>线程驱动生产者消费者类

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * Created by 巩聪 on 2018/7/11.
 */
public class K2ObjectWait {
    //仓库大小
    private static int REPO_SIZE = 5;
    //仓库
    private static List<Commodity> repo = new ArrayList(REPO_SIZE);
    //synchronized锁归属对象
    private static Object synLock = new Object();

    public static void main(String[] args) throws Exception {
        new Thread(new K2Producer(repo, REPO_SIZE, synLock)).start();
        new Thread(new K2Consumer(repo, synLock)).start();
    }
}

/**
 * 生产者
 */
class K2Producer implements Runnable {
    //仓库
    private List<Commodity> repo;
    private int repoSize;
    private Object synLock;

    public K2Producer(List<Commodity> repo, int repoSize, Object synLock) {
        this.repo = repo;
        this.repoSize = repoSize;
        this.synLock = synLock;
    }

    @Override
    public void run() {
        //机器一直运行着
        while (true) {
            //机器1秒钟生产一个产品，生产后尝试存储到仓库
            long start = System.currentTimeMillis();
            while (System.currentTimeMillis() - start < 1000) {
            }
            Commodity commodity = new Commodity("", new Date());
            try {
                synchronized (synLock) {
                    //如果仓库满了进入等待阻塞,等待消费者线程唤醒，唤醒后继续执行
                    if (repoSize == repo.size()) {
                        synLock.wait();
                    }
                    //仓库有位置，将商品存入仓库
                    repo.add(commodity);
                    System.out.println("生产商品：" + commodity.toString());
                    //如果消费者因等待商品进入等待阻塞，唤醒消费者，仓库有商品了
                    synLock.notify();
                }
            } catch (InterruptedException e) {
                System.out.println("中断...");
            }

        }
    }
}

/**
 * 消费者
 */
class K2Consumer implements Runnable {
    //仓库
    private List<Commodity> repo;
    private Object synLock;

    public K2Consumer(List<Commodity> repo, Object synLock) {
        this.repo = repo;
        this.synLock = synLock;
    }

    @Override
    public void run() {
        while (true) {
            try {
                synchronized (synLock) {
                    //如果仓库空了，进入等待阻塞，等待生产线程唤醒，唤醒后继续执行
                    if (0 == repo.size()) {
                        synLock.wait();
                    }
                    //在仓库取出一个商品
                    Commodity commodity = repo.remove(0);
                    System.out.println("消费商品：" + commodity.toString());
                    //如果生产者阻塞，唤醒生产者，仓库有位置了
                    synLock.notify();
                }
                //5秒钟消费完商品
                long start = System.currentTimeMillis();
                while (System.currentTimeMillis() - start < 5000) {
                }
            } catch (InterruptedException e) {
                System.out.println("中断...");
            }
        }
    }
}

>运行结果：生产消费很快趋于稳定

3.2.3Thread的中断方法

每个线程都有一个标志位，标志当前线程是否中断，Thread类中有获取当前线程中断状态及设置当前线程为中断状态的方法；

interrupted：Thread的类方法，获取当前线程的中断状态，并重置当前线程为非中断状态；

isInterrupted：Thread的实例方法，获取当前线程的中断状态；

interrupt：Thread的实例方法，设置当前线程为中断状态；（只是单纯的设置线程的中断标志，至于线程中断后做什么在线程驱动的任务中可以通过捕获异常或获取中断状态后自己定义）

说明：

　　1. 如果线程因wait/sleep/join方法进入等待阻塞，或因调用Lock对象的lockInterrupity/tryLock(time)进入同步阻塞状态，其他线程中调用interrupt方法会导致阻塞线程中抛出InterruptException异常；

　　2. 阻塞状态的线程抛出InterruptException时会重置中断标志（标志位false）；

　　3. 类方法interrupted获取中断状态后会清除中断状态，实例方法isInterrupted()只是获取中断状态；

　　4. 除使用interrupt方法中断线程外，还有2种方式中止线程执行，a. 退出标志使线程正常退出(线程通信)；b.使用stop()方法强行终止线程（不推荐，可能发生不可预料的结果）

1. 中断使用场景：中断阻塞状态

>中断阻塞举例：中断sleep阻塞

import java.util.concurrent.TimeUnit;

/**
 * Created by 巩聪 on 2018/7/12.
 */
public class K3ThreadInterrupt {
    public static void main(String[] args ) throws Exception
    {
        Thread thread = new Thread(()->{
            try {
                //可以响应中断的阻塞有很多，例如：wait/join/sleep/lock.tryLock(time)/lock.lockInterruptibly
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                //捕获异常后线程恢复中断
                System.out.println("休眠阻塞的线程被其他线程中断了...");
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
    }
}

2. 中断使用场景：线程通信，实现生产者消费者问题

>线程驱动生产者消费者类

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class K4ThreadInterrupt {
    public static void main(String [] args) throws InterruptedException {
        List<Commodity> repo = new ArrayList(3);
        new Thread(new K4Producer(repo, 3), "producer").start();
        new Thread(new K4Consumer(repo), "consumer").start();
    }
    public static Thread getThread(String threadName)
    {
        ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
        Thread[] threads = new Thread[threadGroup.activeCount()];
        threadGroup.enumerate(threads);
        for (Thread thread : threads) {
            if(thread!=null && threadName.equals(thread.getName()))
            {
                return thread;
            }
        }
        return null;
    }
    public static void lastTime(TimeUnit timeUnit, int time)
    {
        long start = System.currentTimeMillis();
        long msTime = timeUnit.toMillis(time);
        while (System.currentTimeMillis() - start < msTime)
        {
        }
    }
    static class K4Producer implements Runnable{
        private List<Commodity> repo;
        private int repoSize;
        private Thread consumer;

        public K4Producer(List<Commodity> repo, int repoSize) {
            this.repo = repo;
            this.repoSize = repoSize;
        }

        public void setConsumer(Thread consumer) {
            this.consumer = consumer;
        }

        @Override
        public void run() {
            while (true)
            {
                //当前为中断状态(判定后清除)，且容器没有满
                if(Thread.interrupted() && repo.size() < repoSize)
                {
                    lastTime(TimeUnit.SECONDS, 1);
                    Commodity commodity = new Commodity("baskball", new Date());
                    repo.add(commodity);
                    System.out.println("生产："+commodity.toString());
                }
                Thread consumer = getThread("consumer");
                if(null != consumer)
                {
                    consumer.interrupt();
                }
            }
        }
    }
    static class K4Consumer implements Runnable{
        private List<Commodity> repo;
        private Thread producer;

        public K4Consumer(List<Commodity> repo) {
            this.repo = repo;
        }
        public void setProducer(Thread producer) {
            this.producer = producer;
        }
        @Override
        public void run() {
            while (true)
            {
                //当前为中断状态(判定后清除)，且容器没有满
                if(Thread.interrupted() && repo.size() > 0)
                {
                    lastTime(TimeUnit.SECONDS, 5);
                    Commodity commodity = repo.remove(0);
                    System.out.println("消费："+commodity.toString());
                }
                Thread producer = getThread("producer");
                if(null != producer)
                {
                    producer.interrupt();
                }
            }

        }
    }
}

说明：java volatile也可以实现类似功能

>运行结果：生产消费很快趋于稳定

3.2.4 拥塞队列/BlockingQueue

先粗略说一下java的容器，java容器有Collection和Map2个根接口，Collection又分为Set/集合、List/列表、Queue/队列；Set、List、Queue和Map就是我们常用的4种容器；

在线程安全的角度容器又分为线程安全和线程不安全的容器，线程不安全的常用容器有HashSet、ArrayList、PriorityQueue、HashMap等，如果多线程同时读写会有容器内数据不一致问题；

线程安全的容器又分为同步容器和并发容器，其中同步容器有Vector、Stack、HashTable，同步容器是在方法上面添加synchronized来保证线程安全；

并发容器指java.util.concurrent包中定义的容器，如常见的ConcurrentHashMap、CopyOnWriteArraySet、CopyOnWriteArrayList等，同步容器一般是通过各种Lock来保证线程安全的；

java.util.concurrent包中有一个比较特殊的容器接口BlockingQueue/阻塞队列，除了提供了线程安全外，还提供原有方法的阻塞版本，会对线程的调用产生阻塞，常用于线程池存放任务和生产者消费者问题；

队列的基本特性是先进先出，从队尾插入，队头删除；虽然Queue实现了Collection有删除指定元素的特性，但是使用队列一般都按照队列的使用方式队尾插入，队头删除；

JDK8提供了6种单向拥塞队列和1种双向拥塞队列：

　　1. 拥塞队列的常用方法

添加元素：

　　add(e): 非阻塞，队列满时抛出异常

　　offer(e)/offer(e, time): 非阻塞或定时阻塞，添加成功返回true，队列满时返回false，阻塞过程可以响应中断

　　put(e):阻塞，队列满时一直阻塞，阻塞过程可以响应中断

删除并返回元素：

　　remove():非阻塞，队列为空时抛出异常

　　poll()/poll(time):非阻塞或定时阻塞，队列为空返回null，阻塞过程可以响应中断

　　take():阻塞，队列为空时一直阻塞，阻塞过程可以响应中断

　　2.队列分类：

ArrayBlockingQueue/LinkedBlockingQueue：数组实现队列，需要指定大小，内存连续 ;       链表实现队列，默认大小为Integer.MAX_VALUE， 内存可以不连续

>队列基本的添加和删除

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * 数组和链表队列是最基本的2种队列，实现队列的3种添加，3种删除方法
 */
public class K0BlockingQueue {
    public static void main(String[] args) throws Exception {
        // 数组队列必须指定大小
        BlockingQueue<String> queue = new ArrayBlockingQueue(10);
        // 链表队列可以省略队列大小参数，默认为Integer.MAX_VALUE
        // queue = new LinkedBlockingDeque(10);
        new Thread(() -> {
            int count = 0;
            while (true) {
                //每隔2秒向队列放一个
                lastTime(TimeUnit.SECONDS, 2);
                boolean result;
                //如果队列满了，会抛出异常
                // result = queue.add("element"+(++count));
                //队列满了，返回false
                result = queue.offer("element" + (++count));
                // try {
                //     //队列满了，会阻塞,方法没有返回值
                //     queue.put("element"+(++count));
                // } catch (InterruptedException e) {
                //     System.out.println("中断...");
                // }
                System.out.println("添加结果：" + result);
            }
        }).start();
        while (true) {
            while (true) {
                //每1秒从队列取元素
                lastTime(TimeUnit.SECONDS, 1);
                String element = "";
                // 队列为空时抛出异常
                //  element = queue.remove();
                // 队列为空时，返回null
                element = queue.poll();
                //队列为空时阻塞
                // element = queue.take();
                System.out.println("取出结果：" + element);
            }
        }
    }

    //空循环指定时间
    public static void lastTime(TimeUnit timeUnit, long time) {
        long start = System.currentTimeMillis();
        while (timeUnit.toMillis(time) > System.currentTimeMillis() - start) {
        }
    }
}

SynchronousQueue：同步队列，大小为1（不存储元素），一个添加操作后必须删除操作

>同步队列添加和删除

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * 同步队列比较特殊，队列里面不能缓存多于1个元素，添加和删除必须依次执行，不会连续2次添加成功，不会连续2次删除成功
 * 一般使用阻塞方法
 */
public class K0BlockingQueue {
    public static void main(String[] args) throws Exception {
        // 同步队列没有大小，构造函数只有一个Boolean类型参数，标识是否公平队列
        BlockingQueue<String> queue = new SynchronousQueue();
        new Thread(() -> {
            int count = 0;
            while (true) {
                try {
                    //队列满了，会阻塞,方法没有返回值
                    String element = "element"+(++count);
                    queue.put(element);
                    System.out.println("添加成功:"+element);
                } catch (InterruptedException e) {
                    System.out.println("中断...");
                }
            }
        }).start();
        while (true) {
            while (true) {
                //3秒取出一个元素
                lastTime(TimeUnit.SECONDS, 3);
                //队列为空时阻塞
                String element = queue.take();
                System.out.println("取出结果：" + element);
            }
        }
    }
    //空循环指定时间
    public static void lastTime(TimeUnit timeUnit, long time) {
        long start = System.currentTimeMillis();
        while (timeUnit.toMillis(time) > System.currentTimeMillis() - start) {
        }
    }
}

PriorityBlockingQueue：优先级队列，队列元素必须实现Comparable接口（否则运行异常）复写compareTo(T)方法

>优先级队列添加和删除

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * 优先级队列提供了队列元素插队功能，新添加的元素不一定在队尾
 * 队列元素必须实现Comparable接口
 */
public class K0BlockingQueue {
    public static void main(String[] args) throws Exception {
        // 优先级队列元素必须实现Comparable接口 （或者构造函数提供Comparator实现）
        BlockingQueue<Element> queue = new PriorityBlockingQueue();
        new Thread(() -> {
            //分5批添加，每次添加3个
            for (int i = 1; i <= 5; i++) {
                for (int j = 1; j <= 3; j++) {
                    Element element = new Element(i, j == 3 ? 'W' : 'M');
                    try {
                        queue.put(element);
                    } catch (InterruptedException e) {
                        System.out.println("中断了...");
                    }

                }
                System.out.println(String.format("第%d批添加完毕.", i));
                lastTime(TimeUnit.SECONDS, 3);
            }
        }).start();

        while (true) {
            while (true) {
                //1秒取出一个元素
                lastTime(TimeUnit.SECONDS, 2);
                Element element = queue.take();
                System.out.println("取出元素：" + element.toString());
            }
        }
    }

    //空循环指定时间
    public static void lastTime(TimeUnit timeUnit, long time) {
        long start = System.currentTimeMillis();
        while (timeUnit.toMillis(time) > System.currentTimeMillis() - start) {
        }
    }

    /**
     * 队列元素
     */
    static class Element implements Comparable<Element> {
        //年龄
        private int age;
        //性别：M，W
        private char sex;

        public Element(int age, char sex) {
            this.age = age;
            this.sex = sex;
        }

        public int getAge() {
            return age;
        }

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

        public char getSex() {
            return sex;
        }

        public void setSex(char sex) {
            this.sex = sex;
        }

        /**
         * 年龄大的优先
         * 年龄相同女士优先
         * 年龄和性别相同随便
         *
         * @param o
         * @return
         */
        @Override
        public int compareTo(Element o) {
            int result = o.getAge() - this.getAge();
            if (result == 0) {
                if (this.getSex() == 'W') {
                    result = -1;
                } else {
                    result = 1;
                }
            }
            return result;
        }

        @Override
        public String toString() {
            return "Element{age=" + age + ", sex=" + sex + "}";
        }
    }
}

　　>执行结果：先取出队列中年龄大的女性元素  （因为连续添加3个元素没有添加同步，所以可能出现同一批添加过程有取出操作）

第1批添加完毕.
取出元素：Element{age=1, sex=W}
第2批添加完毕.
取出元素：Element{age=2, sex=W}
取出元素：Element{age=2, sex=M}
第3批添加完毕.
取出元素：Element{age=3, sex=W}
第4批添加完毕.
取出元素：Element{age=4, sex=W}
取出元素：Element{age=4, sex=M}
第5批添加完毕.
取出元素：Element{age=5, sex=W}
取出元素：Element{age=5, sex=M}
取出元素：Element{age=5, sex=M}
取出元素：Element{age=4, sex=M}
取出元素：Element{age=3, sex=M}
取出元素：Element{age=3, sex=M}
取出元素：Element{age=2, sex=M}
取出元素：Element{age=1, sex=M}
取出元素：Element{age=1, sex=M}

DelayQueue：延迟队列，队列元素必须实现Delayed接口（否则运行异常），Delayed接口继承了Comparable接口，所以必须复写compareTo(T)和getDelay(TimeUnit)2个方法，队列中的首个元素，如果getDelay返回值小于等于0则会出队列

>延迟队列添加和删除

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * 延迟队列指元素添加到队列中后，可以让元素不被立即取出，而是等待指定时间或条件
 * 队列元素必须实现Delayed，（Delayed接口继承了Comparable接口）
 */
public class K0BlockingQueue {
    public static void main(String[] args) throws Exception {
        // 延迟队列必须实现Delayed接口
        BlockingQueue<Element> queue = new DelayQueue();
        new Thread(() -> {
            while (true) {
                lastTime(TimeUnit.SECONDS, 3);
                queue.offer(new Element());
            }
        }).start();

        while (true) {
            while (true) {
                //1秒取出一个元素
                lastTime(TimeUnit.SECONDS, 1);
                System.out.println("取出元素：" + queue.take().toString());
            }
        }
    }

    //空循环指定时间
    public static void lastTime(TimeUnit timeUnit, long time) {
        long start = System.currentTimeMillis();
        while (timeUnit.toMillis(time) > System.currentTimeMillis() - start) {
        }
    }

    /**
     * 队列元素
     */
    static class Element implements Delayed {
        private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        private Date addDate;

        public Date getAddDate() {
            return addDate;
        }

        public Element() {
            addDate = new Date();
        }

        /**
         * 返回小于等于0的值时，元素可以被取出
         *
         * @param unit
         * @return
         */
        @Override
        public long getDelay(TimeUnit unit) {
            //addDate.getTime() 返回毫秒
            //3秒后取出
            return addDate.getTime() + TimeUnit.SECONDS.toMillis(3) - System.currentTimeMillis();
        }

        @Override
        public int compareTo(Delayed o) {
            if (o instanceof Element) {
                return (int) (this.getAddDate().getTime() - ((Element) o).getAddDate().getTime());
            }
            return 0;
        }

        @Override
        public String toString() {
            return "Element{addTime=" + dateFormat.format(this.addDate) + ", getTime=" + dateFormat.format(new Date()) +
                    "}";
        }
    }
}

LinkedTransferQueue

LinkedBlockingDeque

3. 队列实现线程协作 : 使用同步队列

 >延迟队列添加和删除

import java.util.Date;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;

/**
 *拥塞队列是实现生产者/消费者问题最简单的方式
 */
public class K4Blocking {
    public static void main(String[] args) throws Exception {
        BlockingQueue<Commodity> repo = new SynchronousQueue();
        new Thread(new K4Producer(repo)).start();
        new Thread(new K4Consumer(repo)).start();
    }
}

class K4Producer implements Runnable {
    private BlockingQueue<Commodity> repo;

    public K4Producer(BlockingQueue<Commodity> repo) {
        this.repo = repo;
    }

    @Override
    public void run() {
        while (true) {
            try {
                //卖方市场：消费者会因为没有商品而阻塞，生产者生产完会直接被消费
                //买方市场：需要在消费者线程控制时间
                long start = System.currentTimeMillis();
                while (System.currentTimeMillis() - start < 3000) {
                }
                Commodity commodity = new Commodity("...", new Date());
                System.out.println("生产商品："+ commodity.toString());
                this.repo.put(commodity);
            } catch (InterruptedException e) {
                System.out.println("中断了...");
            }
        }
    }
}

class K4Consumer implements Runnable {
    private BlockingQueue<Commodity> repo;

    public K4Consumer(BlockingQueue<Commodity> repo) {
        this.repo = repo;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Commodity commodity = repo.take();
                System.out.println("消费商品："+commodity.toString());
            } catch (InterruptedException e) {
                System.out.println("中断了...");
            }
        }
    }
}

 >执行结果：每生产一个商品，瞬间消费