【java 高并发编程之JUC】高阶JUC特性总结
1 线程中断机制
1.1 什么是中断?
首先
一个线程不应该由其他线程来强制中断或停止,而是应该由线程自己自行停止。所以,Thread.stop, Thread.suspend, Thread.resume 都已经被废弃了。其次
在Java中没有办法立即停止一条线程,然而停止线程却显得尤为重要,如取消一个耗时操作。因此,Java提供了一种用于停止线程的机制——中断。
中断只是一种协作机制,Java没有给中断增加任何语法,中断的过程完全需要程序员自己实现。若要中断一个线程,你需要手动调用该线程的interrupt方法,该方法也仅仅是将线程对象的中断标识设成true;接着你需要自己写代码不断地检测当前线程的标识位,如果为true,表示别的线程要求这条线程中断,此时究竟该做什么需要你自己写代码实现。
每个线程对象中都有一个标识,用于表示线程是否被中断;该标识位为true表示中断,为false表示未中断;通过调用线程对象的interrupt方法将该线程的标识位设为true;可以在别的线程中调用,也可以在自己的线程中调用。
1.2 中断的相关API方法
public void interrupt() |
实例方法, 实例方法interrupt()仅仅是设置线程的中断状态为true,不会停止线程 |
---|---|
public static boolean interrupted() |
静态方法,Thread.interrupted(); 判断线程是否被中断,并清除当前中断状态 这个方法做了两件事: 1 返回当前线程的中断状态 2 将当前线程的中断状态设为false 这个方法有点不好理解,因为连续调用两次的结果可能不一样。 |
public boolean isInterrupted() |
实例方法, 判断当前线程是否被中断(通过检查中断标志位) |
1.3 面试题:如何使用中断标识停止线程?
在需要中断的线程中不断监听中断状态,一旦发生中断,就执行相应的中断处理业务逻辑。
中断只是一种协同机制,修改中断标识位仅此而已,不是立刻stop打断
中断线程方法:
- 通过一个volatile变量实现
public class InterruptDemo
{
private static volatile boolean isStop = false;public static void main(String[] args)
{new Thread(() -> {while(true){if(isStop){System.out.println(Thread.currentThread().getName()+"线程------isStop = true,自己退出了");break;}System.out.println("-------hello interrupt");}},"t1").start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }isStop = true;
}
- 通过AtomicBoolean
public class StopThreadDemo
{private final static AtomicBoolean atomicBoolean = new AtomicBoolean(true);public static void main(String[] args){Thread t1 = new Thread(() -> {while(atomicBoolean.get()){try { TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }System.out.println("-----hello");}}, "t1");t1.start();try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }atomicBoolean.set(false);}
}
通过Thread类自带的中断api方法实现
public class InterruptDemo {public static void main(String[] args){Thread t1 = new Thread(() -> {while(true){if(Thread.currentThread().isInterrupted()){System.out.println("-----t1 线程被中断了,break,程序结束");break;}System.out.println("-----hello");}}, "t1");t1.start();System.out.println("**************"+t1.isInterrupted());//暂停5毫秒try { TimeUnit.MILLISECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }t1.interrupt();System.out.println("**************"+t1.isInterrupted());} }
1.4 线程中断总结
线程中断相关的方法:
interrupt()
方法是一个实例方法
它通知目标线程中断,也就是设置目标线程的中断标志位为true,中断标志位表示当前线程已经被中断了。isInterrupted()
方法也是一个实例方法
它判断当前线程是否被中断(通过检查中断标志位)并获取中断标志Thread类的静态方法interrupted()
返回当前线程的中断状态(boolean类型)且将当前线程的中断状态设为false,此方法调用之后会清除当前线程的中断标志位的状态(将中断标志置为false了),返回当前值并清零置false
2. LockSupport
LockSupport是concurrent包中一个工具类,不支持构造,提供了一堆 static 方法,比如park(),unpark()等。
LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
下面这句话,后面详细说
LockSupport中的park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程
使用了一种名为Permit(许可)的概念来做到阻塞和唤醒线程的功能,每个线程都有一个许可。
2.1 3种让线程等待和唤醒的方法
方式1:使用Object中的wait()方法让线程等待,使用Object中的notify()方法唤醒线程
/**** 1 正常程序演示** 以下异常情况:* 2 wait方法和notify方法,两个都去掉同步代码块后看运行效果* 2.1 异常情况* Exception in thread "t1" java.lang.IllegalMonitorStateException at java.lang.Object.wait(Native Method)* Exception in thread "t2" java.lang.IllegalMonitorStateException at java.lang.Object.notify(Native Method)* 2.2 结论* Object类中的wait、notify、notifyAll用于线程等待和唤醒的方法,都必须在synchronized内部执行(必须用到关键字synchronized)。** 3 将notify放在wait方法前面* 3.1 程序一直无法结束* 3.2 结论* 先wait后notify、notifyall方法,等待中的线程才会被唤醒,否则无法唤醒*/
public class LockSupportDemo
{public static void main(String[] args)//main方法,主线程一切程序入口{Object objectLock = new Object(); //同一把锁,类似资源类new Thread(() -> {synchronized (objectLock) {try {objectLock.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName()+"\t"+"被唤醒了");},"t1").start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(3L); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {synchronized (objectLock) {objectLock.notify();}//objectLock.notify();/*synchronized (objectLock) {try {objectLock.wait();} catch (InterruptedException e) {e.printStackTrace();}}*/},"t2").start();}
}
小结:
- wait和notify方法必须要在同步块或者方法里面,且成对出现使用
- 先wait后notify才OK
方式2:使用JUC包中Condition的await()方法让线程等待,使用signal()方法唤醒线程
public class LockSupportDemo2
{public static void main(String[] args){Lock lock = new ReentrantLock();Condition condition = lock.newCondition();new Thread(() -> {lock.lock();try{System.out.println(Thread.currentThread().getName()+"\t"+"start");condition.await();System.out.println(Thread.currentThread().getName()+"\t"+"被唤醒");} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}},"t1").start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(3L); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {lock.lock();try{condition.signal();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}System.out.println(Thread.currentThread().getName()+"\t"+"通知了");},"t2").start();}
}
小结
- Condtion中的线程等待和唤醒方法之前,需要先获取锁
- 一定要先await后signal,不要反了
方式3:LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程
LockSupport 主要API
阻塞 park() /park(Object blocker)
阻塞当前线程/阻塞传入的具体线程
调用LockSupport.park()
时
permit默认是零,所以一开始调用park()方法,当前线程就会阻塞,直到别的线程将当前线程的permit设置为1时,park方法会被唤醒,
然后会将permit再次设置为零并返回。
唤醒 unpark(Thread thread)
LockSupport.unpark(thread);
调用unpark(thread)方法后,就会将thread线程的许可permit设置成1(注意多次调用unpark方法,不会累加,permit值还是1)会自动唤醒thread线程,即之前阻塞中的LockSupport.park()方法会立即返回。
public class LockSupportDemo3
{public static void main(String[] args){//正常使用+不需要锁块Thread t1 = new Thread(() -> {System.out.println(Thread.currentThread().getName()+" "+"1111111111111");LockSupport.park();System.out.println(Thread.currentThread().getName()+" "+"2222222222222------end被唤醒");},"t1");t1.start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }LockSupport.unpark(t1);System.out.println(Thread.currentThread().getName()+" -----LockSupport.unparrk() invoked over");}
}
之前错误的先唤醒后等待,LockSupport照样支持
public class T1
{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"+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(); }LockSupport.unpark(t1);System.out.println(Thread.currentThread().getName()+"\t"+System.currentTimeMillis()+"---unpark over");}
}
2.2 小结一下,LockSupport比Object的wait/notify有两大优势:
- LockSupport不需要在同步代码块里 。所以线程间也不需要维护一个共享的同步对象了,实现了线程间的解耦。
- unpark函数可以先于park调用,所以不需要担心线程间的执行的先后顺序。
- LockSupport原理
2.3 LockSupport原理
看源码,park和unpark都是直接调用了Unsafe的方法
public static void park() {UNSAFE.park(false, 0L);}public static void unpark(Thread var0) {if (var0 != null) {UNSAFE.unpark(var0);}}
Unsafe源码也相对简单,看下就行了:
void
sun::misc::Unsafe::unpark (::java::lang::Thread *thread)
{natThread *nt = (natThread *) thread->data;nt->park_helper.unpark ();
}void
sun::misc::Unsafe::park (jboolean isAbsolute, jlong time)
{using namespace ::java::lang;Thread *thread = Thread::currentThread();natThread *nt = (natThread *) thread->data;nt->park_helper.park (isAbsolute, time);
}
2.4 小结
多次调用unpark方法和调用一次unpark方法效果一样,因为都是直接将_counter赋值为1,而不是加1。简单说就是:线程A连续调用两次LockSupport.unpark(B)方法唤醒线程B,然后线程B调用两次LockSupport.park()方法, 线程B依旧会被阻塞。因为两次unpark调用效果跟一次调用一样,只能让线程B的第一次调用park方法不被阻塞,第二次调用依旧会阻塞。
3. Java内存模型之JMM
参考 万字总结什么是JMM、内存屏障及其原理
4. CAS
源码级别的讲解JAVA 中的CAS
5. 聊聊ThreadLocal
ThreadLocal 源码级别详解
6. Java对象内存布局和对象头
Java对象内存布局及对象头详解
7. Synchronized与锁升级
史上最详细JUC教程之Synchronized与锁升级详解
8. AbstractQueuedSynchronizer之AQS
谈谈Java多线程离不开的AQS
【java 高并发编程之JUC】高阶JUC特性总结相关推荐
- JUC 高并发编程之JUC三大辅助类
JUC 高并发编程之JUC三大辅助类 JUC 中提供了三种常用的辅助类,通过这些辅助类可以很好的解决线程数量过 多时 Lock 锁的频繁操作.这三种辅助类为: CountDownLatch: 减少计数 ...
- 【java 高并发编程之JUC】2w字带你JUC从入门到精通
点击查看脑图目录地址,实时更新 1 什么是 JUC 1.1 JUC 简介 在 Java 中,线程部分是一个重点,本篇文章说的 JUC 也是关于线程的.JUC 就是 java.util .concurr ...
- Java高级技术第五章——高并发编程之从synchronized关键字到事务并发的若干问题
前言 前言点击此处查看: http://blog.csdn.net/wang7807564/article/details/79113195 synchronized关键字 通过该关键字的使用,保证可 ...
- 高并发编程之AtomicReference使用场景
Java并发--AtomicReferencen,解决并发时修改多个属性 记录一下工作中,mycat主从延迟,缓存数据有误解决方案 一.AtomicReference介绍 1-AtomicRefere ...
- 高并发编程之AtomicLong讲解
一.AtomicLong介绍 AtomicLong是作用是对长整形进行原子操作. 在32位操作系统中,64位的long 和 double 变量由于会被JVM当作两个分离的32位来进行操作,所以不具有原 ...
- JUC并发编程之Callable接口、JUC三大辅助类
目录 8. Callable接口 8.1 创建线程的多种方式 8.2 概述 8.3 用Callable接口创建Thred线程 8.4 小结(重点) 9. JUC 三大辅助类 9.1 概述 9.2 减少 ...
- java并发编程之4——Java锁分解锁分段技术
转载自 java并发编程之4--Java锁分解锁分段技术 并发编程的所有问题,最后都转换成了,"有状态bean"的状态的同步与互斥修改问题.而最后提出的解决"有状态bea ...
- Java 并发编程之美:并发编程高级篇之一-chat
借用 Java 并发编程实践中的话:编写正确的程序并不容易,而编写正常的并发程序就更难了.相比于顺序执行的情况,多线程的线程安全问题是微妙而且出乎意料的,因为在没有进行适当同步的情况下多线程中各个操作 ...
- Java 并发编程之美:并发编程高级篇之一
借用 Java 并发编程实践中的话:编写正确的程序并不容易,而编写正常的并发程序就更难了.相比于顺序执行的情况,多线程的线程安全问题是微妙而且出乎意料的,因为在没有进行适当同步的情况下多线程中各个操作 ...
最新文章
- 【PMP】知识点总结20170528
- 川大网教计算机文化基础考试题,川大网教计算机文化基础第一次作业统一标准答案.doc...
- 华为p30是不是鸿蒙芯片,鸿蒙OS+麒麟1020 5G芯片华为P50 Pro,华为P30沦为白菜机改写历史...
- java 一个大事务下的新增、修改、查询_重新学习Mysql数据库8:MySQL的事务隔离级别实战...
- 【朝夕技术专刊】Core3.1WebApi_Filter多种注册方式支持依赖注入
- java session时间_Java基础:里设置session过期时间
- 考勤系统 服务器管理,考勤管理系统ZKNet Web Server管理
- ZZULIOJ1049
- 福昕pdf套件注册码激活
- Xcode可以清理哪些缓存?
- 电脑技巧:Win10操作系统设置定时开机图解教程
- 深度学习在图像分类中的发展
- 基于c语言的象棋游戏
- 显示12306服务器处理中正在排队,12306称能够解决技术问题 不与企业合作
- 去年190家共享经济平台融资1159亿 共享汽车融资最多
- 软件测试建模:Google ACC
- Cassandra实例
- ORACLE找出最大的数返回 GREATEST()函数
- 奇说妙语百度云_陶杰
- JavaScript视频处理库
热门文章
- STM32F103ZE 内部flash 读写
- TRIE_End-to-End Text Reading and Information Extraction for Document Understand 稿
- python引入同一目录下的py文件
- 解决:com.mysql.cj.exceptions.InvalidConnectionAttributeException: The server time zone value '�й���ʱ�
- python 生成图表
- 终极单词index 排序 A-B
- 【NLP】中文停用词表(附哈工大停用词表代码)
- 对测绘软件南方CASS的使用感想
- connection closed gracefully问题
- UCI银行营销数据集---数据可视化