1、JMM
JMM : Java内存模型,不存在的东西,概念!约定!
关于JMM的一些同步的约定:
1、线程解锁前,必须把共享变量立刻刷回主存。
2、线程加锁前,必须读取主存中的最新值到工作内存中!
3、加锁和解锁是同一把锁
内存交互操作有8种,虚拟机实现必须保证每一个操作都是原子的,不可在分的(对于double和long类型的变量来说,load、store、read和write操作在某些平台上允许例外)
-
lock (锁定):作用于主内存的变量,把一个变量标识为线程独占状态
-
unlock (解锁):作用于主内存的变量,它把一个处于锁定状态的变量释放出来,释放后的变量才可以被其他线程锁定
-
read (读取):作用于主内存变量,它把一个变量的值从主内存传输到线程的工作内存中,以便随后的load动作使用
-
load (载入):作用于工作内存的变量,它把read操作从主存中变量放入工作内存中
-
use (使用):作用于工作内存中的变量,它把工作内存中的变量传输给执行引擎,每当虚拟机遇到一个需要使用到变量的值,就会使用到这个指令assign (赋值):作用于工作内存中的变量,它把一个从执行引擎中接受到的值放入工作内存的变量副本中
-
store (存储):作用于主内存中的变量,它把一个从工作内存中一个变量的值传送到主内存中,以便后续的write使用
-
write (写入):作用于主内存中的变量,它把store操作从工作内存中得到的变量的值放入主内存的变量中
JMM对这八种指令的使用,制定了如下规则:
-
不允许read和load、store和write操作之一单独出现。即使用了read必须load,使用了store必须write
-
不允许线程丢弃他最近的assign操作,即工作变量的数据改变了之后,必须告知主存
-
不允许一个线程将没有assign的数据从工作内存同步回主内存
-
一个新的变量必须在主内存中诞生,不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前,必须经过assign和load操作
-
一个变量同一时间只有一个线程能对其进行lock。多次lock后,必须执行相同次数的unlock才能解锁
-
如果对一个变量进行lock操作,会清空所有工作内存中此变量的值,在执行引擎使用这个变量前,必须重新load或assign操作初始化变量的值
-
如果一个变量没有被lock,就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
-
对一个变量进行unlock操作之前,必须把此变量同步回主内存
public class JMMDemo {
private static int num = 0;
public static void main(String[] args) {
new Thread(() -> {
while (num == 0) {
//线程的工作空间不知道主内存的值发生的变化,所以不会停
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
num = 1; // main线程修改了数据
System.out.println(num);
}
}
2、Volatile
Volatile 是 Java 虚拟机提供轻量级的同步机制
1、保证可见性
2、不保证原子性
3、禁止指令重排
2.1、保证可见性
public class JMMDemo {
// 不加 volatile 程序就会死循环!
// 加 volatile 可以保证可见性,也就是线程能看到主存中该值的变化
private volatile static int num = 0;
public static void main(String[] args) {
new Thread(() -> {
while (num == 0) {
//线程的工作空间不知道主内存的值发生的变化,所以不会停
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
num = 1; // main线程修改了数据
System.out.println(num);
}
}
2.2、不保证原子性
原子性 : 不可分割,比如线程A在执行任务的时候,不能被打扰的,也不能被分割。要么同时成功,要么同时失败。
public class VolatileDemo {
// volatile 不保证原子性
private volatile static int num = 0;
public static void add() {
num++; // 不是原子性操作
}
public static void main(String[] args) {
//理论上num结果应该为 2 万
for (int i = 0; i < 20; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount() > 2) {
// main gc
Thread.yield();
}
System.out.println(Thread.currentThread().getName() + " " + num);
}
}
通过反编译发现 num++ 在内存中有三行操作,如果不加Lock 和 Synchronized,怎么保证原子性?
- 使用原子类,解决原子性问题
private volatile static AtomicInteger num = new AtomicInteger();
public static void add() {
num.getAndIncrement(); // 原子类的自加操作,保证原子性
}
这些类的底层都直接和操作系统挂钩!在内存中修改值!Unsafe类是一个很特殊的存在!
2.3、指令重排
指令重排:你写的程序,计算机并不是按照你写的那样去执行的。
源代码–>编译器优化的重排–> 指令并行也可能会重排–> 内存系统也会重排—> 执行
volatile可以避免指令重排:
内存屏障。CPU指令。作用:
1、保证特定的操作的执行顺序!
2、可以保证某些变量的内存可见性 (利用这些特性volatile实现了可见性)
Volatile 是可以保持 可见性。不能保证原子性,由于内存屏障,可以保证避免指令重排现象的产生!
3、彻底玩转单例模式
3.1、饿汉式
// 饿汉式单例
public class Hungry {
// 可能会浪费空间
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
private Hungry() {
///私有化构造器,阻止外部直接实例化对象
}
// 先new出对象,就能保证对象唯一
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance() {
return HUNGRY;
}
}
3.2、DCL 懒汉式
// 懒汉式单例,创建对象不是原子性操作,需要volatile防止指令重排
public class Lazy {
private Lazy() {
System.out.println(Thread.currentThread().getName() + " OK");
}
private volatile static Lazy lazy; //第二层锁,volatile关键字禁止指令重排
// 双重检测锁模式的 懒汉式单例 DCL懒汉式
public static Lazy getInstance() {
if (lazy == null) {
//第一层检查,检查是否有引用指向对象,高并发情况下会有多个线程同时进入
synchronized (Lazy.class) {
//第一层锁,保证只有一个线程进入
//双重检查,防止多个线程同时进入第一层检查(因单例模式只允许存在一个对象,故在创建对象之前无引用指向对象,所有线程均可进入第一层检查)
//当某一线程获得锁创建一个Singleton对象时,即已有引用指向对象,singleton不为空,从而保证只会创建一个对象
//假设没有第二层检查,那么第一个线程创建完对象释放锁后,后面进入对象也会创建对象,会产生多个对象
if (lazy == null) {
//第二层检查
lazy = new Lazy();
//lazy = new Lazy();语句为非原子性,实际上会执行以下内容:
//(1)在堆上开辟空间;(2)属性初始化;(3)引用指向对象
//假设以上三个内容为三条单独指令,因指令重排可能会导致执行顺序为1->3->2
}
}
}
return lazy; //单线程可以
}
// 多线程并发会破坏
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
Lazy.getInstance();
}).start();
}
}
}
3.3、枚举
// enum 是一个什么? 本身也是一个Class类
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance() {
return INSTANCE;
}
}
class Test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
EnumSingle instance1 = EnumSingle.INSTANCE;
Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
constructor.setAccessible(true);
EnumSingle instance2 = constructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
// Cannot reflectively create enum objects
// 反射不能破坏枚举的单例模式
}
}
枚举类型的最终反编译源码:
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: EnumSingle.java
package com.kuang.single;
public final class EnumSingle extends Enum {
public static EnumSingle[] values() {
return (EnumSingle[]) $VALUES.clone();
}
public static EnumSingle valueOf(String name) {
return (EnumSingle) Enum.valueOf(com / kuang / single / EnumSingle, name);
}
private EnumSingle(String s, int i) {
super(s, i);
}
public EnumSingle getInstance() {
return INSTANCE;
}
public static final EnumSingle INSTANCE;
private static final EnumSingle $VALUES[];
static {
INSTANCE = new EnumSingle("INSTANCE", 0);
$VALUES = (new EnumSingle[]{
INSTANCE
});
}
}
4、深入理解CAS
public class CASDemo {
// CAS compareAndSet:比较并交换!
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
// public final boolean compareAndSet(int expect, int update)
// 如果我期望的值达到了,那么就更新,否则,就不更新, CAS 是CPU的并发原语!
atomicInteger.compareAndSet(2020, 2021);
atomicInteger.getAndIncrement();
System.out.println(atomicInteger.get());
}
}
4.1、Unsafe类
CAS : 比较当前工作内存中的值和主内存中的值,如果这个值是期望的,那么则执行操作!如果不是就一直循环!
缺点:
1、 循环会耗时
2、一次性只能保证一个共享变量的原子性
3、ABA问题
4.2、ABA问题(狸猫换太子)
public class CASDemo {
// CAS compareAndSet:比较并交换!
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
// public final boolean compareAndSet(int expect, int update)
// 如果我期望的值达到了,那么就更新,否则,就不更新, CAS 是CPU的并发原语!
//======================捣乱的线程==========================
atomicInteger.compareAndSet(2020, 2021);
System.out.println(atomicInteger.get());
atomicInteger.compareAndSet(2021, 2020);
System.out.println(atomicInteger.get());
//======================期望的线程==========================
atomicInteger.compareAndSet(2020, 666);
System.out.println(atomicInteger.get());
}
}
解决:原子引用
5、原子引用
解决ABA 问题,引入原子引用! 对应的思想:乐观锁!
带版本号 的原子操作!
public class CASDemo {
// CAS compareAndSet:比较并交换!
static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);
public static void main(String[] args) {
new Thread(() -> {
int stamp = atomicStampedReference.getStamp();
System.out.println("a1=>"+stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicStampedReference.compareAndSet(1, 2,
atomicStampedReference.getStamp(), atomicStampedReference.getStamp() +1);
System.out.println("a2=>"+atomicStampedReference.getStamp());
System.out.println(atomicStampedReference.compareAndSet(2, 1,
atomicStampedReference.getStamp(),
atomicStampedReference.getStamp() + 1));
System.out.println("a3=>"+atomicStampedReference.getStamp());
}, "a").start();
// 乐观锁的原理相同
new Thread(() -> {
int stamp = atomicStampedReference.getStamp();
System.out.println("b1=>"+stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet(1, 6,
stamp, stamp + 1));
System.out.println("b2=>"+atomicStampedReference.getStamp());
}, "b").start();
}
}
6、各种锁的理解
6.1、公平锁、非公平锁
公平锁: 非常公平, 不能够插队,必须先来后到!
非公平锁:非常不公平,可以插队 (默认都是非公平)
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
6.2、可重入锁
- Synchronized版
class Phone {
public synchronized void sendMessage() throws InterruptedException {
System.out.println(Thread.currentThread().getName() + "发短信");
TimeUnit.SECONDS.sleep(2);
call(); //拿到外面的锁就自动获得里面的锁
}
public synchronized void call() {
System.out.println(Thread.currentThread().getName() + "打电话");
}
}
public class SynchronizedDemo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
try {
phone.sendMessage();
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
phone.call();
}, "B").start();
}
}
- Lock版
class Phone2 {
Lock lock = new ReentrantLock();
public void sendMessage() throws InterruptedException {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "发短信");
TimeUnit.SECONDS.sleep(2);
call(); //拿到外面的锁就自动获得里面的锁
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void call() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "打电话");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public class SynchronizedDemo {
public static void main(String[] args) {
Phone2 phone = new Phone2();
new Thread(() -> {
try {
phone.sendMessage();
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "A").start(); // A发短信
new Thread(() -> {
// A打电话
phone.call(); // B打电话
}, "B").start();
}
}
6.3、自旋锁
- 自定义一个锁测试,使用CAS
public class SpinLockDemo {
// int 0
// Thread null
AtomicReference<Thread> atomicReference = new AtomicReference<>();
// 加锁
public void myLock() {
Thread thread = Thread.currentThread(); // 获得当前线程
System.out.println(Thread.currentThread().getName() + "被myLock锁住了");
// 自旋锁
do {
}while (!atomicReference.compareAndSet(null, thread)); // 上面线程存在就是死循环
}
//解锁
public void myUnLock() {
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName() + "被myUnLock解锁了");
atomicReference.compareAndSet(thread, null); // 置为null就破坏了自旋锁
}
}
- 测试
public class Test {
public static void main(String[] args) {
// ReentrantLock reentrantLock = new ReentrantLock();
// reentrantLock.lock();
// reentrantLock.unlock();
// 底层使用的自旋锁CAS
SpinLockDemo lock = new SpinLockDemo();
new Thread(() -> {
lock.myLock();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.myUnLock();
}
}, "A").start();
new Thread(() -> {
lock.myLock();
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.myUnLock();
}
}, "B").start();
}
}
6.4、死锁
class MyThread implements Runnable {
private String lockA;
private String lockB;
public MyThread(String lockA, String lockB) {
this.lockA = lockA;
this.lockB = lockB;
}
@Override
public void run() {
synchronized (lockA) {
System.out.println(Thread.currentThread().getName() +
"lock:" + lockA + "=>get" + lockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB) {
System.out.println(Thread.currentThread().getName() +
"lock:" + lockB + "=>get" + lockA);
}
}
}
}
public class DeadLock {
public static void main(String[] args) {
String lockA = "lockA";
String lockB = "lockB";
new Thread(new MyThread(lockA, lockB), "T1").start();
new Thread(new MyThread(lockB, lockA), "T2").start();
}
}
- 解决问题
1、使用 jsp -l 定位进程号
2、使用 jstack 进程号 找到死锁问题