深入了解JMM（JAVA内存模型）

最新推荐文章于 2024-07-08 14:25:59 发布
最新推荐文章于 2024-07-08 14:25:59 发布
阅读量548 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AllenSun23/article/details/108445058
版权

JMM研究什么

JMM研究的是在多线程下Java代码的执行顺序，以及共享变量的读写。在多线程下，对共享变量读写的场景下，代码的执行结果可能和自己的期望结果不一致。

为什么会产生这种现象呢？

首先我们要知道两个现象：

  1. 我们写的代码，未必是实际运行的代码；
  2. 代码的编写顺序，未必就是实际的执行顺序。

为什么会有上面的两个现象呢？

处于性能的考虑，软件层次，JVM会对我们编写的代码进行优化，优化为更高效的代码指令；硬件层次，CPU还有Processor 优化和缓存优化。从而，造成以下三个问题：

  • 可见性问题
  • 原子性问题
  • 有序性问题

JMM研究的重点其实就上面这三个问题。

什么是JMM

jmm（java memory model）规范，他规范了java虚拟机与计算机内存如何协调工作 ，他规定了一个线程如何及何时看到其他线程修改过的变量的值，以及在必须时，如何同步的访问共享变量。

JMM规范

竞态条件

在多线程下，没有依赖关系的代码，在执行共享变量的读写操作时，不能保证以代码的编写顺序执行代码，称之为发生了竞态条件。

例如：
Thread1

r.r1 = y;
r.r2 = x;

Thread2

x = 1;
y = 2;

结果：r1 == 1，r2 == 0。代码执行顺序可能如下：

y = 1;
r.r1 = y;
r.r2 = x;
x = 1;
Synchronization Order

同步动作：在多线程下，如果要想让每个线程中代码的执行顺序，按照代码编写顺序执行，必须要使用Synchronization Actions来保证。这些同步动作有：

  • lock，unlock-synchronized，ReentrantLock等，保证原子性；
  • volatile 方式读写变量，保证可见性，防止指令重排；
  • varhandler方式读写变量（JDK9以上支持）
happens before

若是变量的读写是发生线程切换，在这些边界的处理上如果有action1先于action2发生，那么代码的可以按照确定的顺序执行，称之为happens before。

具体规则如下：

  1. 线程启动和运行的边界

    T1(x = 1) —>T1(t2.start())
    —>T2(run())
    —> T2(x == 10)

  2. 线程结束和join边界

T1(x = 10) —> T1(terminated)
—> T2(t1.join())
—> T2(x == 10)

 static boolean stop = false; //停止标记
    
 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            stop = true; 
        });
        System.out.println("start " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        t.start();
        t.join(); // 线程t在结束前执行了写入操作，当线程t 在join到主线程时，发生了happens before
        foo();
    }

   private static void foo() {
        while (true) {
         
                boolean b = stop; // volatile 的读
                if (b) {
                    break;
                }    
        }
        System.out.println("end " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
    }

  1. 线程的打断和得知打断的边界

    T1(x = 10) —> T1(t2.interrupt())
    —> T2(this.isInterrupt())
    —> T2(x == 10)

  2. unlock与lock边界

public class TestInfinityLoop {
    static volatile boolean stop = false; //停止标记

    static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
          synchronized (lock) {
                stop = true; 
            } // 解锁
        });
        System.out.println("start " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        t.start();
        foo();
    }

    private static void foo() {
        while (true) {
            synchronized (lock) { // 加锁
                boolean b = stop; // volatile 的读
                if (b) {
                    break;
                }
            }
        }
        System.out.println("end " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
    }
}

  1. volatile write与volatile read 边界

    注意：写要读的前面

public class TestInfinityLoop {
    static volatile boolean stop = false; //停止标记

   	public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            stop = true; // volatile 的写
        });
        System.out.println("start " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        t.start();
        foo();
    }

    private static void foo() {
        while (true) {
              boolean b = stop; // volatile 的读
              if (b) {
                  break;
              }
        }
        System.out.println("end " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
    }
}
  1. 传递性
Causality（因果律）

如果代码有依赖关系，即使没有加同步动作，代码的执行顺序也是能够确定。

安全发布

当一个对象被创建出来，作为共享变量使用时，要考虑安全发布，并且避免出现this溢出（在构造方法中，将this赋值给一个共享变量）。需要用final或者volatile修饰他的属性。因为，构造方法可能不是原子的。
使用final修饰成员变量，可以不用考虑它的位置；使用volatile修饰，必须修饰最后写的变量才能保证安全发布。

内存屏障

  • LoadLoad
    发生在两次读取操作之间，防止后面的读取操作重排序到屏障前面去。

  • LoadStore
    发生读取和写入之间，防止后面的写入操作重排序到屏障之前

  • StoreStore
    发生在两次连续的写之间，防止的写入操作重排序到屏障后面

  • StoreLoad
    在线程切换时有效，让所有写入都同步到内存，同时读取的内容是内存中最新的数据。

LoadLoad + LoadStore = Acquire 即让同一线程内读操作之后的读写上不去，第一个 Load 能读到主存最新值
LoadStore + StoreStore = Release 即让同一线程内写操作之前的读写下不来，后一个 Store 能将改动都写入主
存
StoreLoad 最为特殊，还能用在线程切换时，对变量的写操作 + 读操作做同步，只要是对同一变量先写后读，那
么屏障就能生效

volatile

本质

在这里插入图片描述
事实上对 volatile 而言 Store-Load，与 LoadLoad 屏障最为有用，volatile的作用：

  • 单一变量的赋值原子性；
  • 保证线程内按屏障有序，线程切换时，按Happens before有序；
  • 线程切换时若发生了写 —》读，则变量可见，顺带影响普通变量的可见。

visibility（可见性）

@JCStressTest
    @Outcome(id = {"3, 3, 3", "0, 0, 0"}, expect = Expect.ACCEPTABLE, desc = "ACCEPTABLE")
    @Outcome(id = {"0, 3, 3", "0, 0, 3"}, expect = Expect.ACCEPTABLE_INTERESTING, desc = "INTERESTING")
    @Outcome(id = "0, 3, 0", expect = Expect.FORBIDDEN, desc = "FORBIDDEN")
    @State
    public static class Case2 {
        static class Foo {
        // 加上volatile后，会阻止编译器对代码的优化，并加入StoreLoad屏障保证线程的中变量的写入，对于其他线程都是可见的。
            volatile int x = 0; 
        }

        Foo p = new Foo();
        Foo q = p;

        @Actor
        public void actor1(III_Result r) {
            r.r1 = p.x;
            r.r2 = q.x;
            r.r3 = p.x;
        }

        @Actor
        public void actor2() {
            p.x = 3;
        }
    }

partial ordering

volatile修饰了多个共享变量中的一个。

    @JCStressTest
    @Outcome(id = {"0, 0", "1, 1", "0, 1"}, expect = Expect.ACCEPTABLE, desc = "ACCEPTABLE")
    @Outcome(id = "1, 0", expect = Expect.FORBIDDEN, desc = "FORBIDDEN")
    @State
    public static class Case2 {
        int x;
        volatile int y;

        @Actor
        public void actor1() {
            x = 1;
            y = 1;
        }

        @Actor
        public void actor2(II_Result r) {
            r.r1 = y;
            r.r2 = x;
        }
    }

    @JCStressTest
    @Outcome(id = {"0, 0", "1, 1", "0, 1"}, expect = Expect.ACCEPTABLE, desc = "ACCEPTABLE")
    @Outcome(id = "1, 0", expect = Expect.FORBIDDEN, desc = "FORBIDDEN")
    @State
    public static class Case3 {
        volatile int x;
        int y;

        @Actor
        public void actor1() {
            x = 1;
            y = 1;
        }

        @Actor
        public void actor2(II_Result r) {
            r.r1 = y;
            r.r2 = x;
        }
    }

volatile修饰y和修饰x的效果有很大的差别，具体如下图所示：

在这里插入图片描述

total ordering

volatile修饰所有共享变量。

	/**
     * 案例1: 演示 total ordering 存在的问题
     */
    @JCStressTest
    @Outcome(id = {"1, 0", "0, 1", "1, 1"}, expect = Expect.ACCEPTABLE, desc = "ACCEPTABLE")
    @Outcome(id = "0, 0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "INTERESTING")
    @State
    public static class Case1 {
        int x;
        int y;

        @Actor
        public void a1(II_Result r) {
            y = 1;
            r.r2 = x;
        }

        @Actor
        public void a2(II_Result r) {
            x = 1;
            r.r1 = y;
        }
    }

使用volatile修饰其中一个共享变量，不能保证不会出现意外的情况发生。

	/**
     * 案例2: 演示单个 volatile 变量不能解决 total ordering 的情况
     */
    @JCStressTest
    @Outcome(id = {"1, 0", "0, 1", "1, 1"}, expect = Expect.ACCEPTABLE, desc = "ACCEPTABLE")
    @Outcome(id = "0, 0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "INTERESTING")
    @State
    public static class Case2 {
        int x;
        volatile int y;

        @Actor
        public void a1(II_Result r) {
            y = 1;
            r.r2 = x;
        }

        @Actor
        public void a2(II_Result r) {
            x = 1;
            r.r1 = y;
        }
    }

在所有共享变量上使用volatile修饰

    /**
     * 案例4: 演示两个 volatile 变量可以解决 total ordering 存在的问题
     */
    @JCStressTest
    @Outcome(id = {"1, 0", "0, 1", "1, 1"}, expect = Expect.ACCEPTABLE, desc = "ACCEPTABLE")
    @Outcome(id = "0, 0", expect = Expect.FORBIDDEN, desc = "FORBIDDEN")
    @State
    public static class Case4 {
        volatile int x;
        volatile int y;

        @Actor
        public void a1(II_Result r) {
            y = 1;
            r.r2 = x;
        }

        @Actor
        public void a2(II_Result r) {
            x = 1;
            r.r1 = y;
        }
    }

总结

volatile 写要用来收官，volatile 读要用来开篇.即volatile修饰的变量的写入操作要在一个线程的最后位置,volatile修饰的变量的读取操作要在一个线程的开始位置

VarHandler

安全发布

当创建了一个对象，并把它赋值给共享变量时，存在线程安全问题。

构造不安全

初始：

	/**
     * 案例1: 测试不安全的构造
     */
    @JCStressTest
    @Outcome(id = {"16", "-1"}, expect = Expect.ACCEPTABLE, desc = "ACCEPTABLE")
    @Outcome(expect = Expect.ACCEPTABLE_INTERESTING, desc = "INTERESTING")
    @State
    public static class Case1 {
        Holder f;

        int v = 1;

        @Actor
        public void a1() {
            f = new Holder(v);
        }

        @Actor
        void a2(I_Result r) {
            Holder o = this.f;
            if (o != null) {
                r.r1 = o.x8 + o.x7 + o.x6 + o.x5 + o.x4 + o.x3 + o.x2 + o.x1;
                r.r1 += o.y8 + o.y7 + o.y6 + o.y5 + o.y4 + o.y3 + o.y2 + o.y1;
            } else {
                r.r1 = -1;
            }
        }

        static class Holder {
            int x1, x2, x3, x4;
            int x5, x6, x7, x8;
            int y1, y2, y3, y4;
            int y5, y6, y7, y8;

            public Holder(int v) {
                x1 = v;
                x2 = v;
                x3 = v;
                x4 = v;
                x5 = v;
                x6 = v;
                x7 = v;
                x8 = v;
                y1 = v;
                y2 = v;
                y3 = v;
                y4 = v;
                y5 = v;
                y6 = v;
                y7 = v;
                y8 = v;
            }
        }
    }

测试结果：
在这里插入图片描述
原因：对象初始化的指令和赋值操作的指令发生重排序。

在这里插入图片描述

使用final修饰

使用final修饰类的任意一个成员变量

    /**
     * 案例2: 使用 final 改进
     */
    @JCStressTest
    @Outcome(id = {"16", "-1"}, expect = Expect.ACCEPTABLE, desc = "ACCEPTABLE")
    @Outcome(expect = Expect.FORBIDDEN, desc = "FORBIDDEN")
    @State
    public static class Case2 {
        Holder f;

        int v = 1;

        @Actor
        public void a1() {
            /**
             * 对象发布
             * 1.分配空间
             * 2.调用构造方法
             * 3，将引用赋值
             */
            f = new Holder(v);
        }

        @Actor
        void a2(I_Result r) {
            Holder o = this.f;
            if (o != null) {
                r.r1 = o.x8 + o.x7 + o.x6 + o.x5 + o.x4 + o.x3 + o.x2 + o.x1;
                r.r1 += o.y8 + o.y7 + o.y6 + o.y5 + o.y4 + o.y3 + o.y2 + o.y1;
            } else {
                r.r1 = -1;
            }
        }

        static class Holder {
            final int x1;
            int x2, x3, x4;
            int x5, x6, x7, x8;
            int y1, y2, y3, y4;
            int y5, y6, y7, y8;

            public Holder(int v) {
                x1 = v;
                x2 = v;
                x3 = v;
                x4 = v;
                x5 = v;
                x6 = v;
                x7 = v;
                x8 = v;
                y1 = v;
                y2 = v;
                y3 = v;
                y4 = v;
                y5 = v;
                y6 = v;
                y7 = v;
                y8 = v;
            }
        }
    }

测试结果：
在这里插入图片描述
原因：final修饰任意的一个变量时，会在构造方法结束前，添加StoreStore屏障。
在这里插入图片描述

使用volatile修饰


```java
    /**
     * 案例4: 使用 volatile 改进
     */
    @JCStressTest
    @Outcome(id = {"16", "-1"}, expect = Expect.ACCEPTABLE, desc = "ACCEPTABLE")
    @Outcome(expect = Expect.FORBIDDEN, desc = "FORBIDDEN")
    @State
    public static class Case4 {
        Holder f;

        int v = 1;

        @Actor
        public void a1() {
            f = new Holder(v);
        }

        @Actor
        void a2(I_Result r) {
            Holder o = this.f;
            if (o != null) {
                r.r1 = o.x8 + o.x7 + o.x6 + o.x5 + o.x4 + o.x3 + o.x2 + o.x1;
                r.r1 += o.y8 + o.y7 + o.y6 + o.y5 + o.y4 + o.y3 + o.y2 + o.y1;
            } else {
                r.r1 = -1;
            }
        }

        static class Holder {
            volatile int x1;
            int x2, x3, x4;
            int x5, x6, x7, x8;
            int y1, y2, y3, y4;
            int y5, y6, y7, y8;

            public Holder(int v) {
                x2 = v;
                x3 = v;
                x4 = v;
                x5 = v;
                x6 = v;
                x7 = v;
                x8 = v;
                y1 = v;
                y2 = v;
                y3 = v;
                y4 = v;
                y5 = v;
                y6 = v;
                y7 = v;
                y8 = v;
                x1 = v;
            }
        }
    }

结果：
在这里插入图片描述
原因：
在这里插入图片描述

注意：使用volatile必须修饰最后一个赋值操作的变量。

DCL安全单例

初始：

public class Singleton {
    private static Singleton INSTANCE = null;
   
	public static Singleton getInstance() {    
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

原因：
在这里插入图片描述

  1. synchronized可以防止{}中代码重排序到外面去，但是不能防止{}里面的代码在{}内重排序。
  2. 如果INSTANCE = t，重排序到t.x = 1和t.y = 1之间。
  3. 代码执行到INSTANCE = t后，cpu开始执行红色线程，这样红色线程判断INSTATCHE != null，因此，会返回一个没有完全构造的单例对象。

解决方案：
因为不能使用final修饰INSTANCE，所以只能使用volatile修饰INSTANTCE.

在这里插入图片描述
volatile修饰INSTANCE后，可以保证synchronized {}内的INSTACNE = t执行前，成员变量的赋值操作全部结束。这样，就可以实现安全的单例模式。

AllenSun23
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解 Java 内存模型
05-06
《深入理解 Java 内存模型》这本书由程晓明编著，旨在帮助开发者深入理解和应用 JMM。 1. **内存层次结构**：Java 内存模型将内存分为堆内存、栈内存、方法区（在 Java 8 及以后版本中被元空间替代）和程序计数器等...
深入理解Java内存模型 pdf 超清版
01-31
Java内存模型，简称JMM（Java Memory Model），是Java编程语言规范的一部分，它定义了程序中各个线程如何访问和修改共享变量，以及如何确保数据的一致性。深入理解Java内存模型对于编写高效的并发程序至关重要。本文...
JMM(Java内存模型)详解
落日的博客
07-03 893
为了对上面的问题进行更深入的探究，我有查了一些JIT相关的资料。简单总结下JIT然后再对上面的问题分析下。JIT（Just-In-Time）编译器是Java虚拟机（JVM）中的一个关键组件，它负责在程序运行过程中动态地将字节码（即Java编译后的.class文件中的代码）转换为特定于平台的机器代码。这一过程旨在提高程序的执行效率，因为它能够针对运行时的数据和实际使用模式进行优化，而不仅仅是基于静态代码分析。JIT工作原理加载与解释执行：当Java程序启动时，JVM首先加载类文件并由解释器执行字节码。
深入理解JMM内存模型
王华春_Jason
10-17 2265
目录 一、JMM内存模型产生的背景？ 二、什么是JMM内存模型？ 三、JMM内存模型用来解决什么问题？ 四、JMM内存模型与JVM内存模型有什么关系？ 1、JMM是Java物理内存模型 2、JVM是运行时内存模型 3、JMM内存模型和JVM运行时内存模型的关系 一、JMM内存模型产生的背景？ JMM(Java内存模型)源于物理机器CPU架构的内存模型，最初用于解决MP(多处理器架构)系统中的缓存一致性问题，而JVM为了屏蔽各个硬件平台和操作系统对内存访问机制的差异化，提出了JMM的概.
Java内存模型—JMM详解
可达鸭的博客
07-23 3132
JMM
你真的了解Java内存模型JMM吗?
程序员世杰
07-08 678
1. 什么是Java内存模型(JMM)? 为什么需要JMM? 2. Java线程的工作内存和主内存各自的作用? 3. Java缓存一致性问题? 4. Java的并发编程问题?
一文带你深入了解JMM（Java内存模型）
xjx666666的博客
08-06 527
synchronized的特点获得同步锁；清空工作内存；从主内存拷贝对象副本到工作内存；执行代码(计算或者输出等)；刷新主内存数据；释放同步锁。所以，synchronized既保证了多线程的并发有序性和原子性，又保证了多线程的内存可见性。有序性和原子性都是通过同一时刻只有一个线程可以进入锁住的代码保证的（不被其他线程中断，避免了部分执行）。volatile是第二种Java多线程同步的手段。一个被volatile修饰的变量，JMM会确保所有线程看到的是一致的变量值。
JMM Java内存模型的概念以及happens-before原则
终生学习践行者
04-13 3142
详细介绍了JMM Java内存模型的概念、由来，以及happens-before原则的具体规则。
深入理解 Java 内存模型 JMM
GarfieldEr007的专栏
07-22 645
前提 《深入理解 Java 内存模型》程晓明著，该书在以前看过一遍，现在学的东西越多，感觉那块越重要，于是又再细看一遍，于是便有了下面的读书笔记总结。全书页数虽不多，内容讲得挺深的。细看的话，也是挺花时间的，看完收获绝对挺大的。也建议 Java 开发者都去看看。里面主要有 Java 内存模型的基础、重排序、顺序一致性、Volatile 关键字、锁、final。本文参考书中内容。 基础 并发编...
深入理解Java内存模型(JMM)与虚拟机的内存结构(JVM)
码到三十五
02-21 1801
在Java编程世界中，Java内存模型（Java Memory Model，简称JMM）和Java虚拟机（Java Virtual Machine，简称JVM）的内存结构是两个核心概念。它们对于理解Java程序的执行方式、性能优化以及并发编程至关重要。尽管这两个概念紧密相连，但它们的职责和特性却各不相同。本文将详细探讨Java内存模型与Java虚拟机的内存结构，帮助读者更深入地理解它们之间的关系和差异。
Java内存模型(JMM)和volatile原理
weixin_54232666的博客
06-16 1054
一篇带你弄懂Java内存模型(JMM)和volatile原理，为什么synchronized可以保证可见性，以及volatile的底层原理，如何防止多线程JVM指令重排问题，如何利用syn和volition实现现场安全的单例。
深入理解JMM(Java内存模型)
老猫喜欢今日爬山的博客
11-15 126
Java内存模型(Java Memory Model简称JMM)是一种抽象的概念，并不真实存在，它描述的一组规则或者规范。通过这些规则、规范定义了程序中各个变量的访问方式。jvm运行的程序的实体是线程，而每个线程运行时，都会创建一个工作内存（也叫栈空间），来保存线程所有的私有变量。而JMM内存模型规范中规定所有的变量都存储在主内存中，而主内存中的变量是所有的线程都可以共享的，而对主内存中的变量进行操作时，必须在线程的工作内存进行操作，首先将主内存的变量copy到工作内存，进行操作后，再将变量刷回到主内存中。
深入Java内存模型-JMM
04-21
Java内存模型，简称JMM（Java Memory Model），是Java虚拟机规范中定义的一个抽象概念，它描述了在多线程环境下，如何保证各个线程对共享数据的一致性视图。JMM的主要目标是定义程序中各个变量的访问规则，以及在...
14、深入理解并发可见性、有序性、原子性与JMM内存模型
03-07
深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发...
深入理解java内存模型
04-19
《深入理解Java内存模型》是一本专注于探讨Java平台上的内存管理机制的重要著作。Java内存模型（Java Memory Model，简称JMM）是Java编程语言规范的一部分，它定义了线程之间的共享变量如何交互以及多线程环境下的...
mpu6050陀螺仪使用方法开发教程文档.docx
07-30
mpu6050陀螺仪使用方法
【SCI顶级】龙格库塔算法RUN-CNN-LSTM-Multihead-Attention温度预测【含源码 5747期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Mutilhead-Attention回归预测
大模型的数学之魂：统计学习理论精要
07-30
大型机器学习模型，通常简称为“大模型”，是指具有数十亿甚至数千亿参数的深度神经网络模型。这些模型因为其庞大的参数量和复杂的计算结构，能够处理非常复杂的任务和数据，展现出强大的表达能力和预测性能。大模型在自然语言处理、计算机视觉、语音识别和推荐系统等多个领域都有广泛的应用。 大模型的设计目的是通过训练海量数据来学习复杂的模式和特征，从而具备强大的泛化能力，能够对未见过的数据做出准确的预测。与参数较少、层数较浅的小模型相比，大模型虽然需要更多的计算资源和时间来训练和推理，但它们展现出了一种被称为“涌现能力”的特性，即从原始训练数据中自动学习并发现新的、更高层次的特征和模式。 大模型的发展历程可以分为几个阶段，从早期的卷积神经网络模型发展到以Transformer为代表的全新神经网络模型，再到当前以GPT为代表的预训练大模型阶段。Transformer架构因其自注意力机制而成为大模型的核心技术，它使得模型能够更好地理解和处理文本数据中的长距离依赖关系。 大模型的分类主要包括语言大模型（NLP）、视觉大模型（CV）和多模态大模型。语言大模型专注于处理文本数据和理解自然语言，而视觉大模型用
唯美淡雅四页.zip
最新发布
07-30
【简历模板】工作总结、商业计划书、述职报告、读书分享、家长会、主题班会、端午节、期末、夏至、中国风、卡通、小清新、岗位竞聘、公司介绍、读书分享、安全教育、文明礼仪、儿童故事、绘本、防溺水、夏季安全、科技风、商务、炫酷、企业培训、自我介绍、产品介绍、师德师风、班主任培训、神话故事、巴黎奥运会、世界献血者日、防范非法集资、3D快闪、毛玻璃、人工智能等等各种样式的ppt素材风格。 设计模板、图片素材、PPT模板、视频素材、办公文档、小报模板、表格模板、音效配乐、字体库。 广告设计：海报，易拉宝，展板，宣传单，宣传栏，画册，邀请函，优惠券，贺卡，文化墙，标语，制度，名片，舞台背景，广告牌，证书，明信片，菜单，折页，封面，节目单，门头，美陈，拱门，展架等。 电商设计：主图，直通车，详情页，PC端首页，移动端首页，钻展，优惠券，促销标签，店招，店铺公告等。 图片素材：PNG素材，背景素材，矢量素材，插画，元素，艺术字，UI设计等。 视频素材：AE模板，会声会影，PR模板，视频背景，实拍短片，音效配乐。 办公文档：工作汇报，毕业答辩，企业介绍，总结计划，教学课件，求职简历等PPT/WORD模板。
深入理解Java内存模型：JMM详解
"Java内存模型是Java开发中的关键概念，它描述了程序中变量如何在内存中存储和访问，特别是涉及多线程环境下的同步和线程安全性。JVM内存模型，也称为JMM（Java Memory Model），是Java平台的核心组成部分，确保了在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值