HuRan's Blog
归档
全部文章 标签 分类
搜索
摸鱼
抓住那只猫！
HuRan's Blog

目录

JUC并发编程(2)|JMM

 收录于 Java
     约 2755 字   预计阅读 6 分钟 

JUC （2）

什么是JMM？

JMM只是一个java内存模型，一种概念模型。不是具体存在的。为了保护JAVA内存运行安全

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

    • 线程A去拿主存的变量，不会直接引用地址，而是clone一份。
    • 线程A把拿来的共享变量改变后，要马上刷新回去

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

  3. 加锁和解锁是同一把锁

线程的工作内存(ThreadLocal)

八种操作

https://pic.imgdb.cn/item/66a4ba04d9c307b7e98d1f5e.png

  1. read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便 随后的load动作使用
  2. load（载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
  3. use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机 遇到一个需要使用到变量的值，就会使用到这个指令
  4. assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变 量副本中
  5. write （写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中
  6. store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中， 以便后续的write使用
  7. lock（锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
  8. unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量 才可以被其他线程锁定

JMM对此制定了以下规则：

  1. 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须 write
  2. 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
  3. 不允许一个线程将没有assign的数据从工作内存同步回主内存
  4. 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量 实施use、store操作之前，必须经过assign和load操作
  5. 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
  6. 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前， 必须重新load或assign操作初始化变量的值 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
  7. 对一个变量进行unlock操作之前，必须把此变量同步回主内存

⚠️B修改了值，但A不能及时可见

Volatile

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

  1. 保证可见性

    • 内存中的变量改变后，及时刷新到所有工作内存中。

  2. 不保证原子性

    原子性 : 不可分割 线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功，要么同时失败。

    • 使用Atom原子类解决原子性问题 CAS

  3. 禁止指令重排

    • 源代码–>编译器优化的重排–> 指令并行也可能会重排–> 内存系统也会重排—> 执行
    • 处理器在进行指令重排的时候，考虑：数据之间的依赖性

单例模式

  1. 饿汉式

    •  1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

      // 饿汉式单例
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 getInstance(){
        return HUNGRY;
    }
}

  2. 普通懒汉式⚠️

    •  1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

      public class LazyMan {
    private static LazyMan lazyMan;

    private LazyMan(){}

    public static LazyMan getInstance(){
        if(lazyMan==null){
            lazyMan=new LazyMan();
        }
        return lazyMan;
    }
}

    • 单线程下单例可行，但多线程并发有可能会重复创建新实例。原因是

      • lazyMan=new LazyMan()这一步时不是原子性操作，其他线程可能会判断到 if(lazyMan==null)还是true，重复new。

    • 可以使用double check机制⬇️

  3. DCL懒汉式

    •  1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

      public class DCLLazyMan {
    private volatile static LazyMan lazyMan;

    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+" ok");
    }

    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized(LazyMan.class){
                if(lazyMan==null){
                    lazyMan = new LazyMan();//不是原子性操作
                }
            }
        }
        return lazyMan;
    }
}
    1. synchronized(LazyMan.class)加锁双重验证
    2. volatile修饰类变量，避免指令重排
      • new LazyMan()的3个步骤
        1. 分配内存空间
        2. 执行构造方法，初始化对象
        3. 对象指向该堆地址
      • 指令顺序：123————>正常
      • 指令顺序：132————>对象指向的堆地址已经分配内存空间，但未初始化对象，且lazyMan==null会造成难以预计的后果。

  4. 静态内部类

    •  1
 2
 3
 4
 5
 6
 7
 8
 9
10

      //静态内部类
public class Holder {
    private Holder(){}
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

⚠️以上的方式，有效但是不安全！，因为有反射declaredConstructor.setAccessible(true);//无视私有构造器和declaredConstructor.newInstance()就可以绕过单例模式直接new。

1
2
3
4
5
6
7
8
9

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
    LazyMan instance1 = LazyMan.getInstance();
    Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
    declaredConstructor.setAccessible(true);//无视私有构造器
    LazyMan instance2 = declaredConstructor.newInstance();

    System.out.println(instance1);
    System.out.println(instance2);
}

但是也有防范方法：

  1. 构造器判断
1
2
3
4
5
6
7

private LazyMan(){
    synchronized (LazyMan.class){
        if(lazyMan != null){
            throw new RuntimeException("不要用反射构造");
        }
    }
}
  • 在构造器也进行一次判断

但是，如果对方两次构造都用newInstance()方法就可以绕过单例模式

1
2

LazyMan instance1 = declaredConstructor.newInstance();
LazyMan instance2 = declaredConstructor.newInstance();
  1. 标志位判断：增加一个bool变量，构造好后设为true。
    • 同理，使用Field反射也可以更改变量，同样不安全

所以只要有反射就无法完成防范，但是反射原理也告诉了我们解决方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

@CallerSensitive
public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
           IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, null, modifiers);
        }
    }
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    ConstructorAccessor ca = constructorAccessor;   // read volatile
    if (ca == null) {
        ca = acquireConstructorAccessor();
    }
    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);
    return inst;
}
  • newInstance函数有一句if ((clazz.getModifiers() & Modifier.ENUM) != 0),如果是枚举则不会构造。

所以我们可以用枚举类做一个单例模式

1
2
3
4
5
6
7
8

public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance() {
        return INSTANCE;
    }
}

使用反射试一下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class Test{
    public static void main(String[] args) throws InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        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);
    }
}

EnumSingle.class.getDeclaredConstructor(String.class, int.class);一定要String.class, int.class，这是Enum类的构造方法

会报错：

1
2
3

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
	at com.huran.single.Test.main(EnumSingle.java:20)

枚举类型的特性：

  1. 类加载机制:
    • 枚举类型在被加载时，JVM会确保它们的实例是唯一的。在枚举类被初始化时，所有的枚举实例都会被创建，并且这个过程是线程安全的。
    • 由于枚举类型的类加载机制，每个枚举常量都是一个public static final实例，并且只能被实例化一次。
  2. 序列化:
    • 枚举类型的序列化机制保证了枚举实例在反序列化过程中不会创建新的实例。JVM会确保反序列化的枚举实例与原始实例是同一个对象。
    • 枚举的readResolve方法会自动处理序列化和反序列化，以保证返回同一个枚举实例。
更新于 2024-08-27
阅读原始文档
 并发
返回 | 主页
首页搜索