死锁简要笔记 死锁死锁测试实例：package com.sw.lock; import java.util.concurrent.TimeUnit; /** * @Author suaxi * @Date 2021/2/22 23:48 * 死锁Demo */ public class DeadLockTest { public static void main(String[] args) { String lockA = "lockA"; String lockB = "lockB"; new Thread(new DeadLock(lockA,lockB),"A").start(); new Thread(new DeadLock(lockB,lockA),"B").start(); } } class DeadLock implements Runnable{ private String lockA; private String lockB; public DeadLock(String lockA, String lockB) { this.lockA = lockA; this.lockB = lockB; } @Override public void run() { synchronized (lockA){ System.out.println(Thread.currentThread().getName()+"--->现在的锁是:"+lockA+"，想获取的资源是："+lockB); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lockB){ System.out.println(Thread.currentThread().getName()+"--->现在的锁是:"+lockB+"，想获取的资源是："+lockA); } } } } 解决思路：1、jps -l查看进程号2、jstack 进程号查看具体的死锁信息

自旋锁 自旋锁spinlock自定义自旋锁测试实例package com.sw.lock; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; /** * @Author suaxi * @Date 2021/2/22 23:21 * 自定义自旋锁 */ public class SpinLockTest { AtomicReference<Thread> atomicReference = new AtomicReference<>(); //加锁 public void myLock() { Thread thread = Thread.currentThread(); System.out.println(Thread.currentThread().getName() + "--->myLock()"); //自旋锁 while (!atomicReference.compareAndSet(null, thread)) { } } //解锁 public void myUnlock() { Thread thread = Thread.currentThread(); System.out.println(Thread.currentThread().getName() + "--->myUnlock()"); atomicReference.compareAndSet(thread, null); } //测试 public static void main(String[] args) throws InterruptedException { SpinLockTest lock = new SpinLockTest(); new Thread(() -> { lock.myLock(); try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.myUnlock(); } }, "A").start(); TimeUnit.SECONDS.sleep(2); new Thread(() -> { lock.myLock(); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.myUnlock(); } }, "B").start(); /* 执行结果为： A--->myLock() B--->myLock() A--->myUnlock() B--->myUnlock() */ } }

可重入锁 可重入锁可重入锁：打开大门的锁之后也就获得了里面两个房间的锁synchronized版可重入锁package com.sw.lock; /** * @Author suaxi * @Date 2021/2/22 23:07 * synchronized版可重入锁 */ public class Test01 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(() ->{ phone.sms(); },"A").start(); new Thread(() ->{ phone.sms(); },"B").start(); } } class Phone{ public synchronized void sms(){ System.out.println(Thread.currentThread().getName()+"--->sms"); call(); } public synchronized void call(){ System.out.println(Thread.currentThread().getName()+"--->call"); } } lock版可重入锁package com.sw.lock; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @Author suaxi * @Date 2021/2/22 23:07 * lock版可重入锁 */ public class Test02 { public static void main(String[] args) { Phone2 phone = new Phone2(); new Thread(() ->{ phone.sms(); },"A").start(); new Thread(() ->{ phone.sms(); },"B").start(); } } class Phone2{ Lock lock =new ReentrantLock(); public void sms(){ lock.lock(); //lock锁必须配对，否则会产生死锁 try { System.out.println(Thread.currentThread().getName()+"--->sms"); call(); }catch (Exception e){ e.printStackTrace(); }finally { lock.unlock(); } } public void call(){ lock.lock(); try { System.out.println(Thread.currentThread().getName()+"--->call"); }catch (Exception e){ e.printStackTrace(); }finally { lock.unlock(); } } }

原子引用 原子引用原子引用解决ABA问题，解决思路：乐观锁package com.sw.cas; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicStampedReference; /** * @Author suaxi * @Date 2021/2/21 21:29 * 原子引用解决ABA问题 */ public class casTest01 { static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(5, 1); public static void main(String[] args) { new Thread(() ->{ int stamp = atomicStampedReference.getStamp(); System.out.println("A1--->"+stamp); try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(atomicStampedReference.compareAndSet(5, 6, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1)); System.out.println("A2--->"+atomicStampedReference.getStamp()); System.out.println(atomicStampedReference.compareAndSet(6, 5, 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(5, 10, stamp, stamp + 1)); System.out.println("B2--->"+atomicStampedReference.getStamp()); },"B").start(); } } Integer包装类补充：

CompareAndSet(CAS) CompareAndSet(CAS)CASCAS：比较并交换package com.sw.cas; import java.util.concurrent.atomic.AtomicInteger; /** * @Author suaxi * @Date 2021/2/21 20:58 * CAS:比较并交换 */ public class casTest { public static void main(String[] args) { AtomicInteger atomicInteger = new AtomicInteger(2021); //如果达到期望的值，就更新，否则反之 System.out.println(atomicInteger.compareAndSet(2021,666)); //true System.out.println(atomicInteger.get()); //666 } } Unsafe图片来源：狂神说Java缺点：1、循环会耗时2、一次循环只能保证一个共享变量的原子性3、ABA问题ABA问题package com.sw.cas; import java.util.concurrent.atomic.AtomicInteger; /** * @Author suaxi * @Date 2021/2/21 20:58 * CAS:比较并交换 */ public class casTest { public static void main(String[] args) { AtomicInteger atomicInteger = new AtomicInteger(2021); //如果达到期望的值，就更新，否则反之 //捣乱的线程 System.out.println(atomicInteger.compareAndSet(2021,666)); //true System.out.println(atomicInteger.get()); //666 System.out.println(atomicInteger.compareAndSet(666,2021)); System.out.println(atomicInteger.get()); //期望的线程 System.out.println(atomicInteger.compareAndSet(2021, 888)); System.out.println(atomicInteger.get()); } }

单例模式 单例模式饿汉式package com.sw.single; /** * @Author suaxi * @Date 2021/2/21 18:57 * 饿汉式单例 */ 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(){ } private final static Hungry hungry = new Hungry(); public static Hungry getHungry() { return hungry; } } 懒汉式package com.sw.single; import java.lang.reflect.Constructor; import java.lang.reflect.Field; /** * @Author suaxi * @Date 2021/2/21 18:59 * 懒汉式单例 */ public class Lazy { //通过私有参数保证单例模式的安全 private static boolean flag = false; private Lazy() { synchronized (Lazy.class){ if (flag == false){ flag = true; }else { throw new RuntimeException("不要试图使用反射破环单例模式"); } } System.out.println(Thread.currentThread().getName() + " ok"); } private volatile static Lazy lazy; //双重检测锁模式的 懒汉式单例 DCL懒汉式 public static Lazy getInstance(){ if (lazy == null){ synchronized (Lazy.class){ if (lazy == null){ lazy = new Lazy(); //不是一个原子性操作 /* 不是一个原子性操作，可能存在问题 new 对象的过程： 1、分配内存空间 2、执行构造方法。初始化对象 3、把对象指向这个空间 一般来说的执行过程 123 132 A 可能出现指令重排 B B线程执行时，由于A线程中的指令重排导致的问题，此时Lazy还没有完成构造 解决办法：volatile */ } } } return lazy; } //多线程并发 // public static void main(String[] args) { // for (int i = 0; i < 10; i++) { // new Thread(() ->{ // Lazy.getInstance(); // }).start(); // } // } //反射 可以破环单例模式 public static void main(String[] args) throws Exception { //Lazy instance01 = Lazy.getInstance(); //第一次 //第三次，通过反射获取私有字段flag Field flag = Lazy.class.getDeclaredField("flag"); flag.setAccessible(true); Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null); declaredConstructor.setAccessible(true); //无视私有构造 //第二次，两个对象都通过以下方式构造，又破坏了三重检测锁的单例模式 Lazy instance01 = declaredConstructor.newInstance(); flag.set(instance01,false); //此处又破坏了 Lazy instance02 = declaredConstructor.newInstance(); System.out.println(instance01); //com.sw.single.Lazy@74a14482 System.out.println(instance02); //com.sw.single.Lazy@1540e19d } /* 1、第一次破环单例模式，通过反射创建instance对象 2、加上三重检测锁，又通过全部使用反射创建对象来破坏（第二次） 3、设置私有变量 flag，通过反射获取私有变量字段，又破坏了单例 */ } 静态内部类package com.sw.single; /** * @Author suaxi * @Date 2021/2/21 19:48 * 静态内部类 */ public class Holder { private Holder(){ } public static Holder getInstance(){ return InnerClass.holder; } public static class InnerClass{ private static final Holder holder = new Holder(); } } 枚举package com.sw.single; import java.lang.reflect.Constructor; /** * @Author suaxi * @Date 2021/2/21 20:10 */ public enum EnumSingle { INSTANCE; public EnumSingle getInstance(){ return INSTANCE; } } class Test{ public static void main(String[] args) throws Exception { EnumSingle instance01 = EnumSingle.INSTANCE; Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class); declaredConstructor.setAccessible(true); EnumSingle instance02 = declaredConstructor.newInstance(); //获取空参的反射报错 没有无参构造器 // java.lang.NoSuchMethodException: com.sw.single.EnumSingle.<init>() //EnumSingle.class.getDeclaredConstructor(String.class,int.class); //报错 java.lang.IllegalArgumentException: Cannot reflectively create enum objects //反射不能破坏枚举 System.out.println(instance01 == instance02); } } 注:需通过jad反编译，EnumSingle.class.getDeclaredConstructor(String.class,int.class);反射获取有参构造才能得出java.lang.IllegalArgumentException: Cannot reflectively create enum objects（反射不能破坏枚举），常规的通过反射获取无参构造只会报错java.lang.NoSuchMethodException

Volatile Volatile1、保证可见性package com.sw.volatileDemo; import java.util.concurrent.TimeUnit; /** * @Author suaxi * @Date 2021/2/19 22:07 */ public class JMMTest { //不加volatile程序会死循环 //加上volatile保证了可见性 private volatile static int num = 0; public static void main(String[] args) { //main线程 new Thread(() ->{ //线程1 while (num == 0){ } }).start(); try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } num = 1; System.out.println(num); //输出num=1，main线程将num改为1后，线程1还在循环while(num == 0) } } 2、不保证原子性原子性：任务在执行的过程中不能被分割，也不能被干扰，一组操作要么都成功，要么都失败不保证原子性测试实例：package com.sw.volatileDemo; /** * @Author suaxi * @Date 2021/2/19 22:25 * volatile不保证原子性 */ public class VolatileTest01 { private volatile static int num = 0; public static void add() { num++; } public static void main(String[] args) { for (int i = 0; i < 20; i++) { new Thread(() ->{ for (int j = 0; j < 1000; j++) { //理论上默认相加的结果等于2000 add(); } }).start(); } while (Thread.activeCount() > 2){ //Java中main线程和gc线程默认运行 Thread.yield(); } System.out.println(Thread.currentThread().getName()+" "+num); //19359 //18089 //不使用锁的实际相加的情况不等于2000 //volatile不保证原子性 } } 如何在不使用synchronized和lock锁的情况下保证原子性？图片来源：狂神说Java答：使用原子类解决package com.sw.volatileDemo; import java.util.concurrent.atomic.AtomicInteger; /** * @Author suaxi * @Date 2021/2/19 22:25 * volatile不保证原子性 * 使用Atomic原子类解决原子性问题 */ public class VolatileTest02 { private volatile static AtomicInteger num = new AtomicInteger(); public static void add() { //num++; num.getAndIncrement(); //AtomicInteger中的 +1 方法 } public static void main(String[] args) { for (int i = 0; i < 20; i++) { new Thread(() ->{ for (int j = 0; j < 1000; j++) { //理论上默认相加的结果等于2000 add(); } }).start(); } while (Thread.activeCount() > 2){ //Java中main线程和gc线程默认运行 Thread.yield(); } System.out.println(Thread.currentThread().getName()+" "+num); } } 3、禁止指令重排指令重排：源代码 ---> 编译器优化的重排 ---> 指令并行也可能会重排 ---> 执行假设x y a b四个数的默认值为0线程1线程2x = ay = bb = 1a = 2正常的执行结果为：x=0,y=0线程1线程2b = 1a = 2x = ay = b指令重排可能导致的结果：x =2，y=1Volatile可以避免指令重排：内存屏障，作用：1、保证操作的执行顺序2、保证某些变量的内存可见性

JMM JMMvolatilevolatile是Java虚拟机提供的轻量级同步机制它的三个特性：保证可见性不保证原子性禁止指令重排JMM相关的一些同步约定：1、线程解锁前，必须把共享变量立刻刷回主存2、线程加锁前，必须读取主存中的最新值到工作内存中3、加锁和解锁是同一把锁不保证原子性的测试实例：package com.sw.volatileDemo; import java.util.concurrent.TimeUnit; /** * @Author suaxi * @Date 2021/2/19 22:07 */ public class JMMTest { private static int num = 0; public static void main(String[] args) { //main线程 new Thread(() ->{ //线程1 while (num == 0){ } }).start(); try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } num = 1; System.out.println(num); //输出num=1，main线程将num改为1后，线程1还在循环while(num == 0) } } 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之前，必须把此变量同步回主内存