JUC笔记(三)
常用辅助类
1、CountDownLatch
会维护一个减法计数器,当计数器归0时,才会继续之后的操作,否则阻塞。
两个关键方法:
-
countDown():计数器-1;
-
await():阻塞等待计数器归0,也能够配置超时时间。
//实现例子:
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class CountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
//初始化一个计数器
CountDownLatch countDownLatch = new CountDownLatch(5);
for (int i = 1; i <=5 ; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"start count...");
countDownLatch.countDown();
}).start();
}
//等待计数器归零,归零前阻塞
countDownLatch.await();
//countDownLatch.await(50, TimeUnit.SECONDS); 也有超时等待方法
System.out.println(Thread.currentThread().getName()+" end ...");
}
}
执行结果:
2、CyclicBarrier
会维护一个加法计数器,当计数器达到设定值时,才会继续之后的操作(或者执行参数中的runnable),之前阻塞。
//实现例子:
public class CyclicBarrierTest {
public static void main(String[] args) {
//设定计数器最大值,当计数器值到达时执行一个方法。
CyclicBarrier cyclicBarrier = new CyclicBarrier(10,()->{
System.out.println("数量达到上限!程序结束");
});
for (int i = 1; i <=10 ; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"is in count...");
try {
//等待,计数器加1
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
执行结果:
3、Semaphore 信号量
通过信号量限制最大线程数。
方法:
-
acquire();获取一个信号量,总信号量-1,当信号量为0时,阻塞。
-
release();释放一个信号量,总信号量+1。
JMM
Java Memory Model ->java内存模型
8大操作
线程并不会直接操作主内存,而是先将参数从主内存读取一份(read),载入自己的工作内存(load),然后线程的 执行引擎 会使用工作内存中的值(use),操作完后将新的值赋值回工作内存(assign),再将工作内存的值取出(stroe),刷新到主内存(write)。
操作必须(lock)和(unlock)
Volatile
volatile的理解
-
保证可见性(JMM)
如何验证?见上图👆
-
不保证原子性(原子类)
-
禁止指令重排(有序性,单例模式,CAS ,CPU原语)
原代码->编译器(指令重排)->指令并行重排->内存系统的重排->最终指令顺序
单线程也无法避免指令重排
如何验证?
volatile如何禁止指令重排?
内存屏障(Memory Barrier):CPU的指令
有两个作用:
-
保证特定的执行顺序
会在volatile读的前后增加两道内存屏障(不可见),会禁止前/后的指令跟volatile读指令进行指令重排。
-
保证某些变量的内存可见性
-
单例模式-指令重排的最经典实现
单例模式的终极思想:构造器私有!
饿汉式
//饿汉式
//先new好对象,但是占空间,不建议使用
public class Hungry {
private Hungry(){}
private static Hungry h = new Hungry();
public static Hungry getInstance(){
return h;
}
}
懒汉式
//懒汉式
//单线程可用,但多线程下会失效;
public class Lazy {
private Lazy(){}
private static Lazy lazy;
public static Lazy getInstance(){
if(null==lazy) {
lazy = new Lazy();
}
return lazy;
}
}
懒汉式-多线程版
//懒汉式-多线程
public class Lazy {
private Lazy(){}
//防止指令重排导致的线程不安全
private volatile static Lazy lazy;
//DCL 双重检测锁
public static Lazy getInstance(){
if(null==lazy) {
synchronized (Lazy.class) {
if(null==lazy) { //dc
//java创建对象分3步
//1.分配内存空间
//2.执行构造方法,创建对象
//3.将对象指向空间
//没有volatile ,如果指令重排,先执行1.3, 那么拿到对象后会发现,是一个空对象。
lazy = new Lazy();
}
}
}
return lazy;
}
//但是可以通过反射破坏构造器
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor();
declaredConstructor.setAccessible(true);//通过反射破坏私有构造器
Lazy lazy1 = declaredConstructor.newInstance();//然后就可以新建实例
Lazy lazy2 = declaredConstructor.newInstance();//然后就可以新建实例
}
}
懒汉式-终极进阶版(防止反射破坏私有构造器)
上一个版本中,通过反射的方式破坏了私有构造器,从而破解了单例模式,这里可以使用一个不公开的变量来防止破解(只要不被反编译源码)
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
//懒汉式-多线程
public class Lazy {
//增加一个参数用于控制单例,只要不被反编译代码,就能保证单例安全。
private static boolean askdmalskndmlkasnd = true;
private Lazy(){
synchronized (Lazy.class){
if(askdmalskndmlkasnd){
askdmalskndmlkasnd =false;
}else{
throw new RuntimeException("不要瞎搞反射,骚年,你破不了的");
}
}
}
//防止指令重排导致的线程不安全
private volatile static Lazy lazy;
//DCL 双重检测锁
public static Lazy getInstance(){
if(null==lazy) {
synchronized (Lazy.class) {
if(null==lazy) { //dc
//java创建对象分3步
//1.分配内存空间
//2.执行构造方法,创建对象
//3.将对象指向空间
//没有volatile ,如果指令重排,先执行1.3, 那么拿到对象后会发现,是一个空对象。
lazy = new Lazy();
}
}
}
return lazy;
}
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor();
declaredConstructor.setAccessible(true);//通过反射破坏私有构造器
Field askdmalskndmlkasnd = Lazy.class.getDeclaredField("askdmalskndmlkasnd");//如果反编译了源码发现了这个参数,那么也能根据反射获取并修改这个参数
askdmalskndmlkasnd.setAccessible(true);
Lazy lazy1 = declaredConstructor.newInstance();//然后就可以新建实例
askdmalskndmlkasnd.set(lazy1,true);//lazy1实例化后,又把这个参数改成true,从而又破坏了单例
Lazy lazy2 = declaredConstructor.newInstance();//然后就可以新建实例
}
但是,还是会有破坏!不是绝对安全的
终极版 ENUM枚举类单例模式
public enum EnumTest {
INSTANCE;
public EnumTest getInstance(){
return INSTANCE;
}
//破坏不了枚举的单例模式,除非改jdk
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor();
declaredConstructor.setAccessible(true);//通过反射破坏私有构造器
Lazy lazy1 = declaredConstructor.newInstance();//然后就可以新建实例
Lazy lazy2 = declaredConstructor.newInstance();//然后就可以新建实例
}
}
CAS 理念
Compare and Set 比较并交换
比较过当前值与期望值,若一致,才做变更的操作。
以原子类为例:AtomicInteger,
有一个方法getAndIncrement();其底层调用了unsafe类的getAndAddInt(this,valueOffset,1); 是直接对内存操作的。
将对象的属性的当前值得内存地址拿出来传入方法,在方法中再次根据该内存地址再次获取值,与传进来的值对比。只有当这个值与最新拿出来的值相比,如果相同则+1,不同则重复上一步查询的操作(自旋锁)。
<将源码截取出来说明>
原子引用:解决ABA问题
ABA问题
A拿到一个值m=5 ,他准备操作的时候,m被B改成了20,然后又把它改成了5,然后A操作的时候,m还是5,但是已经被B改过了。但是A不知道。
原子引用解决ABA问题
总结:加个版本号,每次操作就要给版本号+1;
如何排查死锁
1.获取当前运行的java进程号 jps -l
2.查看信息 jstack 进程号