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)