限制

1、限制对 CPU 的使用

单核 CPU 下，while (true) 里如果什么都不干， CPU 会空转占用会很快达到 100% 。这时 while(true) 里哪怕用 sleep(1) 也会大幅降低 cpu 占用

sleep 实现

while(true) {
 try {
 　　Thread.sleep(50);
 } catch (InterruptedException e) {
　　 e.printStackTrace();
 }
}

• 可以用 wait 或 条件变量达到类似的效果
• 不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
• sleep 适用于无需锁同步的场景

两阶段终止模式（Two phase termination）

在一个线程 T1 中如何优雅的终止线程 T2，这里的优雅是指给 T2 一个料理后事的机会

1、错误思路

• 使用线程对象的 stop() 方法停止线程
  • stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁
• 使用 System.exit(int) 方法停止线程
  • 目的仅是停止一个线程，但这种做法会让整个程序都停止

2、两阶段终止

通常有监控线程，每隔几秒（sleep()）进行一次系统状态记录，会一直让它 while(true) 运行。但是必须有可以让它停止下来的方法

• 情况1：如果在 sleep 时被打断了，那么就会有 InterruptException 异常，执行 catch(InterruptException e) 里的内容，这时打断标志位为 false，所以要重新打断一次，让它的标志位变为 true，这样下一次 while 循环，就会判断标志位然后继续走下面料理后事退出循环
• 情况2：如果在正常执行时（如记录监控日志时）被打断了，那么打断标志位为 true，这样下一次 while 循环，就会判断标志位然后继续走下面的料理后事退出循环

同步模式之保护性暂停

1. 定义

即 Guarded Suspension，用在一个线程等待另一个线程的执行结果

要点：

• 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject
• 如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）
• JDK 中，join 的实现、Future 的实现，采用的就是此模式
• 因为要等待另一方的结果，因此归类到同步模式

2.实现

class GuardedObject {

 　　private Object response;

 　　private final Object lock = new Object();

 　　public Object get() {
　　 　　synchronized (lock) {
　　　　　　// 条件不满足则等待
　　　　　　while (response == null) {
　　　　　　　　try {
　　　　　　　　　　lock.wait();
　　　　　　　　} catch (InterruptedException e) {
　　　　　　　　　　e.printStackTrace();
　　　　　　　　}
　　　　　　}
　　　　　　return response;
　　　　}
　　}
　　 public void complete(Object response) {
　　　　synchronized (lock) {
　　　　　　// 条件满足，通知等待线程，返回响应
　　　　　　this.response = response;
　　　　　　lock.notifyAll();
　　　　}
 　　}
　　　
}

3.应用

public static void main(String[] args) {
     // 两线程使用同一个 guardedObject
 　　GuardedObject guardedObject = new GuardedObject();
 　　new Thread(() -> {
　　　　try {
　　　　　　// 子线程执行下载
　　　　　　List<String> response = download();
　　　　　　log.debug("download complete...");
　　　　　　guardedObject.complete(response);
　　　　} catch (IOException e) {
　　　　　　e.printStackTrace();
　　　　}
 　　}).start();
 　　log.debug("waiting...");
 　　// 主线程阻塞等待
 　　Object response = guardedObject.get();
 　　log.debug("get response: [{}] lines", ((List<String>) response).size());
}

执行结果

08:42:18.568 [main] c.TestGuardedObject - waiting...
08:42:23.312 [Thread-0] c.TestGuardedObject - download complete...
08:42:23.312 [main] c.TestGuardedObject - get response: [3] lines

4.优点

相比 join ，notify 完了还可以干点别的事

5.带超时版 GuardedObject

控制超时时间

class GuardedObjectV2 {
 　　private Object response;
　　 private final Object lock = new Object();
　　 public Object get(long millis) {
　　　　synchronized (lock) {
　　　　　　// 1) 记录最初时间
　　　　　　long begin = System.currentTimeMillis();
　　　　　　// 2) 已经经历的时间
　　　　　　long timePassed = 0;
　　　　　　while (response == null) {
　　　　　　　　// 4) 假设 millis 是 1000，结果在 400 时唤醒了，那么还有 600 要等
　　　　　　　　long waitTime = millis - timePassed;
　　　　　　　　log.debug("waitTime: {}", waitTime);
　　　　　　　　if (waitTime <= 0) {
　　　　　　　　　　log.debug("break...");
　　　　　　　　　　break;
　　　　　　　　}
　　　　　　　　try {
　　　　　　　　　　lock.wait(waitTime);
　　　　　　　　} catch (InterruptedException e) {
　　　　　　　　　　e.printStackTrace();
　　　　　　　　}
　　　　　　　　// 3) 如果提前被唤醒，这时已经经历的时间假设为 400
　　　　　　　　timePassed = System.currentTimeMillis() - begin;
　　　　　　　　log.debug("timePassed: {}, object is null {}", 
　　　　　　　　　　timePassed, response == null);
　　　　　　　　}
　　　　　　　　return response;
　　　　　　}
　　   }
 
　　　　public void complete(Object response) {
　　　　　　synchronized (lock) {
　　　　　　　　// 条件满足，通知等待线程
　　　　　　　　this.response = response;
　　　　　　　　log.debug("notify...");
　　　　　　　　lock.notifyAll();
　　　　　　}
　　　　 }
}