• JMM与JUC

    1.JMM

    问题1：请你谈谈你对Volatile的理解

    Volatile 是java虚拟机提供轻量级的同步机制

    1. 保证可见性

    2. 不保证原子性

    3. 禁止指令重排

    1.1、什么是JMM

    JMM Java内存模型  不存在的东西，概念！约定 ！

    1.2、关于JMM的一些同步的约定：

    1、线程解锁前，必须把共享变量立刻刷回主存，

    2、线程枷锁前，必须读取主存中的最新值到工作内存中

    3、加锁和解锁的是同一把锁

    线程工作内存，主内存。store和write换一个位置

    2.Volatile

    2.1.保证可见性

    1. package com.kuang.tvolatile;
    2.  
    3. import java.util.concurrent.TimeUnit;
    4.  
    5. public class Demo01 {
    6.     //不加volatile ，程序就会陷入死循环，加了保证主内存的可见性
    7.     public volatile static int num=0;
    8.  
    9.     public static void main(String[] args) {
    10.         new Thread(()->{//线程对主内存的num值的变化是不知道的
    11.             while (num==0){
    12.  
    13.             }
    14.             System.out.println(num);
    15.         }).start();
    16.  
    17.  
    18.         try {
    19.             TimeUnit.SECONDS.sleep(2);
    20.         } catch (InterruptedException e) {
    21.             e.printStackTrace();
    22.         }
    23.         num=1;
    24.         System.out.println(num);
    25.  
    26.     }
    27. }

    2.2不保证原子性

    1. package com.kuang.tvolatile;
    2.  
    3. import java.util.concurrent.BlockingQueue;
    4. import java.util.concurrent.locks.Lock;
    5. import java.util.concurrent.locks.ReentrantLock;
    6.  
    7. //不保证原子性
    8. public class Demo02 {
    9.   //volatile不保证原子性
    10.     private volatile static int num=0;
    11.  
    12. //改变就会重新加载主存的值，不改变就存一次到工作内存，工作内存相当于线程私有的栈帧，先这么理解
    13.     public  static void  add(){
    14.             num++;
    15.     }
    16. //    public   void  add1(){
    17. //        lock.lock();
    18. //        try {
    19. //            num++;
    20. //        } catch (Exception e) {
    21. //            e.printStackTrace();
    22. //        } finally {
    23. //            lock.unlock();
    24. //        }
    25. //    }
    26.  
    27.     public static void main(String[] args) {
    28.         //理论上num结果应该为两万
    29.         for (int i = 0; i < 20; i++) {
    30.             new Thread(()->{
    31.                 for (int j = 0; j < 1000; j++) {
    32.                     add();
    33.                 }
    34.             }).start();
    35.         }
    36. //        Demo02 demo02 = new Demo02();
    37. //        for (int i = 0; i < 10; i++) {
    38. //            new Thread(()->{
    39. //                for (int j = 0; j < 1000; j++) {
    40. //                  demo02.add1();
    41. //                }
    42. //            }).start();
    43. //        }
    44.  
    45.         while (Thread.activeCount()>2){//main gc
    46.             Thread.yield();
    47.         }
    48.  
    49.         System.out.println(Thread.currentThread().getName()+"   "+num);
    50.  
    51.     }
    52.  
    53.  
    54.  
    55. }

    如果不加lock和synchronized，怎么样保证原子性?

    使用原子类，解决原子性问题

    1. package com.kuang.tvolatile;
    2.  
    3. import java.util.concurrent.BlockingQueue;
    4. import java.util.concurrent.atomic.AtomicInteger;
    5. import java.util.concurrent.locks.Lock;
    6. import java.util.concurrent.locks.ReentrantLock;
    7.  
    8. //不保证原子性
    9. public class Demo02 {
    10.   //volatile不保证原子性
    11. //    private volatile static int num=0;
    12.   public volatile static AtomicInteger num=new AtomicInteger();
    13. //改变就会重新加载主存的值，不改变就存一次到工作内存，工作内存相当于线程私有的栈帧，先这么理解
    14.     public  static void  add(){
    15.             num.getAndIncrement();//AtomicInterger+1方法,CAS
    16.     }
    17. //    public   void  add1(){
    18. //        lock.lock();
    19. //        try {
    20. //            num++;
    21. //        } catch (Exception e) {
    22. //            e.printStackTrace();
    23. //        } finally {
    24. //            lock.unlock();
    25. //        }
    26. //    }
    27.  
    28.     public static void main(String[] args) {
    29.         //理论上num结果应该为两万
    30.         for (int i = 0; i < 20; i++) {
    31.             new Thread(()->{
    32.                 for (int j = 0; j < 1000; j++) {
    33.                     add();
    34.                 }
    35.             }).start();
    36.         }
    37. //        Demo02 demo02 = new Demo02();
    38. //        for (int i = 0; i < 10; i++) {
    39. //            new Thread(()->{
    40. //                for (int j = 0; j < 1000; j++) {
    41. //                  demo02.add1();
    42. //                }
    43. //            }).start();
    44. //        }
    45.  
    46.         while (Thread.activeCount()>2){//main gc
    47.             Thread.yield();//Thread.yield() 方法是Java中的一个静态方法，用于提示调度程序当前线程愿意放弃其当前时间片。
    48.             // 换句话说，它建议线程愿意暂停执行并为同一优先级的其他线程提供机会。
    49.         }
    50.  
    51.         System.out.println(Thread.currentThread().getName()+"   "+num);
    52.  
    53.     }
    54.  
    55.  
    56.  
    57. }

    这些类的底层都直接和操作系统直接挂钩 ！在内存中修改值！！！Unsafe类是一个很特殊的存在！

    2.3 、指令重排

    什么是  指令重排: 你写的程序，计算机并不是按照你写的那样去执行的。

    源代码->编译器优化的重排-->指令并行也可能会重排-->内存系统也会重排-->执行

    volatile 是可以保持可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！

    问：volatile在哪里避免指令重排的现象用的最多，在单例模式！！！

    3.彻底玩转单例模式

    饿汉式，DCL懒汉式

    饿汉式

    1. package com.kuang.single;
    2.  
    3. //饿汉式
    4. public class Hungry {
    5.  
    6.     private byte[] bytes1=new byte[1024*1024];
    7.     private byte[] bytes2=new byte[1024*1024];
    8.     private byte[] bytes3=new byte[1024*1024];
    9.     private byte[] bytes4=new byte[1024*1024];
    10.  
    11.  
    12.     private Hungry(){
    13.  
    14.     }
    15.  
    16.     private final static Hungry HUNGRY= new Hungry();
    17.  
    18.  
    19.     public static  Hungry getHungry(){
    20.         return HUNGRY;
    21.     }
    22.  
    23. }

    DCL懒汉式 DCL：双重检测模式

    原子性
    1. package com.kuang.single;
    2. //懒汉式
    3. public class LazyMan {
    4.     private LazyMan(){
    5.         System.out.println(Thread.currentThread().getName()+"ok");
    6.     }
    7.  
    8.     //双重检测锁，volatile内存屏障，防止指令重排，
    9.     private volatile static LazyMan lazyMan;
    10.  
    11.     //双重检测该模式的 懒汉式单例  DCL懒汉式
    12.     public static LazyMan getInstance(){
    13.         if (lazyMan==null){
    14.             synchronized (LazyMan.class){
    15.                 if (lazyMan==null){
    16.                     lazyMan=new LazyMan();//不是一个原子性操作
    17.                     /**
    18.                      * 1.分配内存空间
    19.                      * 2.执行构造方法，初始化对象
    20.                      * 3.把这个对象指向这个空间
    21.                      *
    22.                      * 2和3的顺序，在指令重排的时候
    23.                      */
    24.                 }
    25.                 //外面那一层判断空 是因为可以减少同步的时间，不会全部同步在锁当中，而一部分代码会因为不为空而直接获取对象。
    26.  
    27.  
    28.             }
    29.         }
    30.         return lazyMan;
    31.     }
    32.  
    33.     //多线程并发
    34.     public static void main(String[] args) {
    35.         for (int i = 0; i < 10; i++) {
    36.             new Thread(()->{
    37.                 LazyMan.getInstance();
    38.             }).start();
    39.         }
    40.     }
    41.  
    42.  
    43.  
    44.  
    45. }

    静态内部类

    1. package com.kuang.single;
    2. //静态内部类
    3. public class Holder {
    4.     private Holder(){
    5.         
    6.     }
    7.  
    8.     public static Holder getInstance(){
    9.         return InnerClass.HOLDER;
    10.     }
    11.  
    12.     public static class InnerClass{
    13.             private static final Holder HOLDER=new Holder();
    14.     }
    15.  
    16.  
    17.  
    18.  
    19. }

    进阶

    1. package com.kuang.single;
    2.  
    3. import java.lang.reflect.Constructor;
    4. import java.lang.reflect.Field;
    5.  
    6. //懒汉式
    7. //道高一尺魔高一丈
    8. public class LazyMan {
    9.  
    10.     private static boolean qingjiang=false;
    11.  
    12.     private LazyMan(){
    13.         synchronized (LazyMan.class){
    14.             if (qingjiang==false){
    15.                 qingjiang=true;
    16.             }else {
    17.                 throw  new RuntimeException("不要尝试反射破坏单例模式");
    18.             }
    19.  
    20.  
    21.         }
    22.  
    23.     }
    24.  
    25.     //双重检测锁，原子性，volatile内存屏障，防止指令重排，
    26.     private volatile static LazyMan lazyMan;
    27.  
    28.     //双重检测该模式的 懒汉式单例  DCL懒汉式
    29.     public static LazyMan getInstance(){
    30.         if (lazyMan==null){
    31.             synchronized (LazyMan.class){
    32.                 if (lazyMan==null){
    33.                     lazyMan=new LazyMan();//不是一个原子性操作
    34.                     /**
    35.                      * 1.分配内存空间
    36.                      * 2.执行构造方法，初始化对象
    37.                      * 3.把这个对象指向这个空间
    38.                      *
    39.                      * 2和3的顺序，在指令重排的时候
    40.                      */
    41.                 }
    42.                 //外面那一层判断空 是因为可以减少同步的时间，不会全部同步在锁当中，而一部分代码会因为不为空而直接获取对象。
    43.  
    44.  
    45.             }
    46.         }
    47.         return lazyMan;
    48.     }
    49.  
    50.     //多线程并发
    51. //    public static void main(String[] args) {
    52. //        for (int i = 0; i < 10; i++) {
    53. //            new Thread(()->{
    54. //                LazyMan.getInstance();
    55. //            }).start();
    56. //        }
    57. //    }
    58.  
    59.     public static void main(String[] args) throws Exception {
    60. //        LazyMan instance = LazyMan.getInstance();
    61.  
    62.         Field qingjiang = LazyMan.class.getDeclaredField("qingjiang");
    63.         qingjiang.setAccessible(true);
    64.  
    65.         Constructorextends LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
    66.         constructor.setAccessible(true);
    67.         LazyMan instance2 = constructor.newInstance();
    68.        qingjiang.set(constructor,false);
    69.         LazyMan instance = constructor.newInstance();
    70.         System.out.println(instance);
    71.         System.out.println(instance2);
    72.  
    73.  
    74.     }
    75.  
    76.  
    77. }

     

     

     

     反射无法破坏枚举

    枚举在运行时没有无参构造，但是有一个有参构造，反射拿无参，会抛没有更多的方法

    反射拿有参构造，则会抛出，

    throw new IllegalArgumentException("Cannot reflectively create enum objects");

     

    4.深入理解CAS

    Unsafe类

     

    5.原子引用

    ABA问题

    1. package com.kuang.cas;
    2.  
    3. import java.util.concurrent.atomic.AtomicInteger;
    4.  
    5. public class CASDemo {
    6.  
    7.  
    8.     //CAS   atomicInteger.compareAndSet()  CAS就是compareAndSet的缩写:比较并交换！
    9.     public static void main(String[] args){
    10.         AtomicInteger atomicInteger=new AtomicInteger(2020);
    11.  
    12.         //对于我们平时写的SQL：乐观锁！
    13.  
    14.         
    15.         //expect期望 update更新
    16.         //public final boolean compareAndSet(int expect, int update)
    17.         //如果我期望的值达到了，那么就更新，否则，就不更新,CAS 是CPU的并发原语！
    18.         //捣乱的线程
    19.         System.out.println(atomicInteger.compareAndSet(2020, 2021));
    20.         System.out.println(atomicInteger.get());
    21.  
    22.         System.out.println(atomicInteger.compareAndSet(2021, 2020));
    23.         System.out.println(atomicInteger.get());
    24.  
    25. //        atomicInteger.getAndIncrement();
    26.  
    27.         //期望的线程
    28.         System.out.println(atomicInteger.compareAndSet(2020, 6666));
    29.         System.out.println(atomicInteger.get());
    30.     }
    31.  
    32.  
    33.  
    34. }

    6.各种锁的理解

     

    1. package com.kuang.cas;
    2.  
    3. import java.util.concurrent.TimeUnit;
    4. import java.util.concurrent.atomic.AtomicInteger;
    5. import java.util.concurrent.atomic.AtomicStampedReference;
    6.  
    7. public class CASDemo {
    8.  
    9.  
    10.     //解决ABA问题，引入原子引用
    11.     //CAS   atomicInteger.compareAndSet()  CAS就是compareAndSet的缩写:比较并交换！
    12.     public static void main(String[] args){
    13. //        AtomicInteger atomicInteger=new AtomicInteger(2020);
    14.         AtomicStampedReference atomic = new AtomicStampedReference<>(1, 1);
    15.  
    16.         new Thread(()->{
    17.             int stamp = atomic.getStamp();//获取当前版本号
    18.             System.out.println("a1=>"+stamp);
    19.             try {
    20.                 TimeUnit.SECONDS.sleep(1);
    21.             } catch (InterruptedException e) {
    22.                 e.printStackTrace();
    23.             }
    24.             System.out.println("a2=>"+atomic.compareAndSet(1, 2, atomic.getStamp(), atomic.getStamp() + 1));
    25.             System.out.println("a3=>"+atomic.compareAndSet(2, 1, atomic.getStamp(), atomic.getStamp() + 1));
    26.  
    27.  
    28.             System.out.println("a4=>"+atomic.getStamp());
    29.         },"a").start();
    30.  
    31.  
    32.         //乐观锁原理是一样的
    33.  
    34.         new Thread(()->{
    35.             int stamp = atomic.getStamp();//获取当前版本号
    36.             System.out.println("b1=>"+stamp);
    37.             try {
    38.                 TimeUnit.SECONDS.sleep(2);
    39.             } catch (InterruptedException e) {
    40.                 e.printStackTrace();
    41.             }
    42.             System.out.println("b1=>"+(atomic.compareAndSet(1, 6, stamp, stamp + 1)));
    43.  
    44.  
    45.             System.out.println("b2=>"+atomic.getStamp());
    46.  
    47.         },"b").start();
    48.  
    49.  
    50.  
    51.  
    52.  
    53.  
    54.  
    55.         //
    56. //        //对于我们平时写的SQL：乐观锁！
    57. //
    58. //
    59. //        //expect期望 update更新
    60. //        //public final boolean compareAndSet(int expect, int update)
    61. //        //如果我期望的值达到了，那么就更新，否则，就不更新,CAS 是CPU的并发原语！
    62. //        //捣乱的线程
    63. //        System.out.println(atomicInteger.compareAndSet(2020, 2021));
    64. //        System.out.println(atomicInteger.get());
    65. //
    66. //        System.out.println(atomicInteger.compareAndSet(2021, 2020));
    67. //        System.out.println(atomicInteger.get());
    68. //
    69.         atomicInteger.getAndIncrement();
    70. //
    71. //        //期望的线程
    72. //        System.out.println(atomicInteger.compareAndSet(2020, 6666));
    73. //        System.out.println(atomicInteger.get());
    74.     }
    75.  
    76.  
    77.  
    78. }

    对应的思想就是:乐观锁

    6.1、公平锁与非公平锁

    6.2、可重入锁

    1. package com.kuang.reelock;
    2.  
    3. //Synchronized
    4. public class Demo01 {
    5.     public static void main(String[] args) {
    6.  
    7.         Phone phone = new Phone();
    8.  
    9.         new Thread(()->{
    10.             phone.sms();
    11.         },"A").start();
    12.         new Thread(()->{
    13.             phone.sms();
    14.         },"B").start();
    15.     }
    16. }
    17.  
    18. class Phone{
    19.  
    20.     public synchronized void sms(){
    21.         System.out.println(Thread.currentThread().getName()+"sms");
    22.         call();//这里也有锁
    23.  
    24.     }
    25.  
    26.     public synchronized void call(){
    27.         System.out.println(Thread.currentThread().getName()+"call");
    28.  
    29.     }
    30.  
    31.  
    32. }

     

    1. package com.kuang.reelock.reelock;
    2.  
    3. import java.util.concurrent.locks.Lock;
    4. import java.util.concurrent.locks.ReentrantLock;
    5.  
    6. //Synchronized
    7. public class Demo02{
    8.     public static void main(String[] args) {
    9.  
    10.         Phone1 phone = new Phone1();
    11.  
    12.         new Thread(()->{
    13.             phone.sms();
    14.         },"A").start();
    15.         new Thread(()->{
    16.             phone.sms();
    17.         },"B").start();
    18.     }
    19. }
    20.  
    21. class Phone1{
    22.  
    23.     Lock lock =new ReentrantLock();
    24.     public  void sms(){
    25.  
    26.         lock.lock();
    27.         lock.lock();
    28.  
    29.         try {
    30.             System.out.println(Thread.currentThread().getName()+"sms");
    31.             call();//这里也有锁
    32.         } catch (Exception e) {
    33.             e.printStackTrace();
    34.         } finally {
    35.             lock.unlock();
    36.             lock.unlock();
    37.         }
    38.  
    39.     }
    40.  
    41.     public  void call(){
    42.         lock.lock();
    43.  
    44.         try {
    45.             System.out.println(Thread.currentThread().getName()+"call");
    46.  
    47.         } catch (Exception e) {
    48.             e.printStackTrace();
    49.         } finally {
    50.             lock.unlock();
    51.  
    52.         }
    53.     }
    54.  
    55.  
    56. }

     

    6.3、自旋锁

    自定义锁

    1. package com.kuang.spinlock;
    2.  
    3. import java.util.concurrent.atomic.AtomicReference;
    4.  
    5. //自旋锁
    6. public class SpinLockDemo {
    7.  
    8.  
    9.     /**
    10.      * int 0
    11.      * Thread null
    12.      */
    13.      AtomicReference atomicReference=new AtomicReference<>();
    14.  
    15.     //加锁
    16.     public void lock(){
    17.         Thread thread = Thread.currentThread();
    18.  
    19.         System.out.println("加锁的是"+thread.getName());
    20.  
    21.         //第一次进来 为null 成功改变，while条件不成立，不自旋，但是条件没有释放，第二次进来，他不是null了。返回false但是取反为true
    22.         //自旋等待解锁
    23.         while (!atomicReference.compareAndSet(null,thread)){
    24.  
    25.         }
    26.  
    27.     }
    28.  
    29.  
    30.  
    31.     //解锁
    32.     public void unlock(){
    33.  
    34.         Thread thread = Thread.currentThread();
    35.         System.out.println("解锁的是"+thread.getName());
    36.         atomicReference.compareAndSet(thread,null);
    37.     }
    38.  
    39.  
    40.     //
    41.  
    42.  
    43. }

    自定义锁测试

    1. package com.kuang.spinlock;
    2.  
    3. import java.util.concurrent.TimeUnit;
    4.  
    5. public class TestDemo {
    6.     public static void main(String[] args) {
    7.         SpinLockDemo spinLockDemo = new SpinLockDemo();
    8.  
    9.         new Thread(()->{
    10.  
    11.             spinLockDemo.lock();
    12.             try {
    13.                 System.out.println(Thread.currentThread().getName()+"执行");
    14.                 TimeUnit.SECONDS.sleep(3);
    15.             } catch (Exception e) {
    16.                 e.printStackTrace();
    17.             } finally {
    18.                 spinLockDemo.unlock();
    19.             }
    20.  
    21.  
    22.         },"A").start();
    23.  
    24.         new Thread(()->{
    25.  
    26.             spinLockDemo.lock();
    27.             try {
    28.                 System.out.println(Thread.currentThread().getName()+"执行");
    29.                 TimeUnit.SECONDS.sleep(1);
    30.             } catch (Exception e) {
    31.                 e.printStackTrace();
    32.             } finally {
    33.                 spinLockDemo.unlock();
    34.             }
    35.  
    36.  
    37.         },"B").start();
    38.     }
    39. }

     

    6.4、死锁

    死锁是多线程或多进程并发执行时可能遇到的一种问题，它具有以下四个必要条件，也被称为死锁的四个特性：

    1. 互斥条件（Mutual Exclusion）：至少有一个资源被多个线程或进程竞争使用，且一次只能被一个线程或进程占用。当一个线程或进程占用了资源，其他线程或进程必须等待该资源释放。

    2. 请求与保持条件（Hold and Wait）：线程或进程在持有至少一个资源的同时，又请求其他线程或进程持有的资源。即线程或进程在等待其他资源时，仍然保持已经占有的资源。

    3. 不可剥夺条件（No Preemption）：已经被一个线程或进程占用的资源不能被其他线程或进程强制性地抢占，只能由占有者主动释放。

    4. 循环等待条件（Circular Wait）：存在一个线程或进程的资源请求序列，使得每个线程或进程都在等待下一个线程或进程所持有的资源。形成一个闭环，导致循环等待。

    当以上四个条件同时满足时，就可能发生死锁。在死锁发生时，线程或进程无法继续执行，导致系统无法正常运行。因此，死锁的四个特性是死锁问题的根本原因，需要通过合理的资源分配和调度策略来避免死锁的发生。

    1. package com.kuang.sisuo;
    2.  
    3. import java.util.concurrent.TimeUnit;
    4.  
    5. public class DeadLockDemo {
    6.     public static void main(String[] args) {
    7.         String A="A";
    8.         String B="B";
    9.  
    10.         new Thread(new MyThread(A,B)).start();
    11.         new Thread(new MyThread(B,A)).start();
    12.  
    13.  
    14.  
    15.     }
    16.  
    17. }
    18.  
    19.  
    20. class MyThread implements Runnable {
    21.  
    22.     private String A;
    23.     private String B;
    24.  
    25.     public MyThread(String a, String b) {
    26.         A = a;
    27.         B = b;
    28.     }
    29.  
    30.     @Override
    31.     public void run() {
    32.         synchronized (A){
    33.             System.out.println(A+"获取"+B);
    34.             try {
    35.                 TimeUnit.SECONDS.sleep(2);
    36.             } catch (InterruptedException e) {
    37.                 e.printStackTrace();
    38.             }
    39.             synchronized (B){
    40.                 System.out.println(B+"获取"+A);
    41.  
    42.             }
    43.  
    44.         }
    45.  
    46.  
    47.  
    48.  
    49.     }
    50. }

    如何解决问题 

    栈：jstack

    堆:  jprofile

    调优 

  • 相关阅读:
    [23年毕业设计源码]精品基于Python实现的仓库库存管理系统[2023届新项目源码]
    天翎BPM流程引擎助力打造流程服务中台
    Vue权限控制
    《C语言程序设计 第4版》笔记和代码 第十一章 指针和数组
    vCenter7.0.0升级到vCenter7.0u3h
    【946. 验证栈序列】
    gorm的增删改查
    代码随想录第41天 | 123.买卖股票的最佳时机III ● 188.买卖股票的最佳时机IV
    XWPFTemplate（二）动态生成表格
    回顾.NET系列：Framework、Net Core、Net 过往
  • 原文地址：https://blog.csdn.net/qq_53374893/article/details/133231934