Java Sleep的替换方法

Sleep 问题说明

假设一个场景，人每次往猫盆里放一份猫粮，放完之后就休息一段时间；猫每次吃一份猫粮，吃完也休息一段时间。 显然，如果要保证猫每次醒来都能吃到猫粮，猫的休息时间必须大于人的最大休息时间。

假设人每次休息的时长为0~3000毫秒的随机数，则猫的每次休息时间必须大于3000毫秒。我们用Sleep来模拟两者的做法。

public class TestSleep {
    // 猫盆里的食物数量
    private static Integer catFoods = 0;

    public static void main(String[] args){
        Thread person = new PersonThread();
        person.start();

        Thread cat = new CatThread();
        cat.start();
    }

    static class PersonThread extends Thread {
        @Override
        public void run() {
            while (true){
                // 猫粮加1
                catFoods++;
                System.out.println("======= Person 人往猫盆里放了一份猫粮，当前猫粮数："+catFoods);

                // 人休息0~3000毫秒，休息时间是不固定的
                int time = (int) (Math.random()*3000);
                System.out.println("======= Person 休息 time="+time);
                try {
                    sleep(time);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class CatThread extends Thread {
        @Override
        public void run() {
            while (true){
                if(catFoods >0){
                    catFoods--;
                    System.out.println("======= Cat 猫咪吃了一份猫粮，当前猫粮数："+catFoods);
                }else{
                    System.out.println("======= Cat 猫盆里没有猫粮");
                }

                // 猫粮休息的时间必须大于人的休息时间，才能保证猫咪每次醒来都能吃到猫粮
                System.out.println("====== Cat 休息");
                try {
                    // 固定休息3000毫秒
                    sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

显然，上述方法长时间执行就会发现猫粮是一直在不断增加。由于人的休息时间猫是无法知道的，因此猫只能被迫等待足够长的时间才能确保每次醒来都能吃到猫粮。

如何优化这个流程呢？显然，如果人每次放完猫粮之后都叫醒猫，那么猫就不必被迫长时间等待了，这里我们可以使用 CountDownLatch 和 Lock 来实现。

CountDownLatch 方法实现

import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch {
    // 猫盆里的食物数量
    private static Integer catFoods = 0;
    // 叫醒服务
    public static CountDownLatch latch = new CountDownLatch(1);

    public static void main(String[] args) {
        Thread cat = new CatThread();
        cat.start();

        Thread person = new PersonThread();
        person.start();
    }

    static class PersonThread extends Thread {
        @Override
        public void run() {
            while (true) {
                // 猫粮加1
                catFoods++;
                System.out.println("======= Person 人往猫盆里放了一份猫粮，当前猫粮数：" + catFoods);
                // 叫醒猫
                latch.countDown();
                // 人休息0~3000毫秒，休息时间是不固定的
                int time = (int) (Math.random() * 3000);
                System.out.println("======= Person 休息 time=" + time);
                try {
                    sleep(time);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class CatThread extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    System.out.println("======= Cat 猫休息，等待叫醒");
                    // 休息，等待人叫醒
                    latch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (catFoods > 0) {
                    catFoods--;
                    System.out.println("======= Cat 被叫醒，吃了一份猫粮，当前猫粮数：" + catFoods);
                } else {
                    System.out.println("======= Cat 猫盆里没有猫粮");
                }
                // CountDownLatch默认只能使用一次，因此要重置一下叫醒服务
                latch = new CountDownLatch(1);
            }
        }
    }
}

Lock 方法实现

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestLock {

    // 猫盆里的食物数量
    private static Integer catFoods = 0;
    public static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread cat = new CatThread();
        cat.start();

        Thread person = new PersonThread();
        person.start();
    }

    static class PersonThread extends Thread {

        @Override
        public void run() {
            while (true) {
                // 猫粮加1
                catFoods++;
                System.out.println("======= Person 人往猫盆里放了一份猫粮，当前猫粮数：" + catFoods);
                // 叫醒猫
                synchronized (lock) {
                    lock.notify();
                }
                // 人休息0~3000毫秒，休息时间是不固定的
                int time = (int) (Math.random() * 3000);
                System.out.println("======= Person 休息 time=" + time);
                try {
                    sleep(time);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class CatThread extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    System.out.println("======= Cat 猫休息，等待叫醒");
                    // 休息，等待人叫醒
                    synchronized (lock) {
                        lock.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (catFoods > 0) {
                    catFoods--;
                    System.out.println("======= Cat 被叫醒，吃了一份猫粮，当前猫粮数：" + catFoods);
                } else {
                    System.out.println("======= Cat 猫盆里没有猫粮");
                }
            }
        }
    }
}

通过上述方式，猫就可以灵活控制等待时间，由人主动叫醒猫。长时间执行，猫盆里的猫粮也不会有剩余。

后记

注意：阻塞方法是 latch.await()，而不是 latch.wait()，否则会抛出如下异常。

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at com.krt.testOne.TestCountDownLatch$CatThread.run(TestCountDownLatch.java:50)

更多介绍参考：https://www.jianshu.com/p/e233bb37d2e6