无网站网络营销,电脑培训班速成班,网站备案信息填写,物流门户网站源码一、保护性暂停
1.1 定义
即Guarded Suspension,用在一个线程等待另一 个线程的执行结果
要点 ● 有一个结果需要从一个线程传递到另一 个线程#xff0c;让他们关联同一一个GuardedObject
● 如果有结果不断从一个线程到另一个线程那么可以使用消息队列#xff08;生产者…一、保护性暂停
1.1 定义
即Guarded Suspension,用在一个线程等待另一 个线程的执行结果
要点 ● 有一个结果需要从一个线程传递到另一 个线程让他们关联同一一个GuardedObject
● 如果有结果不断从一个线程到另一个线程那么可以使用消息队列生产者/消费者
● JDK中join的实现、Future的实现采用的就是此模式
● 因为要等待另一方的结果 因此归类到同步模式
1.2 实现
GuardedObject保护对象其response属性用来保存最终的结果t1使用结果t2产生结果初始值为nullwait-notify在GuardedObject上等待结果
模拟应用场景线程1需要等待线程2产生的结果线程2进行一个下载任务
import cn.itcast.pattern.Downloader;
import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.util.List;Slf4j(topic c.Test)
public class Test {public static void main(String[] args) throws InterruptedException {GuardedObject guardedObject new GuardedObject();new Thread(() - {// 等待结果log.debug(等待结果);ListString list guardedObject.get();log.debug(结果的大小:{}, list.size());}, t1).start();new Thread(() - {log.debug(执行下载);try {ListString list Downloader.download();// 将下载结果传给线程1guardedObject.complete(list);} catch (IOException e) {e.printStackTrace();}});}
}class uardedObject {// 结果private Object response;// 获取结果的方法public Object get() {synchronized (this) {// 还没有结果while (response null) {// 调用wait等待try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}return response;}}// 产生结果public void complete(Object response) {synchronized (this) {// 给结果成员变量赋值this.response response;// 通知等待线程this.notifyAll();}}
}运行结果
1.3 保护性暂停扩展—增加超时
二、 两阶段终止-interrupt
Two Phase Termination 在一个线程T1中如何“优雅”终止线程T2这里的【优雅】指的是给T2一个料理后事的机会。
错误思路
● 使用线程对象的stop()方法停止线程强制杀死 —— stop方法会真正杀死线程如果这时线程锁住了共享资源那么当它被杀死后就再也没有机会释放锁其它线程将永远无法获取锁
● 使用System.exitint方法停止线程 —— 目的仅是停止一个线程但这种做法会让整个程序都停止
2.1 两阶段终止-interrupt分析
有如下场景做一个系统的健康状态监控记录电脑CPU的使用率、内存的使用率实现定时监控。实现这样一个场景可用一个后台的监控线程不断记录。 代码实现
import lombok.extern.slf4j.Slf4j;Slf4j(topic c.Test)
public class Test {public static void main(String[] args) throws InterruptedException {TwoPhaseTermination tptnew TwoPhaseTermination();// 启动监控线程每隔1秒执行监控记录tpt.start();// 模拟非正常打断主线程经过3.5后被interrupt()优雅打断Thread.sleep(3500);tpt.stop();}
}
// 监控类代码
Slf4j(topic c.TwoPhaseTermination)
class TwoPhaseTermination{// 创建监控线程private Thread monitor;// 启动监控线程public void start(){// 创建线程对象monitornew Thread(()-{// 不断被执行监控while (true){// 获取当前线程对象判断是否被打断Thread current Thread.currentThread();if(current.isInterrupted()){// 若被打断log.debug(料理后事);break;}// 若未被打断每隔2s执行睡眠进行监控操作try {Thread.sleep(1000); // 情况1非正常打断睡眠过程中log.debug(执行监控记录); // 情况2正常打断} catch (InterruptedException e) {e.printStackTrace();// 重新设置打断标记sleep()被打断后会清除打断标记current.interrupt();}}});monitor.start();}// 停止监控线程public void stop(){// 优雅打断monitor.interrupt();}
}
运行结果
分析监控线程每隔1s监控系统主线程处于休眠状态3.5秒后休眠状态被打断
*****interrupted与isInterrupted均为判断当前线程是否被打断表面上看起来类似。但却有着很大的区别调用isInterrupted不会清除打断标记而调用interrupted判断完后会将打断标记清除
三、固定运行顺序
同步模式之顺序控制 比如先打印2后打印1如果不加控制两个线程被CPU调度的时间不受控制
3.1 wait notify版
import lombok.extern.slf4j.Slf4j;Slf4j(topic c.Test25)
public class Test25 {// 锁对象static final Object lock new Object();// 表示 t2 是否运行过static boolean t2runned false;public static void main(String[] args) {// 打印1的线程线程1期待线程2打印过后将标记置为真后再打印Thread t1 new Thread(() - {synchronized (lock) {while (!t2runned) {try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug(1);}}, t1);// 打印2的线程Thread t2 new Thread(() - {synchronized (lock) {log.debug(2);t2runned true;lock.notify();}}, t2);t1.start();t2.start();}
}运行结果
3.2 park unpack版
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.LockSupport;Slf4j(topic c.Test26)
public class Test26 {public static void main(String[] args) {Thread t1 new Thread(() - {LockSupport.park();log.debug(1);}, t1);t1.start();new Thread(() - {log.debug(2);LockSupport.unpark(t1);},t2).start();}
}运行结果
3.3 ReentrantLock——awaitsignal
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;Slf4j(topic c.Test24)
public class Test24 {static final Object room new Object();static boolean flag false;static ReentrantLock ROOM new ReentrantLock();// 创建一个新的条件变量休息室static Condition waitSet ROOM.newCondition();public static void main(String[] args) throws InterruptedException {// 打印“1”的线程Thread t1 new Thread(() - {ROOM.lock();try {log.debug(2是否打印完毕[{}], flag);while (!flag) {log.debug(未打印2先歇会);try {waitSet.await();} catch (InterruptedException e) {e.printStackTrace();}}log.debug(1);} finally {// 解锁ROOM.unlock();}});// 打印“2”的线程Thread t2new Thread(()-{ROOM.lock();try {log.debug(2);flagtrue;// 唤醒线程waitSet.signal();}finally {ROOM.unlock();}});t1.start();t2.start();}
}四、交替输出
线程1输出a 5次线程2输出b 5次线程3输出c 5次。现在要求输出abcabcabcabcabc怎么实现
4.1 wait notify版
import lombok.extern.slf4j.Slf4j;Slf4j(topic c.Test)
public class Test {public static void main(String[] args) {Wait_notify wait_notify new Wait_notify(1,5);// 线程t1打印anew Thread(() - {wait_notify.print(a,1,2);}, t1).start();// 线程t1打印bnew Thread(() - {wait_notify.print(b,2,3);}, t2).start();// 线程t3打印cnew Thread(() - {wait_notify.print(c,3,1);}, t3).start();}
}/*输出内容 等待标记 下一个标记a 1 2b 2 3c 3 1*/
class Wait_notify {// 等待标记【存在3个线程因此用blooen变量不太合适blooen变量的状态只有两个】private int flag; // 1: t1 2: t2 3: t3// 循环次数private int loopnumber;public Wait_notify(int flag, int loopnumber) {this.flag flag;this.loopnumber loopnumber;}// 打印方法打印内容打印标记public void print(String s, int wait, int nextFlag) {for (int i 0; i loopnumber; i) {synchronized (this) {while (flag ! wait) {// 进入等待try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.print(s);flag nextFlag;// 唤醒其他等待的线程this.notifyAll();}}}
}运行结果
4.2 ReentrantLock——awaitsignal
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;Slf4j(topic c.Test)
public class Test {public static void main(String[] args) throws InterruptedException {Awaitsynch awaitsynch new Awaitsynch(5);// 线程1的休息室Condition a awaitsynch.newCondition();// 线程2的休息室Condition b awaitsynch.newCondition();// 线程3的休息室Condition c awaitsynch.newCondition();new Thread(() - {awaitsynch.print(a, a, b);}).start();new Thread(() - {awaitsynch.print(b, b, c);}).start();new Thread(() - {awaitsynch.print(c, c, a);}).start();// 三个线程刚开始都会进入各自休息室进行休息利用主线程先将a休息室中的线程唤醒Thread.sleep(1000);awaitsynch.lock();try {System.out.println(开始......);// 唤醒a休息室中的线程a.signal();} finally {awaitsynch.unlock();}}
}
class Awaitsynch extends ReentrantLock {// 循环次数private int loopnumber;public Awaitsynch(int loopnumber) {this.loopnumber loopnumber;}// 打印内容,进入的休息室,下一个休息室public void print(String s, Condition con, Condition next) {for (int i 0; i loopnumber; i) {// 给当前线程加锁lock();try {con.await();System.out.print(s);// 唤醒下一个休息室中的线程next.signal();} catch (InterruptedException e) {e.printStackTrace();} finally {unlock();}}}
}运行结果
4.3 park unpack版
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.LockSupport;Slf4j(topic c.Test24)
public class Test24 {static Thread a;static Thread b;static Thread c;public static void main(String[] args) throws InterruptedException {ParkUnpark parkUnpark new ParkUnpark(5);anew Thread(() - {parkUnpark.print(a, b);});bnew Thread(() - {parkUnpark.print(b, c);});cnew Thread(() - {parkUnpark.print(c, a);});a.start();b.start();c.start();// 主线程唤醒当前暂停的线程LockSupport.unpark(a);}
}
class parkUpark {// 循坏次数private int loopNumber;public parkUpark(int loopNumber) {this.loopNumber loopNumber;}// print(打印的内容,要唤醒的线程)public void print(String s, Thread next) {for (int i 0; i loopNumber; i) {// 暂停当前线程(阻塞)LockSupport.park();System.out.println(s);// 唤醒下一个线程LockSupport.unpark(next);}}
}
