JUC系列(八)Java内存模型 volatile关键字与单例模式实践

简介: JMM里有对于线程交换资源的一些约定 理解可以更好的参透JUC的内容Volatile可以保证可见性和阻止操作系统的指令重排理解多个不同的单例模式的实现方法
📣 📣 📣 📢📢📢
☀️☀️你好啊!小伙伴,我是小冷。是一个兴趣驱动自学练习两年半的的Java工程师。
📒 一位十分喜欢将知识分享出来的Java博主⭐️⭐️⭐️,擅长使用Java技术开发web项目和工具
📒 文章内容丰富:覆盖大部分java必学技术栈,前端,计算机基础,容器等方面的文章
📒 如果你也对Java感兴趣,关注小冷吧,一起探索Java技术的生态与进步,一起讨论Java技术的使用与学习
✏️高质量技术专栏专栏链接: 微服务netty单点登录SSMSpringCloudAlibaba
😝公众号😝想全栈的小冷,分享一些技术上的文章,以及解决问题的经验
当前专栏JUC系列

JMM

谈谈队 Volatile的理解

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

  1. 保证可见性
  2. 不保证原子性
  3. 禁止指令重排

什么是Jmm

JMM就是Java内存模型(java memory model) Java内存模型规定所有的变量都存储在主内存中,包括实例变量,静态变量,但是不包括局部变量和方法参数。每个线程都有自己的工作内存,线程的工作内存保存了该线程用到的变量和主内存的副本拷贝,线程对变量的操作都在工作内存中进行线程不能直接读写主内存中的变量

jmm的一些同步约定

  1. 线程解锁前 必须把共享变量 立刻刷新回主缓存
  2. 线程加锁 前,必须读取主内存中的最新值到工作中
  3. 加锁和解锁必须是同一把锁

线程 : 工作内存和 主内存

Jmm中的八种操作:

image-20220304163433104

  • lock(锁定),作用于主内存中的变量,把变量标识为线程独占的状态。
  • read(读取),作用于主内存的变量,把变量的值从主内存传输到线程的工作内存中,以便下一步的load操作使用。
  • load(加载),作用于工作内存的变量,把read操作主存的变量放入到工作内存的变量副本中。
  • use(使用),作用于工作内存的变量,把工作内存中的变量传输到执行引擎,每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作。
  • assign(赋值),作用于工作内存的变量,它把一个从执行引擎中接受到的值赋值给工作内存的变量副本中,每当虚拟机遇到一个给变量赋值的字节码指令时将会执行这个操作。
  • store(存储),作用于工作内存的变量,它把一个从工作内存中一个变量的值传送到主内存中,以便后续的write使用。
  • write(写入):作用于主内存中的变量,它把store操作从工作内存中得到的变量的值放入主内存的变量中。
  • unlock(解锁):作用于主内存的变量,它把一个处于锁定状态的变量释放出来,释放后的变量才可以被其他线程锁定。

JMM对8种内存交互操作制定的规则:

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

Volatile

验证 这个关键字的特性

  1. 保证可见性
  2. 不保证原子性
  3. 禁止指令重排
1 可见性
    //volatile 之后 就会循环停止了,验证了特性 1 可见性
    private volatile static int num = 0;

    public static void main(String[] args) {
        //此时循环 没有结束 为什么? 因为线程队主内存的变化并不知道
        new Thread(() -> {
            while (num == 0) {

            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
    }
2 不保证原子性

使用 synchronized 关键字 保证原子性 结果为 20000

   private static int num = 0;

    public synchronized static void add() {
        num++;
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + num);
    }

使用 Volatile 不保证原子性 17824 每次出来的都不一样,可能是两万 概率不大

    private volatile static int num = 0;

    public static void add() {
        num++;
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + num);
    }
问题 如果不上锁 也不用 关键字 ,我们怎么保证原子性

image-20220304165005009

使用JUC 包中的 原子类 来解决 原子性问题

比如 int : 替换成 原子类 AtomicInteger

 private volatile static AtomicInteger num = new AtomicInteger(0);

    public static void add() {
        //num++;
        // incr 自增
        num.getAndIncrement();
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + num);
    }

保证了原子操作 输出20000

image-20220304165350036

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

指令重排

什么是 指令重排: 我们写的程序 计算机不一定会按照我们写的顺序来执行

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

==处理器再进行指令重排的时候 考虑数据之间的依赖性==

int x = 1;// 1
int y = 2;// 2
x = x + 5;// 3
y = x * x;// 4

我们期待的是 1234, 可能执行的时候变成了 2134 1324
但是不可能是 4123

可能 造成影响最后的执行结果 a b x y 默认值都是 0

image-20220304170008300

正常的结果 : x=0;y=0; 可能由于指令重排

image-20220304170120677

指令重排 导致的奇怪结构 = x=2 y=1

volatile 可以避免指令重排

内存屏障 CPU 指令 作用:

  1. 保证特定操作的执行顺序
  2. 可以保证某些变量的内存可见性

image-20220304170643130

单例模式

饿汉式
public class Hungryemo {
    private Hungryemo() {
    }

    private final static Hungryemo HUNGRYEMO = new Hungryemo();

    public static Hungryemo getIstance() {
        return HUNGRYEMO;
    }
}
DCL懒汉式
package single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @projectName: JUC
 * @package: single
 * @className: LazyMan
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * @date: 2022/3/4 17:09
 * @version: 1.0
 */
public class LazyMan {
    private static boolean flag = true;

    private LazyMan() {
        synchronized (LazyMan.class) {
            if (flag == false) {
                flag = true;
            } else {
                throw new RuntimeException("不要试图用反射破坏单例模式");
            }
            if (lazyMan != null) {
                throw new RuntimeException("不要试图用反射破坏单例模式");
            }
        }
    }

    //必须 加上 volatile 避免 指令重排
    private volatile static LazyMan lazyMan;

    // 双重检测锁模式 的懒汉式单例 DCL懒汉式
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();
                    //    会有问题 不是一个原子性操作
                    /* 1. 分配内存空间
                     * 2 。 执行构造对象 初始化对象
                     * 3. 把这个对象指向空间
                     *
                     * 比如 我们期望执行的是 123
                     * 但是 指令重排 执行是 132
                     * a 线程可能没有问题,
                     * b 就会以为已经完成构造,指向就是null 可能会空指针
                     * */
                }
            }
        }
        return lazyMan;
    }

    //但是会有并发问题
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<EnumSngle> field = EnumSngle.class.getDeclaredConstructor(String.class, int.class);
        field.setAccessible(true);
        //LazyMan lazyMan = field.newInstance();
        //LazyMan lazyMan1 = field.newInstance();
        EnumSngle lazyMan = field.newInstance();
        EnumSngle lazyMan1 = field.newInstance();

        System.out.println(lazyMan);
        System.out.println(lazyMan1);
    }
}
静态内部类
public class Holder {
    private Holder() {
    }

    public static Holder getInstance() {
        return innerClass.holder;
    }

    public static class innerClass {
        private final static Holder holder = new Holder();
    }


}
枚举
//enum 是什么? 本身也是一个 Class 类
public enum EnumSngle {
    INSTANCE;

    private EnumSngle() {
    }

    public EnumSngle getInstance() {
        return INSTANCE;
    }
}
class test{
        //但是会有并发问题
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<EnumSngle> field = EnumSngle.class.getDeclaredConstructor(String.class, int.class);
        field.setAccessible(true);
        //LazyMan lazyMan = field.newInstance();
        //LazyMan lazyMan1 = field.newInstance();
        EnumSngle lazyMan = field.newInstance();
        EnumSngle lazyMan1 = field.newInstance();

        System.out.println(lazyMan);
        System.out.println(lazyMan1);
    }
}
相关文章
|
2月前
|
监控 Java API
现代 Java IO 高性能实践从原理到落地的高效实现路径与实战指南
本文深入解析现代Java高性能IO实践,涵盖异步非阻塞IO、操作系统优化、大文件处理、响应式网络编程与数据库访问,结合Netty、Reactor等技术落地高并发应用,助力构建高效可扩展的IO系统。
52 0
|
2月前
|
并行计算 Java API
Java List 集合结合 Java 17 新特性与现代开发实践的深度解析及实战指南 Java List 集合
本文深入解析Java 17中List集合的现代用法,结合函数式编程、Stream API、密封类、模式匹配等新特性,通过实操案例讲解数据处理、并行计算、响应式编程等场景下的高级应用,帮助开发者提升集合操作效率与代码质量。
113 1
|
2月前
|
SQL 缓存 安全
深度理解 Java 内存模型:从并发基石到实践应用
本文深入解析 Java 内存模型(JMM),涵盖其在并发编程中的核心作用与实践应用。内容包括 JMM 解决的可见性、原子性和有序性问题,线程与内存的交互机制,volatile、synchronized 和 happens-before 等关键机制的使用,以及在单例模式、线程通信等场景中的实战案例。同时,还介绍了常见并发 Bug 的排查与解决方案,帮助开发者写出高效、线程安全的 Java 程序。
118 0
|
2月前
|
存储 搜索推荐 算法
Java 大视界 -- Java 大数据在智慧文旅旅游线路规划与游客流量均衡调控中的应用实践(196)
本实践案例深入探讨了Java大数据技术在智慧文旅中的创新应用,聚焦旅游线路规划与游客流量调控难题。通过整合多源数据、构建用户画像、开发个性化推荐算法及流量预测模型,实现了旅游线路的精准推荐与流量的科学调控。在某旅游城市的落地实践中,游客满意度显著提升,景区流量分布更加均衡,充分展现了Java大数据技术在推动文旅产业智能化升级中的核心价值与广阔前景。
|
2月前
|
存储 Java
Java对象的内存布局
在HotSpot虚拟机中,Java对象的内存布局分为三部分:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。对象头包含Mark Word、Class对象指针及数组长度;实例数据存储对象的实际字段内容;对齐填充用于确保对象大小为8字节的整数倍。
|
2月前
|
存储
阿里云轻量应用服务器收费标准价格表:200Mbps带宽、CPU内存及存储配置详解
阿里云香港轻量应用服务器,200Mbps带宽,免备案,支持多IP及国际线路,月租25元起,年付享8.5折优惠,适用于网站、应用等多种场景。
466 0
|
2月前
|
存储 缓存 NoSQL
内存管理基础:数据结构的存储方式
数据结构在内存中的存储方式主要包括连续存储、链式存储、索引存储和散列存储。连续存储如数组,数据元素按顺序连续存放,访问速度快但扩展性差;链式存储如链表,通过指针连接分散的节点,便于插入删除但访问效率低;索引存储通过索引表提高查找效率,常用于数据库系统;散列存储如哈希表,通过哈希函数实现快速存取,但需处理冲突。不同场景下应根据访问模式、数据规模和操作频率选择合适的存储结构,甚至结合多种方式以达到最优性能。掌握这些存储机制是构建高效程序和理解高级数据结构的基础。
160 0
|
2月前
|
存储 弹性计算 固态存储
阿里云服务器配置费用整理,支持一万人CPU内存、公网带宽和存储IO性能全解析
要支撑1万人在线流量,需选择阿里云企业级ECS服务器,如通用型g系列、高主频型hf系列或通用算力型u1实例,配置如16核64G及以上,搭配高带宽与SSD/ESSD云盘,费用约数千元每月。
145 0
|
存储 编译器 C语言
【C语言篇】数据在内存中的存储(超详细)
浮点数就采⽤下⾯的规则表⽰,即指数E的真实值加上127(或1023),再将有效数字M去掉整数部分的1。
774 0