精华内容
下载资源
问答
  • java的内存模型

    2016-08-08 11:48:16
    Java的内存模型 一、模型展示图 本地内存: ①其实是抽象的、不存在的,但是主内存是存在的。本地内存是主内存的副本。 二、volatile和synchronized的内存语义 java的内存屏壁的作用: ①保证内存的可见性 ...
    

    Java的内存模型

    一、模型展示图

    本地内存:

    ①其实是抽象的、不存在的,但是主内存是存在的。本地内存是主内存的副本。




    二、volatile和synchronized的内存语义

    java的内存屏壁的作用:

    ①保证内存的可见性
    ②禁止重排序,遵循happen-before语义


    被volatile修饰的变量,在使用的过程中都是会直接读取主内存的值,而实现这个的就是这个内存屏壁发挥的作用,但是保证不了原子性。从内存中读取数据和将数据刷新到主内存中的load/read/store/write这四步是保证不了原子性的。

    synchronized修饰的方法或者代码块= 内存可见+原子性。


    volatile的使用条件:

    ①对变量的写操作不依赖当前值            如:a++;
    ②该变量不能存在于其他变量的不变式中     如:int b=a+1;

    最实在的使用场景:
    ①作为一次性事件、终结条件;涉及的单方面修改
    ②读--写锁分离策略。读用volatile、写用对象锁。




    展开全文
  • JAVA的内存模型

    2020-07-13 19:31:33
    Java 内存模型Java 并发编程有关。 JVM内存模型 6个区域 堆区(Heap):堆是存储类实例和数组,通常是内存中最大一块。实例很好理解,比如 new Object() 就会生成一个实例;而数组也是保存在堆上面,...

    JAVA内存模型


    JVM 内存结构和 Java 虚拟机的运行时区域有关;

    Java 内存模型和 Java 的并发编程有关。


    JVM内存模型

    6个区域

    堆区(Heap):堆是存储类实例和数组的,通常是内存中最大的一块。实例很好理解,比如 new Object() 就会生成一个实例;而数组也是保存在堆上面的,因为在 Java 中,数组也是对象。

    虚拟机栈(Java Virtual Machine Stacks):保存局部变量和部分结果,并在方法调用和返回中起作用。

    方法区(Method Area):存储每个类的结构,例如运行时的常量池、字段和方法数据,以及方法和构造函数的代码,包括用于类初始化以及接口初始化的特殊方法。

    本地方法栈(Native Method Stacks):与虚拟机栈基本类似,区别在于虚拟机栈为虚拟机执行的 Java 方法服务,而本地方法栈则是为 Native 方法服务

    程序计数器(The PC Register):是最小的一块内存区域,它的作用通常是保存当前正在执行的 JVM 指令地址

    运行时常量池(Run-Time Constant Pool):是方法区的一部分,包含多种常量,范围从编译时已知的数字到必须在运行时解析的方法和字段引用。


    .java->.class->机器指令->cpu运行


    JMM 里最重要 3 点内容,分别是:重排序、原子性、内存可见性。


    重排序:一个 Java 程序,编译器、JVM 或者 CPU ,出于优化等目的,对于实际指令执行的顺序进行调整。

    重排序通过减少执行指令,从而提高整体的运行速度


    原子性:一系列的操作,要么全部发生,要么全部不发生,不会出现执行一半就终止的情况。

    比如转账行为就是一个原子操作,该过程包含扣除余额、银行系统生成转账记录、对方余额增加等一系列操作。虽然整个过程包含多个操作,但由于这一系列操作被合并成一个原子操作,所以它们要么全部执行成功,要么全部不执行,不会出现执行一半的情况。比如我的余额已经扣除,但是对方的余额却不增加,这种情况是不会出现的,所以说转账行为是具备原子性的。而具有原子性的原子操作,天然具备线程安全的特性。

    不具备原子性的例子:i++(3 个指令:读取 增加 保存 )

    原子操作:

    1、除了 long 和 double 之外的基本类型(int、byte、boolean、short、char、float)的读/写操作,都天然的具备原子性;

    2、所有引用 reference 的读/写操作;

    3、加了 volatile 后,所有变量的读/写操作(包含 long 和 double)。这也就意味着 long 和 double 加了 volatile 关键字之后,对它们的读写操作同样具备原子性;

    4、在 java.concurrent.Atomic 包中的一部分类的一部分方法是具备原子性的,比如 AtomicInteger 的 incrementAndGet 方法。

    原子操作 + 原子操作 != 原子操作


    内存可见性:

    volatile


    JMM的抽象:主内存和工作内存

    img

    每个线程只能够直接接触到工作内存,无法直接操作主内存,而工作内存中所保存的正是主内存的共享变量的副本,主内存和工作内存之间的通信是由 JMM 控制的。

    如果一个变量 x 被线程 A 修改了,只要还没同步到主内存中,线程 B 就看不到,所以此时线程 B 读取到的 x 值就是一个过期的值,这就导致了可见性问题。


    什么是 happens-before 关系

    描述和可见性相关问题

    如果第一个操作 happens-before 第二个操作,就说第一个操作对于第二个操作一定是可见的

    Happens-before 关系的规则:

    1、单线程规则

    2、锁操作规则

    3、volatile 变量规则

    4、线程启动规则

    5、线程 join 规则

    6、中断规则

    7、并发工具类的规则


    volatile 是什么

    Java关键字 一种同步机制。

    当某个变量是共享变量,且这个变量是被 volatile 修饰的,那么在修改了这个变量的值之后,再读取该变量的值时,可以保证获取到的是修改后的最新的值,而不是过期的值。

    相比于 synchronized 或者 Lock,volatile 是更轻量的,因为使用 volatile 不会发生上下文切换等开销很大的情况,不会让线程阻塞。但正是由于它的开销相对比较小,所以它的效果,也就是能力,相对也小一些。

    不适用:i++ volatile 不能保证原子性

    适用:布尔标记位、触发器、

    如果某个共享变量自始至终只是被各个线程所赋值或读取,而没有其他的操作(比如读取并在此基础上进行修改这样的复合操作)的话,那么我们就可以使用 volatile 来代替 synchronized 或者代替原子类,因为赋值操作自身是具有原子性的,volatile 同时又保证了可见性,这就足以保证线程安全了。

    一个比较典型的场景就是布尔标记位的场景,例如 volatile boolean flag。因为通常情况下,boolean 类型的标记位是会被直接赋值的,此时不会存在复合操作(如 a++),只存在单一操作,就是去改变 flag 的值,而一旦 flag 被 volatile 修饰之后,就可以保证可见性了,那么这个 flag 就可以当作一个标记位,此时它的值一旦发生变化,所有线程都可以立刻看到,所以这里就很适合运用 volatile 了。

    volatile 的作用:保证可见性、禁止重排序


    单例模式的双重检查锁模式为什么必须加 volatile?

    单例模式指的是,保证一个类只有一个实例,并且提供一个可以全局访问的入口。

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

    方法中首先进行了一次 if (singleton == null) 的检查,然后是 synchronized 同步块,然后又是一次 if (singleton == null) 的检查,最后是 singleton = new Singleton() 来生成实例。

    我们进行了两次 if (singleton == null) 检查,这就是“双重检查锁”这个名字的由来。这种写法是可以保证线程安全的,假设有两个线程同时到达 synchronized 语句块,那么实例化代码只会由其中先抢到锁的线程执行一次,而后抢到锁的线程会在第二个 if 判断中发现 singleton 不为 null,所以跳过创建实例的语句。再后面的其他线程再来调用 getInstance 方法时,只需判断第一次的 if (singleton == null) ,然后会跳过整个 if 块,直接 return 实例化后的对象。

    这种写法的优点是不仅线程安全,而且延迟加载、效率也更高。

    在双重检查锁模式中为什么需要使用 volatile 关键字

    singleton = new Singleton() ,它并非是一个原子操作,

    img

    展开全文
  • Java的内存模型

    千次阅读 2019-03-11 20:36:28
      java的后端服务器开发中"高效并发"是我们经常会碰到的,而要写出高效的代码需要更多的积累与实践。而一些基础的内容是往这个方向发展的基石。所以我们就来介绍下。 硬件效率的一致性   ...

      java的后端服务器开发中"高效并发"是我们经常会碰到的,而要写出高效的代码需要更多的积累与实践。而一些基础的内容是往这个方向发展的基石。所以我们就来介绍下。

    硬件效率的一致性

      随着硬件技术的发展,处理器的处理能力越来越强大,但是与处理器交互的内存的处理能力并没有提升多少,读取运算,存储运算这些IO操作的瓶颈并没有得以消除,处理器的处理效率比内存的处理效率要高好几个数量级,在这种情况下在处理器和内存之间添加了一个高速缓存用以平衡相互关系,也就是将内存中的数据先保存到高速缓存中,处理器处理数据的时候直接从缓存中获取,处理完成后再从缓存中将数据同步回内存中。这样既不会拖累处理器,也能很好的从内存中操作数据。关系图如下:
    在这里插入图片描述

      引入高速缓存解决了处理器和内存的矛盾,但同时又产生了一个新的问题:缓存一致性,在多处理器的系统中,每个处理器都有自己的高速缓存,而他们又都共享同一主内存。当多个处理器的运算任务都涉及到同一块主内存区域时,将可能导致各自缓存数据的不一致。为了解决一致性问题,需要各个处理器访问缓存时都遵循一些协议。在读写时根据协议来操作。这里讲的"内存模型"可以理解为在特定操作协议下对特定的内存或高速缓存进行读写访问的过程抽象。java虚拟机也有自己的内存模型,接下来我们看下。

    Java内存模型

      java的内存模型规定所有的变量都存储在主内存中,每条线程都有自己的工作内存(类比上面的高速缓存)。线程的工作内存中保存了该线程使用的变量的主内存副本拷贝。线程对变量的所有操作(读取,赋值)都必须在工作内存中进行。而不能直接读写主内存中的变量,不同线程之间也无法直接访问对方工作内存中的变量。线程间变量的传递均需要通过主内存来完成。如下图
    在这里插入图片描述

    内存交互操作

      主内存和工作内存之间具体的交互协议通过以下8个操作来完成。

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

    将一个变量从主内存中复制到工作内存中,需要顺序的执行read和load操作。
    在这里插入图片描述

    如果要将变量从工作内存中同步会主内存,就要顺序的执行store和write操作如下。
    在这里插入图片描述

      内存模型要求上述两个操作必须按顺序执行,但不是连续,也就是说read和load之间、store和write之间可插入其他指令。可以出现 read a,read b,load a,load b的情况,java内存模型还要求了如下的规则,必须准守。

    1. 不允许read和load、store和write操作之一单独出现,即不允许一个变量从主内存读取了但工作内存不接受或者从工作内存发起回写但主内存不接受的情况。
    2. 不允许一个线程丢弃它的最近的assign操作。即变量在工作内存中改变了之后必须把变化同步会主内存。
    3. 不允许一个线程无原因滴(没有发生任何assign操作)把数据从线程的工作内存同步会主内存中。
    4. 一个新的变量只能在主内存中“诞生”,不允许在工作内存中直接使用一个未被初始化的变量。换句话说就是在对一个变量use、store操作之前必须先执行过了assign和load操作
    5. 一个变量在同一时刻只允许一条线程对其进行lock操作,但lock操作可以被同一条线程重复执行多次,多次执行lock后,只要执行相同次数的unlock操作,变量才会被解锁。
    6. 如果对一个变量执行lock操作,将会清空工作内存中此变量的值,在执行引擎是哟欧这个变量之前需要重新执行load或者assign操作初始化变量的值。
    7. 如果一个变量没有被lock操作锁定,那么就不允许对它执行unlock操作,也不允许去unlock一个被其他线程锁定住的变量。
    8. 对一个变量执行unlock操作之前,必须先把此变量同步回主内存中(store,write操作)

    以上八条就是Java内存模型的操作规则。

    参考《深入理解Java虚拟机》

    展开全文
  • 走近Java的内存模型1.为什么要有内存模型1.1 计算机内存模型 相信大家在网上也看到过很多Java内存模型的文章,但很多人可能和我一样读完之后还是没有理解。作为一名Java小白,经过一段时间的学习,对Java内存模型...


    相信大家在网上也看到过很多Java内存模型的文章,但很多人可能和我一样读完之后还是没有理解。作为一名Java小白,经过一段时间的学习,对Java内存模型有所了解。本篇文章,就来系统整体的对Java内存模型作以解释。目的也非常简单,希望大家读完后能知道Java内存模型是什么,为什么要用Java内存模型,以及Java内存模型可以解决什么问题等。


    1.为什么要有内存模型

    在介绍Java内存模型时,首先我们需要了解计算机的内存模型,因为Java内存模型是在计算机内存模型基础上进行增加的。


    1.1 计算机内存模型

    计算机在执行程序时,每条指令都是在CPU中执行的,而执行的时候,又免不了要与数据进行交互。计算机上面的数据,是存放在主存中的,也就是计算机的物理内存。
    随着CPU技术的发展,CPU的执行速度执行速度越来越快,而由于内存的技术没有太大的变化,所以从内存中读取与写入数据的速度与CPU的执行速度相比起来差距越来越大,导致CPU每次操作内存都要耗费很多的等待时间。
    于是,就有了在CPU与主存之间增加高速缓存的想法。缓存的概念可以理解为保存一份数据拷贝,特点是速度快、体积小。

    这时当程序运行时,会将运算需要的数据从主存中复制一份到CPU的高速缓存中,那么CPU进行计算时就可以直接从高速的缓存读取数据以及写入数据,当运算结束后,再将高速缓存中的数据再刷新回主存中。

    在多路处理器系统中,每个处理器都有自己的高速缓存,而它们共享同一主存。如下图:

    在这里插入图片描述

    • 程序执行时,把需要用到的数据,从主内存拷贝一份到高速内存中
    • CPU处理器计算时,把它从高速的缓存中先进行读取,然后把计算完的数据写入高速缓存
    • 当程序计算结束后,把高速缓存的数据刷新回主内存

    随着CPU的能力不断增加,一层缓存就慢慢无法满足要求,就逐渐衍生出多级缓存。

    按照数据读取顺序与CPU结合的紧密程度,CPU缓存可以分为一级缓存(L1)、二级缓存(L2)、三级缓存(L3)。
    在这里插入图片描述
    有了多级缓存之后,程序的执行就变为:当CPU要读取一个数据时,首先需要从一级缓存中进行查找,如果没有找到再从二级缓存中查找,如果还是没有就从三个缓存或内存中查找。

    随着计算机能力的不断提升,开始支持多线程,下面我们来分析下单线程、多线程在单核CPU、多核CPU中的影响。

    **单线程**CPU的核心的缓存只被一个线程所访问。缓存独占,不会发生访问冲突等问题。
    
    **CPU,多线程**。进程中的多个线程会同时访问进程的共享数据,CPU将某个内存加载到
    缓存中后,不同线程在访问相同的物理地址时,都会映射到相同的缓存位置,这样即使发生
    线程的切换,缓存都不会失效。由于任意一个时刻只有一个线程在执行,所以不会发生访问冲突。
    

    多核CPU,多线程。每个核至少有一个一级缓存(L1)。多个线程访问进程中的某个共享内存,多个线程分别在不同的核心上进行执行,每个核心都会在各自的caehe中保存一份共享内存的缓冲。这样可能就会出现多个线程同时写各自缓存的内容,而各自的缓存之间的数据就有可能不同。

    在CPU与主存之间增加缓存,在多线程场景下就可能存在缓存一致性问题。也就是说,在多核CPU中,每个核自己缓存中,关于同一个数据缓存的内容可能不一致。


    1.2 解决缓存不一致问题的方案

    当多个处理器的计算任务都涉及同一块主内存区域,可能会导致缓存不一致问题。如何解决这个问题呢?有两种解决方案:

    1.通过总线加Lock锁的方式解决缓存不一致的问题
    
    2.通过缓存一致性协议来解决缓存不一致问题
    

    方式一:总线加Lock锁的方式

    总线(Bus)是计算机各种功能部件之间传送信息的公共的通信干线,它是由导线组成的传输线束,按照计算机所传输的信息种类,计算机的总线可以划分为数据总线、地址总线和控制总线,分别用于传输数据、数据地址和控制信号。

    CPU和其他功能部件是通过总线进行通信的,如果在总线加Lock锁,那么锁住总线期间,其他CPU是无法访问内存的,这样一来,效率就低了。

    方式二:缓存一致性协议

    为了解决缓存一致性问题,还可以通过缓存一致性协议。即各个处理器访问缓存时都遵循了一些协议,在读写的时候需要根据读写协议来进行操作。

    其中缓存一致性协议最有名的是: Intel的MESI(Modified Exclusive Shared Or Invaild)协议,协议的操作思想为:当CPU写数据时,如果发现操作的变量为共享变量,即在其他CPU也存在该变量的副本,会发出信号去通知其他CPU将变量的缓存行置为无效状态。因此当其他CPU需要读取这个变量时,发现自己缓存中缓存该变量的缓存行是无效的,那么就会从内存重新读取。


    2.Java内存模型(JMM)的实现

    前面介绍过计算机内存模型,这是解决多线程场景下并发问题的一个重要规范。那么具体的实现是如何的呢,不同的编程语言,在实现上可能有所不同。

    • Java虚拟机规范试图定义一种内存模型,来屏蔽掉各种硬件和操作系统的内存访问差异,以实现让Java程序在各种平台上都能达到一致的内存访问效果。
    • Java内存模型类比于计算机内存模型。
    • 为了更好的执行性能,java内存模型并没有限制引擎使用处理器的特定寄存器或缓存来和主内存进行交互,也没有限制编译器进行调整代码顺序优化。所以Java内存模型会存在缓存一致性问题和指令重排序问题
    • Java内存模型规定所有的变量都是存在主内存当中(类似于计算机模型中的物理内存),每个线程都有自己的工作内存(类似与计算机模型的高速缓存)。这里的变量包含实例变量和静态常量,但是不包含局部变量,因为局部变量是线程私有的。
    • 线程的工作内存保存了该线程使用的变量的主内存副本,线程对变量的操作都必须在工作内存中进行,而不能直接操作主内存。并且每个线程不能访问其他线程的工作内存。

    在这里插入图片描述
    举个例子,假设i的初始值为0,执行以下语句:

    i=i+1;

         首先,线程t1从主内存中读取到i=0,到工作内存。然后在工作内存中,赋值i+1,工作
      内存就得到i=1,最后把结果再写回主内存。因此,若是单线程,此语句执行是没有问题的。
      但是,线程t2的本地工作内存还没有过期,那么它读到的数据就是脏数据(脏数据一般是指
      不符合要求以及不能直接进行相应分析的数据。在常见的数据挖掘工作中,脏数据包括:
      缺失值、异常值、不一致的值、重复数据及含有特殊符号的数据)了。
    

    Java内存模型是围绕着如何在并发过程中解决**【原子性、可见性、有序性】**这3个特征来建立的。而这第三个特征是并发编程的3个特性。


    原子性

    原子性,指操作是不可中断的,要么执行完成,要么不执行。基本数据类型的访问和读写都是具有原子性。
    我们可以通过下面例子来深刻体会原子性:

    i=23;            //语句1
    i=j ;           //语句2
    i=i+1;         //语句3
    i++;         //语句4
    
    • 语句1操作显然是原子性的,将数值23赋值给i,即线程执行这个语句时,直接将数值23写入工作内存中。
    • 语句2操作看起来也是原子性的,但它实际上涉及两个操作,先去读j的值,再把j的值写入工作内存,两个操作分开都是原子操作,但是合起来就不满足原子性。
    • 语句3读取i的值,加1,再写回主存,这个就不是原子性操作了。
    • 语句4等同于语句3,也是非原子性操作。

    在Java中可以使用synchronized关键字来保证方法与代码块中的操作是原子性的。


    可见性

    • 可见性就是指一个线程修改共享变量的值,其他线程能够立即得到这个修改
    • Java内存模型是通过在变量修改后将新值同步到主内存中,在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现可见性,无论是普通变量还是volatile变量都是如此。
    • volatile变量,保证新值能立即同步到主内存中,以及每次使用前立即从主内存中进行刷新。所以我们说volatile关键字保证了多线程操作变量的可见性。
    • synchronized和Lock也能保证可见性,线程在释放锁之前,会把共享变量值都刷回主内存。final也可以实现可见性。

    有序性

    在Java中,可以使用synchronized和volatile来保证多线程之间操作的有序性。

    • 实现方式有所区别:volatile关键字会禁止指令重排。synchronized关键字保证同一时刻只允许一条线程来操作。

    这里简单介绍了java并发编程中解决原子性、可见性、以及有序性可以使用的关键字。大家似乎可以发现,好像synchronized关键字是万能的,它可以同时满足三个特性,这其实也是很多滥用synchronized的原因。

    注意:synchronized是比较影响性能的,虽然编译器提供了很多锁优化技术,但是不建议过度使用。


    总结

    相信大家读取本文后,对于Java内存模型会有所了解,有兴趣的朋友也可以通过《深入理解Java虚拟机》和《Java并发编程的艺术》了解更多哟。
    在这里插入图片描述

    展开全文
  • java的内存模型(JMM) 参考:https://blog.csdn.net/hollis_chuang/article/details/80880118  JMM是多线程并发的概念,他描述了一组规范,这个规范定义了一个线程对共享变量的写入对另一个线程是可见的  Java的...
  • java的内存模型,jvm内存结构和java对象模型对比http://www.hollischuang.com/archives/2509java的内存模型(JMM)https://blog.csdn.net/hollis_chuang/article/details/80880118 JMM是多线程并发的概念,他描述了一...
  • 这两天看Java的内存模型,越看越迷糊,到底Java文件里的方法区是如何存储的,又是如何管理的呢?
  • Java的内存模型和线程安全

    千次阅读 2019-06-23 00:40:37
    Java的内存模型和线程安全 计算机指令的特性 原子性指的是一个操作是不可中断的,即使是在多线程一起执行的时候,一个操作一旦开始,就不会被其他线程所干扰。指令都是具有原子性。 有序性,计算机在运行程序的时候...
  • Java的内存模型(一)

    2017-10-23 20:30:11
    JMM是Java的内存模型。内存,其实说简单点儿就是指,当我们在完成一个任务的时候,需要为它腾出的一个地方,Java的内存就是指运行Java程序的那一块儿地方。Java程序里面有很多的东西,变量,方法,对象实例,方法...
  • Java的内存模型分析

    2014-09-29 13:48:43
    Java的内存模型 我们知道,计算机CPU和内存的交互是最频繁的,内存是我们的高速缓存区,用户磁盘和CPU的交互,而CPU运转速度越来越快,磁盘远远跟不上CPU的读写速度,才设计了内存,用户缓冲用户IO等待导致CPU的...
  • 各种的查找资料,发现造成线程的安全与否好像跟java的内存模型有一定的联系,于是就决定学习这一部分的内容,下面就来一起认识一下java的内存模型,谈谈我对java内存 的理解。 1.什么是java的内存模型?他要解决的...
  • JMM Java的内存模型

    2010-03-07 19:12:00
    Java的内存模型JMM(Java Memory Model)JMM主要是为了规定了线程和内存之间的一些关系。根据JMM的设计,系统存在一个主内存(Main Memory),Java中所有实例变量都储存在主存中,对于所有线程都是共享的。每条线程都...
  • java的内存模型是什么意思 有什么作用 如何理解 如何学习 注意哪些
  • java的内存模型与volatile关键字详解

    千次阅读 2017-02-05 10:19:48
    由于各种硬件及操作系统的内存访问差异,java虚拟机使用java内存模型java Memory Model,JMM)来规范java对内存的访问。这套模型在jdk 1.2中开始建立,经jdk 1.5的修订,现已逐步完善起来。什么是java内存模型什么...
  • java的内存模型与线程

    2015-11-08 10:46:02
    首先介绍一下从硬件的效率与一致性说一一下操作系统的内存模型: cpu的执行速度与内存的读取的速度不是一个数量级的,因此,为了提高CPU的利用率,提出了高速缓存,将内存的数据首先放到高速缓存,每...java的内存
  • Akka学习笔记(五):Akka与Java的内存模型 Akka简化了编写并发软件的过程,本文主要讨论Akka如何在并发应用中访问共享内存。 Java内存模型 Java5之前的JMM是相当混乱的。多线程访问共享内存很有可能会得...
  • 谈谈java的内存模型

    2013-05-09 13:29:27
    简单来讲,就是jvm帮你管理你的内存分配与回收,不需要你去像c++中一样需要自己delete内存。  需要注意的几点: 1. jvm只负责与内存相关的资源的管理,其他的不属于jvm的范畴,需要你自己去控制。 e.g.文件...
  • 我总结出了很多互联网公司面试题...推荐文章:Java 面试知识点解析;Mysql优化技巧(数据库设计、命名规范、索引优化 今天周末,闲来无事,干嘛呢?当然看书啊,总结啊!读完书光回想是没用,必须有个自己...
  • ThreadLocal含义 ThreadLocal意为线程局部...这里我们对比下普通变量在多线程的情况下所产生的线程安全问题,当多个线程对同一内存区域的数据进行运算时即会产生线程安全问题,这也正是线程的内存模型所导致的!下...
  • 对于从没听说过Erlang人来说,有必要简单介绍一下,它是一门函数式语言,并且使用异步消息传递作为它并发基石。消息传递使用是拷贝机制,并且在不同...两者运行时系统都通过垃圾回收来将程序员从内存管理
  • JVM内存模型如上图,需要声明一点,这是《Java虚拟机规范(Java SE 7版)》规定内容,实际区域由各JVM自己实现,所以可能略有不同。以下对各区域进行简短说明。 1.1程序计数器 程序计数器是众多编程语言都共有...
  • Java当中的内存模型 内存: code segment (存放代码) Data segment (静态变量 字符串常量) Stack 栈 (局部变量) Heap (new出来的东西) 大部分情况下都是用new关键字来创建对象(因为我们还有单例...
  • 全面理解Java内存模型

    万次阅读 多人点赞 2016-09-21 18:39:21
    Java内存模型Java Memory Model,简称JMM。JMM定义了Java 虚拟机(JVM)在...Java内存模型定义了多线程之间共享变量可见性以及如何在需要时候对共享变量进行同步。原始的Java内存模型效率并不是很理想,因此Jav
  • 第一部分:进程和程序区别 程序只是一组指令有序集合,它本身没有任何运行含义,它只是一个静态实体。而进程则不同,它是程序在某个数据集上执行。进程是一个动态实体,它有自己生命周期。它因创建而...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,468
精华内容 9,787
关键字:

java的内存模型

java 订阅