文章目录
引言
LockSupport
线程中断机制
什么是中断机制?
- 一个线程不应该由其他线程来强制中断或停止,应该由线程自己去停止
- Thread.stop,Thread.suspend,Thread.resume 均已被弃用
- Java 提供了一种协作协商机制——中断,也称为中断标识协商机制
- 中断只是一种协商机制,Java 中没有给中断增加任何语法,中断过程完全需要程序员自己实现
- 若要中断一个线程,需要手动调用 interrupt 方法,该方法将线程对象的中断标识设成 true,之后编写代码不断检测当前线程的标志位
- 若为 true,表示别的线程请求被该线程中断,中断后代码由程序员实现
- 每个线程对象均有一个中断标志位,用于表示线程是否被中断,该标志位为 true 表示中断,为 false 表示未中断
- 通过调用线程对象 interrupt 方法将该线程的标志位设为 true,可以在别的线程中调用,也可以在自己的线程中调用
- 通过调用线程对象 interrupt 方法将该线程的标志位设为 true,可以在别的线程中调用,也可以在自己的线程中调用
说说一下 java.lang.Thread 类下的三个方法的区别
- 如何中断一个线程?
- 如何停止一个线程?
线程中断机制
中断机制相关 API 三个方法的说明
public void interrupt()
- 实例方法
- 仅仅设置了线程状态中断状态为 true,发起一个协商,并不会立刻停止线程
如果当前线程没有中断它自己（这在任何情况下都是允许的），则该线程的 checkAccess 方法就会被调用，这可能抛出 SecurityException。
如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。
如果该线程在可中断的通道上的 I/O 操作中受阻，则该通道将被关闭，该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。
如果该线程在一个 Selector 中受阻，则该线程的中断状态将被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用了选择器的 wakeup 方法一样。
如果以前的条件都没有保存，则该线程的中断状态将被设置。
中断一个不处于活动状态的线程不需要任何作用。
抛出： SecurityException - 如果当前线程无法修改该线程
public static boolean interrupted()
- 静态方法
- 首次调用返回线程状态,第二次调用将线程状态置为 false,并返回 fasle
测试当前线程是否已经中断。线程的_中断状态_ 由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。
线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。
**返回：**如果当前线程已经中断，则返回 true；否则返回 false。
public boolean isInterrupted()
- 实例方法
- 判断当前线程是否被中断(通过检查中断标志位)
测试线程是否已经中断。线程的_中断状态_ 不受该方法的影响。
线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。
**返回：**如果该线程已经中断，则返回 true；否则返回 false。
经典面试题中的中断机制考点
如何停止,中断运行中的线程
- 通过一个 volatile 变量实现
static volatile boolean isStop = false;
private static void m1_volatile() {
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();
}
- 运行上述 demo
- 通过 AtomicBoolean
- 原子布尔型,该变量的操作无需加锁
static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
private static void m2_atomicBoolean() {
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();
}
- 效果
- 通过 Thread 类自带的中断 api 实例方法实现
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(); //main线程中断
- 效果
API
核心思想:在需要中断的线程中不断监听中断状态,一旦发生中断,就执行相应的中断处理业务逻辑 stop 线程
- 实例方法
- interrupt(),没有返回值
- interrupted,没有返回值
- 源码分析(interrupt)
- Just to set the interrupt flag(只是为了设置中断标志)
- interrupt0()为 native 方法,交由 OS 进行调度
- 源码分析(isInterrupted)
当前线程的中断标志位为 true,是不是线程就立刻停止?
public static void main(String[] args) {
//实例方法interrupt()仅仅是设置线程的中断状态位设置为true，不会停止线程
Thread t1 = new Thread(() -> {
for (int i = 1; i <= 300; i++) {
System.out.println("-----: " + i);
}
System.out.println("t1线程调用interrupt()后的的中断标识02：" + Thread.currentThread().isInterrupted());
}, "t1");
t1.start();
System.out.println("t1线程默认的中断标识：" + t1.isInterrupted());//false
//暂停毫秒
try {
TimeUnit.MILLISECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
t1.interrupt();//true
System.out.println("t1线程调用interrupt()后的的中断标识01：" + t1.isInterrupted());//true
try {
TimeUnit.MILLISECONDS.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1线程调用interrupt()后的的中断标识03：" + t1.isInterrupted());//????---false中断不活动的线程不会产生任何影响。
}
- 运行结果
t1线程默认的中断标识：false //活跃的线程默认中断标志位为false
-----: 1
-----: 2
-----: 3
...
-----: 132
t1线程调用interrupt()后的的中断标识01：true //interrupt方法仅修改中断标志位
-----: 133
-----: 134
...
-----: 300
t1线程调用interrupt()后的的中断标识02：true //再次监听线程中断标志位
//对于一个不活跃的线程,调用interrupt方法不产生任何运行,可以理解为恢复中断标志位默认值
t1线程调用interrupt()后的的中断标识03：false
//线程结束
- 案例二
- 正常启动,正常中断
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
while (true) {
if (Thread.currentThread().isInterrupted()) {
System.out.println(Thread.currentThread().getName() + "\t " +
"中断标志位：" + Thread.currentThread().isInterrupted() + " 程序停止");
break;
}
System.out.println("-----hello InterruptDemo3");
}
}, "t1");
t1.start();
//暂停几秒钟线程
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> t1.interrupt(), "t2").start();
}
- 效果,中断之前一直执行
- 在调用 sleep()方法过程中被中断.重置中断标志位,抛出 InteruptedException 异常
- 此时中断标志位为 false,线程正常执行,where(true)…
- 效果
- 解决方案,在 catch 块中,再次调用 interrupt 方法复位中断标志位
try {
Thread.sleep(200);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();//为什么要在异常处，再调用一次？？
e.printStackTrace();
}
- interupt()源码
静态方法 Thread.interrupted(),谈谈你的理解
- demo
public static void main(String[] args) {
//测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态，
// 第二次再调用时中断状态已经被清除，将返回一个false。
System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
System.out.println("----1");
Thread.currentThread().interrupt();// 中断标志位设置为true
System.out.println("----2");
System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
Thread.interrupted();//静态方法
Thread.currentThread().isInterrupted();//实例方法
}
- 每次调用都指行两次操作
- 返回但前线程中断标志位
- 重置中断标志位(false)
- 两个方法的区别
- 底层
private native boolean isInterrupted(boolean ClearInterrupted);方法会根据传入的ClearInterrupted 参数确定是否重置中断标志位- 静态方法 interupted 传入的ClearInterrupted 为 true
- 实例方法 isInterupted 传入的ClearInterrupted 为 false
小结
- public void interupt()是一个实例方法
- 用于通知目标线程中断,仅仅设置目标线程中断标志位为 true
- public boolean isInterupted()也是一个实例方法
- 判断当前线程是否被中断,通过检查中断标志位,返回中断标志位
- public static boolean interupted()是 Thread 类的一个静态方法
- 先获取当前线程的中断标志位并返回,之后将当前线程的中断标志位重置为初始值(false)
- 不管线程是否被中断,第二次调用总是得到 false
LockSupport
是什么?
- park 方法与 unpark 方法
- 说明
- LockSupport 用于创建锁和其它同步类的基本线程阻塞原语
- park 方法的作用是阻塞线程 , unpark 方法是接触阻塞线程
线程等待唤醒机制
3 种让线程等待和唤醒的方法
- 使用 Object 类中的 wait 方法让线程等待,使用 notify 方法唤醒线程
- 使用 JUC 包中的 Condition 接口中的 await 方法让线程等待,使用 signal 方法唤醒线程
- 使用 LockSupport 类可以阻塞当前线程以及唤醒指定被阻塞的线程
Object 类中 wait 和 notify 方法实现线程等待和唤醒
正常情况,均在同步监视器中执行 wait 与 notify 方法,先执行 wait 方法后执行 notify 方法
private static void syncWaitNotify() {
Object objectLock = new Object();
new Thread(() -> {
synchronized (objectLock) {
System.out.println(Thread.currentThread().getName() + "\t ----come in");
try {
objectLock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "\t ----被唤醒");
}
}, "t1").start();
//暂停几秒钟线程
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
synchronized (objectLock) {
objectLock.notify();
System.out.println(Thread.currentThread().getName() + "\t ----发出通知");
}
}, "t2").start();
}
- 效果
- 结果说明
- t1 先执行,正常阻塞,
- t2 后执行,发出通知,结束线程
- t1 被唤醒,继续执行,结束线程
去除同步监视器 synchronized 的情况
- 效果
- 结果说明
- 抛出两次异常IllegalMonitorStateException,非法的监视器状态异常
- 带一次是调用 wait 方法,第二次是调用 notify 方法
- 结论
- wait 方法与 notify 方法的执行必须在当前线程已获取锁的情况下
- wait 方法与 notify 方法的执行必须在当前线程已获取锁的情况下
正常情况下,将 notify 先于 wait 执行
private static void syncWaitNotify() {
Object objectLock = new Object();
new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (objectLock) {
System.out.println(Thread.currentThread().getName() + "\t ----come in");
try {
objectLock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "\t ----被唤醒");
}
}, "t1").start();
//暂停几秒钟线程
//try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
synchronized (objectLock) {
objectLock.notify();
System.out.println(Thread.currentThread().getName() + "\t ----发出通知");
}
}, "t2").start();
}
- 效果
- 结果说明
- t2 先执行 notify 唤醒线程,此时 t1 还没启动
- t1 运行进入 wait,等待唤醒,t2 已经结束,t1 陷入无限等待
结论
- Object 中的 wait 于 notify 方法的使用有以下两个限制
- 两个方法均必须获取锁之后才能调用
- wait 方法必须先于 notify 方法调用
Condition 接口中的 await 后的 signal 方法实现线程的等待和唤醒
- 与 Object 类中的方法类似
- await 对标 wait 方法
- signal 对标 notify 方法
- 正常情况
private static void lockAwaitSignal() {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t ----come in");
condition.await();
System.out.println(Thread.currentThread().getName() + "\t ----被唤醒");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "t1").start();
//暂停几秒钟线程
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
lock.lock();
try {
condition.signal();
System.out.println(Thread.currentThread().getName() + "\t ----发出通知");
} finally {
lock.unlock();
}
}, "t2").start();
}
- 无锁情况,将 lock 与 unlock 方法注掉
- signal 先于 await 方法调用的情况
private static void lockAwaitSignal() {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t ----come in");
condition.await();
System.out.println(Thread.currentThread().getName() + "\t ----被唤醒");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "t1").start();
//暂停几秒钟线程
//try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
lock.lock();
try {
condition.signal();
System.out.println(Thread.currentThread().getName() + "\t ----发出通知");
} finally {
lock.unlock();
}
}, "t2").start();
}
- 结论
- 与 synchronized 的类似,须在获取锁之后进行调用,先等待再唤醒
- 与 synchronized 的类似,须在获取锁之后进行调用,先等待再唤醒
Object 类和 Condition 接口实现的限制
- 调用之前必须获取锁对象
- 先等待后唤醒
LockSupport 类中的 park 等待与 unpark 唤醒
- 该类与使用它的每个线程关联一个许可证（在Semaphore类的意义上）。 如果许可证可用，将立即返回park ，并在此过程中消费; 否则可能会阻止。 如果尚未提供许可，则致电unpark获得许可。 （与Semaphores不同，许可证不会累积。最多只有一个。）可靠的使用需要使用volatile（或原子）变量来控制何时停放或取消停放。 对于易失性变量访问保持对这些方法的调用的顺序，但不一定是非易失性变量访问。
- LockSupport 类使用了一种名为 Permit(许可)的概念做到阻塞和唤醒线程功能,每一个线程都有一个许可(permit)与 Semaphore 不同,LockSupport 许可上限是 1
- 主要方法
- 通过 LockSupport 调用 park 方法的执行过程
- permit 许可证默认没有,不能放行
- 所以一开始调用 park 方法但前线程就会阻塞,
- 直至别的线程调用 unpark 为当前线程发放 permit,park方法才会唤醒
- unpark 与 park 类似均调用自 UNSafe 类中的 unpark 方法
- 基于 LockSupport 实现等待唤醒
Thread t1 = new Thread(() -> {
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();
- 效果
- unpark 先于 park 执行的情况
- 效果
LockSupport 与 Object 和 Condition 先比的优点
- 方法的调用不在依赖于锁的环境
- LockSupport 支持先唤醒后等待
- unpark 发放的许可上限为 1
913
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
