Java内存模型和线程

并发处理的广泛应用是人类“压榨”计算机运行能力的最有利武器

为啥需要并发?

  • 计算机的运行速度和其他存储和通信子系统差距太大
  • 一个服务端需要为多个客户端提供服务

硬件的效率与一致性

  • 运算任务不能只靠 CPU 来完成,现代计算机加入了读写速度尽量接近 CPU 高速缓存最为内存与处理器之间的缓冲
  • 但是带来了缓存一致性的问题(多个处理器读取同一块内存)
  • 为了解决该问题,各个处理器访问缓存时需要遵守协议(MSI,MESI,MOSI等等)
  • 除了增加高速缓存之外,处理器还会对代码进行乱序执行

Untitled Diagram (1).png

Java内存模型

  • Java 模型定义必须得足够严谨,使其并发内存访问操作不会产生歧义
  • Java 模型定义必须得足够宽松,使其可以利用硬件的各种特性

主内存与工作内存

Java 内存模型的主要目标是定义程序中各个变量的访问规则 > 变量:与 Java 编程中变量有区别,此处是指实例字段,静态字段和构成数组的对象,但不包括局部变量和方法参数

  • 所有的内存都存储在主内存(与物理硬件的主内存名字一样)
  • 每条线程还有自己的工作内存(与物理硬件的高速缓存类似)
  • 线程的工作内存保存了变量的主内存拷贝副本,对变量操作都在工作内存中,不能直接读取主内存的变量 > 副本拷贝不是整个对象拷贝,只是对象的一些引用和用到的字段 > volatile 变量依然有工作内存的拷贝,但是由于其特殊的操作顺序,所以看起来如同直接在主内存中读写访问一般

关系.png

内存间交互操作

  • 主内存与工作内存之间具体的交互协议,Java内存模型中定义了以下8种操作来完成,虚拟机实现时必须保证下面提及的每一种操作都是「原子的、不可再分」的

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

  • 如果要把变量从工作内存同步会主内存,就要顺序地执行store和write操作 > 注意,Java内存模型只要求上述两个操作必须按顺序执行 ,而没有保证是连续执行

  • ava内存模型还规定了在执行上述8种基本操作时必须满足如下规则:

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

对于volatile型变量的特殊规则

  • 关键字volatile可以说是 Java 虚拟机提供的最轻量级的同步机制
  • 当一个变量定义为volatile之后,它将具备两种特性: 保证此变量对所有线程的可见性 、禁止指令重排序优化
  • 可见性:这里的“可见性”是指当一条线程修改了这个变量的值,新值对于其他线程来说是可以立即得知的。 > 提示:Java里面的运算并非原子操作,导致volatile变量的运算在并发下一样是不安全的,可以通过一段简单的演示来说明原因:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class VolatileTest {
    public static volatile int race = 0;
    public static void increase() {
        race++;
    }
    private static final int THREADS_COUNT = 20;
    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
        //等待所有累加线程都结束
        while (Thread.activeCount() > 1)
          Thread.yield();
        System.out.println(race); //输出结果并非200000,而是每次输出的结果都不一样,都是一个小于200000的数字。
    }
}

问题就出现在自增运算“race++”上,不是原子操作。

  1. volatile变量只能保证「可见性」不能保证「原子性」,在不符合以下两条规则的运算场景中,我们仍然要通过「加锁」(使用synchronized或java.util.concurrent中的原子类)来保证「原子性」。

  2. 使用volatile变量的第二个语义是禁止「指令重排序优化」。普通的变量仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获得到正确的结果,而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。而volatile赋值后有类似内存屏障(Memory Barrier/Memory Fence),重排序时不能把后面的指令重排序到内存屏障之前的位置。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
//双重检验模式(DCL)单例模式
public class Singleton {
    private volatile static Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

通过对比生成的汇编代码可知,关键在于volatile修饰的变量,多执行了“lock addl $0x0,(%esp)”,这个lock前缀不允许配合nop指令使用,效果是前面volatile的修改

  • volatile性能:在某些情况下,volatile的同步机制的性能优于锁(synchronized关键字或者java.util.concurrent包里的锁)
    • volatile读操作的性能消耗和普通变量没什么差别
    • volatile写操作可能会慢一点,因为需要插入内存屏障指令来保证不发生乱序执行
  • Java内存模型中对volatile变量定义的特殊规则。假定T表示一个线程,V和W分别表示两个volatile型变量
    • 要求在工作内存中,每次使用V前都必须先从主内存 刷新 最新的值,用于保证能看见其他线程对变量V所做的修改后的值。
    • 要求在工作内存中,每次修改V后都必须立刻 同步 回主内存,用于保证其他线程可以看到自己对变量V所做的修改。
    • 要求volatile修饰的变量不会被指令重排序优化,保证代码的执行顺序与程序的顺序相同。

对于long和double型变量的特殊规则

  • 对于64位的数据(long和double),定义了一条相对宽松的规定:允许虚拟机实现选择可以不保证64位数据类型的load,store,read和write这四个操作的原子性(long和double的「非原子性规定」)
  • 这种情况十分罕见,目前商用的虚拟机几乎都选择64位数据的读写操作作为原子操作

原子性、可见性与有序性

  • 原子性(Atomicity) :由Java内存模型来直接保证的原子性变量操作包括read、load、assign、use、store和write,我们大致可以认为8种基本数据类型的访问读写是具备原子性的。 > 尽管虚拟机未把lock和unlock操作直接开始给用户使用,但却提供了更高层次的字节码指令monitorenter和monitorexit来隐式地使用这两个操作,这两个字节码指令反映到Java代码中就是同步块——synchronized关键字,因此在synchronized块之间的操作也具备原子性
  • 可见性(Visibility) :可见性是指当一个线程修改了共享变量的值,其他线程能够立即得知这个修改。Java内存模型是通过在变量修改后将新值同步回主内存,在变量读取前从主内存刷新变量值这种依赖主内存作为传媒介质的方式来实现可见性的。

    1. volatile 保证了多线程操作时变量的可见性。除此之外,Java还有两个关键字能实现可见性,即 synchronized 和 final 。
    2. synchronized同步块的可见性是由“对一个变量执行unlock操作之前,必须先把此变量同步回主内存中(执行store、write操作)”这条规则获得的
    3. final关键字的可见性是指:被final修饰的字段在构造器中一旦初始化完成,并且构造器没有把“this”的引用传递出去,那在其他线程中就能看见final字段的值。
  • 有序性(Ordering) :如果在本线程内观察,所有的操作都是有序的;如果在一个线程中观察另一个线程,所有的操作都是无序的。前半句是指“线程内表现为串行的语义”(Within-Thread As-If-Serial Semantics),后半句是指“指令重排序”现象和“工作内存与主内存同步延迟”现象。

    • Java语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性,
    • volatile关键字本身就包含了禁止指令重排序的语义,
    • 而synchronized则是由“一个变量在同一个时刻只允许一条线程对其进行lock操作”这条规则获得的,这条原则决定了持有同一个锁的两个同步块只能串行地进入。
  • synchronized万能的优缺点:

    • 优点:用起来方便
    • 缺点:越方便越大的性能损耗

先行发生原则

  • 下面是Java内存模型下一些“天然的”先行发生关系,无须任何同步手段:

    • 程序次序规则(Program Order Rule) :在一个线程内,按照程序代码顺序,书写在前面的操作先行发生与书写在后面的操作。准确地说,应该是控制流顺序而不是程序代码顺序,因为要考虑分支、循环等结构。
    • 管程锁定规则(Monitor Lock Rule):一个unlock操作先行发生于后面对同一个锁的lock操作。
    • volatile变量规则(Volatile Variable Rule):对一个volatile变量的 写操作 先行发生于后面对这个变量的 读操作 。
    • 线程启动规则(Thread Start Rule) :Thread对象的 start() 方法先行发生于此线程的每一个动作。
    • 线程终止规则(Thread Termination Rule) :线程中的所有操作都先行发生于对此线程的终止检测,我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测到线程已经终止执行。
    • 线程中断规则(Thread Interruption Rule):对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生,可以通过Thread.interrupted()方法检测到是否有中断发生。
    • 对象终结规则(Finalizer Rule):一个对象的初始化完成(构造函数执行结束)先行发生与它的finalize()方法的开始。
    • 传递性(Transitivity):如果操作A先行发生于操作B,操作B先行发生于操作C,那就可以得出操作A先行发生与操作C的结论。
  • 结论:“时间上先发生”与“先行发生”之间没有太大的关系 > 一切以先行发生原则进行

Java与线程

线程的实现

  • 线程是比进程更加轻量级的调度单位
  • 各个线程既可以共享进度资源(内存地址、文件I/O等),又可以独立调度( 线程是CPU调度的基本单位 )
  • 每个执行了start()的且还没有结束的Thread类的实例就代表了一个线程(所有方法都是Native的) > Java API中Native方法往往需要结合平台先关的技术
  • 实现线程主要有3种方式:
    • 使用 内核线程 实现
    • 使用 用户线程 实现
    • 使用 用户线程加轻量级进程混合实现。

使用内核线程实现

  • 内核线程(Kernel-Level Thread,KLT)就是直接由操作系统内核(Kernel)支持的线程,这种线程由内核来完成线程切换,内核通过操纵调度器(Scheduler)对线程进行调度,并负责将线程的任务映射到各个处理器上。每个内核线程可以视作内核的一个分身,支持多线程的内核就叫做多线程内核(Multil-Threads Kernel)。
  • 程序一般不会直接去使用内核线程,而是去使用内核线程的一种高级接口——轻量级进程(Light Weight Process, LWP),由于每个轻量级进程都由一个内核线程支持,因此只有先支持内核线程,才能有轻量级进程。这种轻量级进程与内核线程之间1:1的关系称为一对一的线程模型。
  • 局限性:
    • 代价高:由于是基于内核线程实现的,所以各种线程操作,如创建、析构及同步,都需要进行系统调用。而系统调用的代价相对较高,需要在用户态(User Mode)和内核态(Kernel Mode)中来回切换。
    • 数量有限:每个轻量级进程都需要有一个内核线程的支持,因此轻量级进程要消耗一定的内核资源(如内核线程的栈空间),因此一个系统支持轻量级进程的数量是有限的。

使用用户线程实现

  • 用户线程(User Thread)的建立、同步、销毁和调度完全在用户态中完成,不需要内核的帮助,这种线程不需要切换到内核态,因此操作可以是非常快速且低消耗的,也可以支持规模更大的线程数量
  • 这种进程与用户线程之间1:N的关系称为一对多的线程模型。
  • 优势在于不需要系统内核支援
  • 劣势在与没有系统内核的支援,所有的线程操作都需要用户程序自己处理。 > Java、Ruby等语言都曾经使用过用户线程,最终又都放弃使用它。

使用用户线程加轻量级进程混合实现

  • 用户线程还是完全建立在用户空间中,因此用户线程的创建、切换、析构等操作依然廉价,并且可以支持大规模的用户线程并发。而操作系统提供支持的 轻量级进程则作为用户线程和内核线程之间的桥梁,这样可以使用内核提供的线程调度功能及处理器映射,并且用户线程的系统调用通过轻量级线程来完成,大大降低了整个进程被完全阻塞的风险
  • 用户线程与轻量级进程的数量比是不定的,即为N:M的关系,称为多对多的线程模型。

Java线程的实现

  • 基于操作系统原生线程模型:
    • 对于Sun JDK来说,它的Windows版与Linux版都是使用 一对一的线程模型 实现的,一条Java线程就映射到一条轻量级进程之中。
    • 而在Solaris平台中,同时支持一对一和多对多。

Java线程调度

  • 线程调度是指系统为线程分配处理器使用权的过程,主要调度方式有两种,分别是 协同式线程调度(Cooperative Threads-Scheduling)抢占式线程调度(Preemptive Threads-Scheduling)
    • 协同式调度:线程的执行时间由线程本身来控制 ,线程把自己的工作执行完了之后,要主动通知系统切换到另一个线程上。实现简单,没有线程同步问题,但线程执行时间不可控制,可能导致阻塞。Lua语言的“协同例程”就是这类实现。
    • 抢占式调度:每个线程将由系统来分配执行时间 ,线程的切换不由线程本身来决定(在Java中,Thread.yield()可以让出执行时间,但是要获取执行时间的话,线程本身是没有什么办法的)。线程的执行时间可控,也不会有一个线程导致整个进程阻塞的问题。 Java使用抢占式调度
  • Java语言一共设置了10个级别的线程优先级(Thread.MIN_PRIORITY至Thread.MAX_PRIORITY),在两个线程同时处于Ready状态 时,优先级越高的线程越容易被系统选择执行。 > 并不是很靠谱,操作系统的优先级不一定是10个,就无法一一对应,再者,优先级可能会被系统自动改变。

状态转换

  • Java语言定义了5种线程状态(与操作系统定义的线程状态有所不同),在任意一个时间点,一个线程只能有且只有其中的一种状态。
    • 新建(New) :创建后尚未启动的线程处于这种状态。
    • 运行(Runable) :Runable包括了操作系统线程状态中的RunningReady,也就是处于此状态的线程有可能正在执行,也有可能正在等待着CPU为它分配执行时间。
    • 无限期等待(Waiting) :处于这种状态的线程不会被分配CPU执行时间,它们要等待被其他线程显示地唤醒 。以下方法会让线程陷入无限期的等待状态:
      • 没有设置Timeout参数的Object.wait()方法
      • 没有设置Timeout参数的Thread.join()方法
      • LockSupport.park()方法
    • 限期等待(Timed Waiting) :处于这种状态的线程 也不会 被分配CPU执行时间,不过在一定时间之后它们会由系统自动唤醒。以下方法会让线程进入限期等待状态:
      • Thread.sleep()方法
      • 设置了Timeout参数的Object.wait()方法
      • 设置了Timeout参数的Thread.join()方法
      • LockSupport.parkNamos()方法
      • LockSupport.parkUntil()方法
    • 阻塞(Blocked) :线程被阻塞了,“阻塞状态”与“等待状态”的区别是:“阻塞状态”在等待着获取到一个排他锁。这个事件将在另外一个线程放弃这个锁的时候发生;而“等待状态”则是在等待一段时间,或者唤醒动作的发生。 在程序等待进入同步区域的时候,线程将进入这种状态。
    • 结束(Terminated) :已终止线程的线程状态,线程已经结束执行。