线程的中断协商机制

什么是中断

一个线程不应该由其他线程来强制中断或停止,而是应该由线程自己自行停止。所以,Thread.stop、Thread.suspend、Thread. resume都已经被废弃了。

在Java中没有办法立即停止一条线程,然而停止线程却显得尤为重要,如取消一个耗时操作。
因此,Java提供了一种用于停止线程的机制即中断。中断只是一种协作机制,Java没有给中断增加任何语法,中断的实现完全需要程序员自己实现。

1、每个线程对象中都有一个标识,用于标识线程是否被中断;该标识位为true表示中断,为false表示未中断;若要中断协商一个线程,你需要手动调用该线程的interrupt方法,该方法也仅仅是
将线程对象的中断标识设为true。
2、interrupt可以在别的线程中调用,也可以在自己的线程中调用

interrupt

线程t1线程t2，当线程t2调用t1.interrupt()时

中断协商：如果t1线程处于正常活动状态，当线程t2调用t1.interrupt()时，那么会将t1线程的中断标志设置为true，仅此而已。t1线程将继续正常运行不受影响

isInterrupted

通过检查中断标志位判断当前线程是否被中断
●若中断标志为true，则isInterrupted返回true
●若中断标志为false，则isInterrupted返回false

静态方法interrupted

判断线程是否被中断,并清除当前中断状态,这个方法做了两件事：
●返回当前线程的中断状态
●将当前线程的中断状态重置即设为false

假设有两个线程A、B，线程B调用了interrupt方法。
后面如果我们连接调用两次interrupted方法,第一次会返回true,然后这个方法会将中断标识位设置位false,
所以第二次调用interrupted将返回false

中断运行中的线程

volatile

static volatile boolean isStop = false;public static void main(String[] args) {new Thread(() -> {while (true) {if (isStop) {System.out.println(Thread.currentThread().getName() + "\t isStop被修改为true，程序停止");break;}System.out.println("t1 -----hello volatile");}}, "t1").start();//暂停毫秒try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}new Thread(() -> {isStop = true;}, "t2").start();}

AtomicBoolean

static AtomicBoolean atomicBoolean = new AtomicBoolean(false);public static void main(String[] args) {new Thread(() -> {while (true) {if (atomicBoolean.get()) {System.out.println(Thread.currentThread().getName() + "\t atomicBoolean被修改为true，程序停止");break;}System.out.println("t1 -----hello atomicBoolean");}}, "t1").start();//暂停毫秒try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}new Thread(() -> {atomicBoolean.set(true);}, "t2").start();}

interrupt+isInterrupted

 static volatile boolean isStop = false;public static void main(String[] args) {Thread t1 = new Thread(() -> {while (true) {if (Thread.currentThread().isInterrupted()) {System.out.println(Thread.currentThread().getName() + "\t isInterrupted()被修改为true，程序停止");break;}System.out.println("t1 -----hello interrupt api");}}, "t1");t1.start();System.out.println("-----t1的默认中断标志位：" + t1.isInterrupted());//暂停毫秒try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}//t2向t1发出协商，将t1的中断标志位设为true希望t1停下来new Thread(() -> {t1.interrupt();}, "t2").start();//t1.interrupt();，t1也可以自己给自己协商}

等待唤醒

线程等待与唤醒的方式演进：

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。LockSupport类使用了一种名为Permit(许可)的概念来做到阻塞和唤醒线程的功能,每个线程都有一个许可(permit),permit只有两个值1和零,默认是零。可以把许可看成是一种(0,1)信号量(Semaphore)，但与Semaphore不同的是,许可的累加上限是1

阻塞方法park：

①. permit默认是0,所以一开始调用park()方法,当前线程就会阻塞,直到别的线程将当前线程的permit设置为1时, park方法会被唤醒,然后会将permit再次设置为0并返回
②. static void park( )：底层是unsafe类native方法

唤醒方法unpark：

①. 调用unpark(thread)方法后,就会将thread线程的许可permit设置成1(注意多次调用unpark方法,不会累加,permit值上限是1)会自动唤醒thread线程,即之前阻塞中的LockSupport.park()方法失效
②. static void unpark( )：底层是unsafe类native方法

LockSupport它的解决的痛点：
①. LockSupport不用持有锁块,在代码书写方面不用加锁
②. 唤醒与阻塞的先后顺序，即使先调用唤醒再调用阻塞也不会导致程序卡死报异常，因为unpark获得了一个凭证,之后再调用park方法,就可以名正言顺的依据凭证消费

demo

public class LockSupportDemo {static int x = 0;static int y = 0;public static void main(String[] args) {Thread t1 = new Thread(() -> {try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "\t ----come in" + System.currentTimeMillis());LockSupport.park();System.out.println(Thread.currentThread().getName() + "\t ----被唤醒" + System.currentTimeMillis());}, "t1");t1.start();//暂停几秒钟线程//try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {LockSupport.unpark(t1);System.out.println(Thread.currentThread().getName() + "\t ----发出通知");}, "t2").start();}
}

生产者与消费者

synchronized

public class ProductorAndConsumer {public static void main(String[] args) {Market market = new Market();Productor productor = new Productor(market);Consumer consumer = new Consumer(market);new Thread(productor, "生产者A").start();new Thread(consumer, "消费者B").start();new Thread(productor, "生产者C").start();new Thread(consumer, "消费者D").start();}
}//商店
class Market {//某件商品数量，最开始为0private int product = 0;//进货方法,在多线程环境下，如果不加锁会产生线程安全问题，这里加synchronized锁public synchronized void get() {//限定商店容量为10while (product > 10) {System.out.println("仓库已满！");//当仓库已满，需要停止生产try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName() + "进货成功！-->" + ++product);//当进货成功，就需要唤醒this.notifyAll();}//出售方法public synchronized void sale() {while (product <= 0) {System.out.println("已售罄！");//售罄之后需要停止去生产try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName() + "出售成功-->" + --product);//出售成功之后需要生产this.notifyAll();}
}//生产者,生产者不可能只有一个，所以是多线程的
class Productor implements Runnable {private Market market;public Productor(Market market) {this.market = market;}@Overridepublic void run() {//一次买15个for (int i = 0; i < 15; i++) {market.get();}}
}//消费者
class Consumer implements Runnable {private Market market;public Consumer() {}public Consumer(Market market) {this.market = market;}@Overridepublic void run() {//一次买10个for (int i = 0; i < 10; i++) {market.sale();}}
}

Lock

/** 使用Lock代替Synchronized来实现新版的生产者和消费者模式 !* */
@SuppressWarnings("all")
public class ThreadWaitNotifyDemo {public static void main(String[] args) {AirCondition airCondition = new AirCondition();new Thread(() -> {for (int i = 0; i < 10; i++) airCondition.decrement();}, "线程A").start();new Thread(() -> {for (int i = 0; i < 10; i++) airCondition.increment();}, "线程B").start();new Thread(() -> {for (int i = 0; i < 10; i++) airCondition.decrement();}, "线程C").start();new Thread(() -> {for (int i = 0; i < 10; i++) airCondition.increment();}, "线程D").start();}
}class AirCondition {private int number = 0;//定义Lock锁对象final Lock lock = new ReentrantLock();final Condition condition = lock.newCondition();//生产者,如果number=0就 number++public void increment() {lock.lock();try {//1.判断while (number != 0) {try {condition.await();//this.wait();} catch (InterruptedException e) {e.printStackTrace();}}//2.干活number++;System.out.println(Thread.currentThread().getName() + ":\t" + number);//3.唤醒condition.signalAll();//this.notifyAll();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}//消费者,如果number=1,就 number--public void decrement() {lock.lock();try {//1.判断while (number == 0) {try {condition.await();//this.wait();} catch (InterruptedException e) {e.printStackTrace();}}//2.干活number--;System.out.println(Thread.currentThread().getName() + ":\t" + number);//3.唤醒condition.signalAll();//this.notifyAll();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}
}

Lock带顺序的生产者与消费者

/*多个线程之间按顺序调用,实现A->B->C
三个线程启动,要求如下:AA打印5次,BB打印10次,CC打印15次接着AA打印5次,BB打印10次,CC打印15次....来10轮
* */
public class ThreadOrderAccess {public static void main(String[] args) {ShareResource shareResource = new ShareResource();new Thread(() -> {for (int i = 1; i <= 10; i++) shareResource.print5();}, "线程A").start();new Thread(() -> {for (int i = 1; i <= 10; i++) shareResource.print10();}, "线程B").start();new Thread(() -> {for (int i = 1; i <= 10; i++) shareResource.print15();}, "线程C").start();}
}class ShareResource {//设置一个标识,如果是number=1,线程A执行...private int number = 1;Lock lock = new ReentrantLock();Condition condition1 = lock.newCondition();Condition condition2 = lock.newCondition();Condition condition3 = lock.newCondition();public void print5() {lock.lock();try {//1.判断while (number != 1) {condition1.await();}//2.干活for (int i = 1; i <= 5; i++) {System.out.println(Thread.currentThread().getName() + ":\t" + i);}//3.唤醒number = 2;condition2.signal();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}public void print10() {lock.lock();try {//1.判断while (number != 2) {condition2.await();}//2.干活for (int i = 1; i <= 10; i++) {System.out.println(Thread.currentThread().getName() + ":\t" + i);}//3.唤醒number = 3;condition3.signal();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}public void print15() {lock.lock();try {//1.判断while (number != 3) {condition3.await();}//2.干活for (int i = 1; i <= 15; i++) {System.out.println(Thread.currentThread().getName() + ":\t" + i);}//3.唤醒number = 1;condition1.signal();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}
}