栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java并发编程的艺术阅读笔记

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java并发编程的艺术阅读笔记

Java并发编程的艺术 一、并发编程的挑战

上下文切换

任务从保存到再加载的过程就是一次上下文切换

CPU通过给每个线程分配CPU时间片来实现支持多线程执行代码。时间片是CPU分给各个线程的时间,因为时间片非常短,所以CPU通过不停地切换线程执行,让我们感觉多个线程是同时执行的。

多线程一定快吗?

不一定,线程有创建和上下文切换的开销

如何减少上下文切换?

  • 无锁并发编程:使用一些方法来避免使用锁
  • CAS算法
  • 使用最少线程:避免创建不需要的线程
  • 协程:在单线程里实现多任务的调度,并在单线程里维持多个任务间的切换
二、Java并发机制的底层实现原理

Java代码在编译后会变成Java字节码,字节码被类加载器加载到JVM里,JVM执行字节码,最终需要转换为汇编指令在CPU上执行,Java所使用的并发机制依赖于JVM的实现和CPU的指令。

2.1 volatile的应用

volatile 是轻量级的 synchronized,保证共享变量的可见性。可见性的意思是当一个线程修改一个共享变量时,另外一个线程能读到这个修改的值。

如果一个字段被声明称volatile,Java线程内存模型保证所有线程看到这个变量是一致的。

实现原理

下列代码通过工具获取JIT编译器生成的汇编指令

public volatile Singleton instance = new Singleton();

如下:

0x01a3de1d: movb $0×0,0×1104800(%esi);0x01a3de24: lock addl $0×0,(%esp);

我们会发现如果使用volatile修饰的变量会多出上面这一条指令,Lock前缀的指令在多核处理器下会引发了两件事情:

  • 将当前处理器缓存行的数据写回到系统内存
  • 这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效

为了提高处理速度,处理器不直接和内存进行通信,而是先将系统内存的数据读到内部缓存(L1,L2或其他)后再进行操作,但操作完不知道何时会写到内存。如果对声明了volatile的变量进行写操作,JVM就会向处理器发送一条Lock前缀的指令,将这个变量所在缓存行的数据写回到系统内存。但是,就算写回到内存,如果其他处理器缓存的值还是旧的,再执行计算操作就会有问题。所以,在多处理器下,为了保证各个处理器的缓存是一致的,就会实现缓存一致性协议,每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了,当处理器发现自己缓存行对应的内存地址被修改,就会将当前处理器的缓存行设置成无效状态,当处理器对这个数据进行修改操作的时候,会重新从系统内存中把数据读到处理器缓存里。

  • **处理器使用嗅探技术保证它的内部缓存、系统内存和其他处理器的缓存的数据在总线上保持一致。**例如,在Pentium和P6 family处理器中,如果通过嗅探一个处理器来检测其他处理器打算写内存地址,而这个地址当前处于共享状态,那么正在嗅探的处理器将使它的缓存行无效,在下次访问相同内存地址时,强制执行缓存行填充。
  • 锁住总线:使其他CPU不能访问总线,不能访问总线就意味着不能访问系统内存。(在最近的处理器里,LOCK#信号一般不锁总线,而是锁缓存,毕竟锁总线开销的比较大)
  • 缓存锁定:它会锁定这块内存区域的缓存并回写到内存,并使用缓存一致性机制来确保修改的原子性,缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据。
2.2 synchronized的实现原理

(102条消息) Java并发编程的艺术读书笔记(第二章)__changeme的博客-CSDN博客

Java中的每一个对象都可以作为锁,具体表现为以下3种形式。

  • 对于普通同步方法,锁是当前实例对象

  • 对于静态同步方法,锁是当前类的Class对象

    synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令,取得代之的确实是
    ACC_SYNCHRONIZED 标识,该标识指明了该方法是一个同步方法,JVM 通过该ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法,从而执行相应的同步调用。

  • 对于同步方法块,锁是Synchonized括号里配置的对象

    synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令,其中 monitorenter 指令指向同步代码块的开始位置,monitorexit 指令则指明同步代码块的结束位置。 当执行 monitorenter 指令时,线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中,synchronized 锁便是通过这种方式获取锁的,也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取,获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后,将锁计数器设为0,表明锁被释放。如果获取对象锁失败,那当前线程就要阻塞等待,直到锁被另外一个线程释放为止。

Java对象头

synchronized用的锁是存在Java对象头里的。

Mark Word的状态变化:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0ilefWwl-1654791261780)(assets/艺术20190825230309751.jpg)]

Mark Word的存储结构 :

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W6FiAFJA-1654791261782)(assets/艺术20190825230321268.jpg)]

锁的升级与对比

锁一共有4种状态,级别从低到高依次是:无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态,这几个状态会随着竞争情况逐渐升级。锁升级却不能降级的策略,目的是为了提高获得锁和释放锁的效率。

偏向锁

大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,为了让线程获得锁的代价更低而引入了偏向锁。当一个线程访问同步块并获取锁时,会在对象头和栈帧中的锁记录里存储锁偏向的线程ID,以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁,只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。

偏向锁的获取

  • 线程A第一次访问同步代码块时,先检查对象头Mark Word中锁标志位是否为01,依此判断此时对象是否处于无锁状态或者偏向锁状态
  • 若锁标志位是为01,然后判断偏向锁的标识是否为1
    • 如果是,表明此对象是偏向锁状态,则进行下一步流程
    • 如果不是,表明此对象是无锁状态,则进入轻量级锁逻辑(使用CAS竞争锁) (注意:此时不是使用CAS尝试获取偏向锁,而是直接升级为轻量级锁;原因是:当偏向锁的标识为0时,表明偏向锁在此对象上被禁用,禁用原因可能是JVM关闭了偏向锁模式,或该类刚经历过bulk revocation,等等。所以应该入轻量级锁逻辑)
  • 判断是偏向锁时,检查对象头Mark Word中记录的ThreadID是否是当前线程A的ID
    • 如果是,则表明当前线程A已经获得过该对象锁,以后线程A进入同步代码块时,不需要CAS进行加锁,只会往当前线程A的栈中添加一条Displaced Mark Word为空的Lock Record,用来统计重入的次数
    • 如果不是,则进行CAS操作,尝试将当前线程A的ID替换进Mark Word
      • 如果当前对象锁的ThreadID不为0,即该对象锁已经被其他线程B占用了,则会替换失败,开始进行偏向锁撤销。这也是偏向锁的特点,一旦出现线程竞争,就会撤销偏向锁。
      • 如果当前对象锁的ThreadID为0(匿名偏向锁状态),则会替换成功(将Mark Word中的Thread id由匿名0改成当前线程A的ID,在当前线程A栈中找到内存地址最高的可用Lock Record,将线程A的ID存入),获得到锁,执行同步代码块。

偏向锁的撤销

偏向锁使用了一种等到竞争出现才释放锁的机制,所以当其他线程尝试竞争偏向锁时,持有偏向锁的线程才会释放锁。

  • 偏向锁的撤销需要等待全局安全点(safe point,代表了一个状态,在该状态下所有线程都是暂停的,stop-the-world),到达全局安全点后,持有偏向锁的线程B也被暂停了。
  • 检查持有偏向锁的线程B的状态(会遍历当前JVM的所有线程,如果能找到线程B,则说明偏向的线程B还存活着),检查偏向锁线程是否处于同步块。栈中的锁记录和对象头的Mark Word要么重新偏向于其他线程,要么恢复到无锁或者标记对象不适合作为偏向锁 。
    • 已退出同步块:将锁置于无锁状态,重新偏向,偏向为抢锁线程。
    • 处于同步块:将锁升级为轻量级锁,继续执行原线程1的代码,线程2自旋来获取锁对象
  • 唤醒暂停的线程,从安全点继续执行代码
轻量级锁

Java synchronized轻量级锁的核心原理详解-云海天教程 (yht7.com)

轻量级锁在对象内存布局中 MarkWord 锁标志位为 00,它可以由偏向锁对象因存在多个线程访问而升级成轻量级锁,当然,轻量级锁也可能因多个线程同时访问同步代码块升级成重量级锁。

执行过程

  • 在抢锁线程进入临界区之前,如果内置锁没有被锁定,JVM首先将在抢锁线程的栈帧中建立一个锁记录(Lock Record),每个线程都的栈帧都会包含一个锁记录的结构,内部可以存储锁定对象的mark word

  • 抢锁线程将使用CAS自旋操作,尝试将内置锁对象头的mark word的ptr_to_lock_record(锁记录指针)更新为抢锁线程栈帧中锁记录的地址,如果这个更新执行成功了,这个线程就拥有了这个对象锁。然后jvm将mark word中的lock标记位改为00,即表示该对象处于轻量级锁状态。

    抢锁成功之后,jvm会将mark word中原来的锁对象信息(如哈希码等)保存在抢锁线程锁记录的Displaced Mark Word字段中,再将抢锁线程中锁记录的owner指针指向锁对象 。

    在轻量级锁抢占成功之后,锁记录和对象头的状态如图所示:

    锁记录是线程私有的,每个线程都有自己的一份锁记录,在创建完锁记录后,会将内置锁对象的Mark Word复制到锁记录的Displaced Mark Word字段。这是为什么呢?因为内置锁对象的mark word的结构会有所变化,mark word将会出现一个指向锁记录的指针,而不再存着无锁状态下的锁对象哈希码等信息,所以必须将这些信息暂存起来,供后面在锁释放时使用。

  • 如果 cas 失败,有两种情况:

    • 如果是其它线程已经持有了该 Object 的轻量级锁,这时表明有竞争,那么此时当前线程只有通过自旋的方式去获取锁。如果在自旋一定次数后仍未获得锁,那么轻量级锁将会升级成重量级锁。

    • 如果是自己执行了 synchronized 锁重入,那么再添加一条 Lock Record 作为重入的计数;

  • 当退出 synchronized 代码块(解锁时)如果有取值为 null 的锁记录,表示有重入,这时重置锁记录,表示重入计数减一

  • 当退出 synchronized 代码块(解锁时)锁记录的值不为 null,这时使用 cas 将 mark word的值恢复给对象头

    • 成功,则解锁成功
    • 失败,说明轻量级锁进行了锁膨胀或已经升级为重量级锁,进入重量级锁解锁流程(在释放锁的同时,唤醒被挂起的线程)

轻量级锁的膨胀

虽然大部分临界区代码的执行时间都是很短的,但是也会存在执行得很慢的临界区代码。临界区代码执行耗时较长,在其执行期间,其他线程都在原地自旋等待,会空消耗CPU。因此,如果竞争这个同步锁的线程很多,就会有多个线程在原地等待继续空循环消耗CPU(空自旋),这会带来很大的性能损耗。

轻量级锁的本意是为了减少多线程进入操作系统底层的互斥锁的概率,并不是要替代操作系统互斥锁。所以,在争用激烈的场景下,轻量级锁会膨胀为基于操作系统内核互斥锁实现的重量级锁。

如果在尝试加轻量级锁的过程中,CAS 操作无法成功,这时一种情况就是有其它线程为此对象加上了轻量级锁(有 竞争),这时需要进行锁膨胀,将轻量级锁变为重量级锁。

  • Thread-1 进行轻量级加锁时,Thread-0 已经对该对象加了轻量级锁

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AqBaOVWA-1654791261784)(assets/艺术1652172200319.png)]

  • 这时 Thread-1 加轻量级锁失败,进入锁膨胀流程,即为锁对象申请 Monitor 锁,让锁对象指向重量级锁地址,然后自己进入 Monitor 的 EntryList BLOCKED

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pqxsaQwO-1654791261785)(assets/艺术1652172218487.png)]

  • 当 Thread-0 退出同步块解锁时,使用 cas 将mark word的值恢复给对象头,失败。这时会进入重量级解锁 流程,即按照 Monitor 地址找到 Monitor 对象,设置 Owner 为 null,唤醒 EntryList 中 BLOCKED 线程。

全过程

总体来说,偏向锁是在没有发生锁争用的情况下使用的;一旦有了第二个线程争用锁,偏向锁就会升级为轻量级锁;如果锁争用很激烈,轻量级锁的CAS自旋到达阈值后,轻量级锁就会升级为重量级锁。

2.3 原子操作的实现原理

原子操作意为不可被中断的一个或一系列操作

处理器如何实现原子操作

使用总线锁保证原子性

  • 问题:多个处理器同时对共享变量进行读改写操作时,操作完之后共享变量的值会和期望的不一致。如i++,处理器1和处理器2同时从各自的缓存中读取变量 i,分别进行加1操作,然后分别写入系统内存中,结果可能是2,而预期的是3。想要保证读改写共享变量的操作是原子的,就必须保证 CPU1 读改写共享变量的时候,CPU2 不能操作缓存了该共享变量内存地址的缓存
  • 解决:总线锁就是使用处理器提供的一个 LOCK# 信号,当一个处理器在总线上输出此信号时,其他处理器的请求将被阻塞住,那么该处 理器可以独占共享内存

使用缓存锁保证原子性

  • 总线锁定把 CPU 和内存之间的通信锁住了,这使得锁定期 间,其他处理器不能操作其他内存地址的数据,所以总线锁定的开销比较大
  • 缓存一致性机制就整体来说,是当某块CPU对缓存中的数据进行操作了之后,就通知其他CPU放弃储存在它们内部的缓存,从内存中重新读取
Java如何实现原子操作

在 Java 中可以通过锁和循环CAS 的方式来实现原子操作

使用循环CAS
private AtomicInteger atomicI = new AtomicInteger(0);
private int i = 0
    
//使用 CAS 实现线程安全计数器
private void safeCount() {
     for (; ; ) {
         int i = atomicI.get();
         boolean suc = atomicI.compareAndSet(i, ++i);
         if (suc) {
            break;
         }
     }
}
//非线程安全计数器
private void count() {
 i++;
}
CAS实现原子操作的三大问题
  • ABA问题:若共享变量修改过程为A->B->A,进行CAS操作时,虽然值发生过更改,但又变成了预期值。解决方法是在变量前追加版本号,1A->2B->3A。
  • 循环开销时间长:自旋CAS如果长时间不成功,会给CPU带来很大的开销
  • 只能保证一个原子变量的原子操作:CAS无法保证对多个共享变量的原子操作
三、Java内存模型 3.1 Java内存模型的基础 并发编程模型的两个关键问题

问题:线程之间如何通信、线程之间如何同步

通信:线程是指线程之间以何种机制来交换信息。

两种模型:在共享内存的并发模型里,线程之间共享程序的公共状态,通过写-读内存中的公共状态进行隐式通信,同步是显式的;在消息传递的并发模型里,线程之间没有公共状态,线程之间必须通过发送消息来显式进行通信,但同步是隐式进行的。

Java中使用的是共享内存模型

Java 内存模型的抽象结构

共享:所有的实例域、静态域、数组元素都在堆内存中,堆内存是在线程间共享的(这些被称为共享变量)

不共享:局部变量、方法定义参数、异常处理参数

内存划分:可以抽象的分成主内存和本地内存,共享变量是存放在主内存的,本地内存存放共享变量的副本,缓存、写缓冲区、寄存器、其他的硬件和编译器优化都在本地内存中。

JMM 决定一个线程对共享变量的写入何时对另一个线程可见。

Java内存模型的抽象结构示意图:

如果线程 A 与线程 B 之间要通信的话:

  • 线程 A 把本地内存 A 中更新过的共享变量刷新到主内存中去
  • 线程 B 到主内存中去读取线程 A 之前已更新过的共享变量。
从源代码到指令序列的重排序
  • 目的:提高性能。

  • 流程:从源代码到最终执行的指令序列,分别经历下面三种重排序:

    源代码 -> 1:编译器优化重排序 -> 2:指令级并行重排序 -> 3:内存系统重排序 -> 最终执行的指令序列

    第一个是编译器重排序,二三是处理器重排序。重排序可能会导致多线程程序出现内存可见性问题。

并发编程模型的分类

处理器对内存的读/写操作的执行顺序,不一定与内存实际发生的读/写操作顺序一致

例子:

内存实际的发生顺序:顺序为A2(从主存中读a=0)—>A1(a=1),直到处理器A执行A3来刷新自己的写缓冲区,写操作A1(即a=1)才真正执行,a最后刷新到主存的值为1;

而处理器A执行内存操作的顺序为A1—> A2,导致a最后刷新到主存的值为0,程序可以得到x=0,y=0的结果(而这并不是我们想要的)。

现代的处理器都会允许对写-读操作进行重排序,常见的处理器不允许对存在数据依赖的操作做重排序。

happens-before 简介

在JMM中,如果一个操作的执行结果需要对另一个操作可见,那么这两个操作之间必须存在happens-before关系。

规则如下:

  • 程序顺序规则:一个线程中的每个操作,happens-before 于该线程中的任意后续操作
  • 监视器锁规则:对一个锁的解锁,happens-before 于随后对这个锁的加锁
  • volatile 变量规则:对一个 volatile 域的写,happens-before 于任意后续对这个 volatile 域的读
  • 传递性:如果 A happens-before B,且 B happens-before C,那么 A happens-before C

注意:两个操作之间具有 happens-before 关系,并不意味着前一个操作必须要在后一个操作之前执行!happens-before 仅仅要求前一个操作(执行的结果)对后一个操作可见,且前一个操作按顺序排在第二个操作之前。

3.2 重排序

重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段

数据依赖性

如果两个操作访问同一个变量,且这两个操作中有一个为写操作,此时这两个操作之间就存在数据依赖性。数据依赖分为下列3种类型:

编译器和处理器在重排序时,会 守数据依赖性,编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。

as-if-serial 语义

不管怎么重排序(编译器和处理器为了提高并行度),(单线程)程序的执行结果不能被改变

double pi = 3.14;
double r = 1.0;
double area = pi * r * r;

A 和 C 之间存在数据依赖关系,B 和 C 之间也存在数据依赖关系。因此在最终执行的指令序列中,C 不能被重排序到 A 和 B 的前面。但 A 和 B 之间没有数据依赖关系,编译器和处理器可以重排序 A 和 B 之间的执行顺序,易知程序的执行结果一致。

程序顺序规则

如上存在的3个happens-before :

A happens-before B、B happens-before C、A happens-before C(由传递性推导出来)。 只要不影响程序执行结果,咋排都行。在计算机中,软件技术和硬件技术有一个共同的目标:在不改变程序执行结果的前提下,尽可能提高并行度。

重排序对多线程的影响
class ReorderExample {
     int a = 0;
     boolean flag = false;
     public void writer() {
         a = 1; // 1
         flag = true; // 2
     }
     public void reader() {
         if (flag) { // 3
             int i = a * a; // 4
             ……
         }
     }
}

操作 1 和操作 2 没有数据依赖关系 ,操作 3 和操作 4 也没有数据依赖关系。如果对操作1和2做重排序,程序执行:2(线程A) —> 3(线程B) —> 4(线程B)—> 1(线程A),线程B执行操作4时,不一定能看到线程A在操作1对共享变量a的写入。

对多线程影响:单线程程序中,对存在控制以来的操作重排序,不会影响结果;多线程中,对存在控制依赖的操作重排序,可能会改变程序的执行结果。

3.3 顺序一致性 数据竞争与顺序一致性

当程序未正确同步时,就可能会存在数据竞争(在一个线程中写一个变量,在另一个线程读同一个变量,而且写和读没有通过同步来排序 )。如果程序是正确同步的,程序的执行将具有顺序一致性——即程序的执行结果与该程序在顺序一致性内存模型中的执行结果相同。

顺序一致性内存模型

两大特性:

  • 一个线程中的所有操作必须按照程序的顺序来执行
  • (不管程序是否同步)所有线程都只能看到一个单一的操作执行顺序。在顺序一致性内存模型中,每个操作都必须原子执行且立刻对所有线程可见

顺序一致性内存模型视图:

假设有两个线程 A 和 B 并发执行。其中 A 线程有 3 个操作,它们在程序中的顺序 是: A1→A2→A3。B 线程也有 3 个操作,它们在程序中的顺序是:B1→B2→B3:

假设这两个线程使用监视器锁来正确同步:A 线程的 3 个操作执行后释放监视器锁,随后 B 线程获取同一个监视器锁。那么程序在顺序一致性模型中的执行效果将如图:

未同步程序在顺序一致性模型中虽然整体执行顺序是无序的,但所有线程都只能看到一个一致的整体执行顺序。线程 A 和 B 看到的执行顺序都是B1→A1→A2→B2→A3→B3,之所以能得到这个保证是因为顺序一致性内存模型中的每个操作必须立即对任意线程可见。

但是,在 JMM 中就没有这个保证。未同步程序在 JMM 中不但整体的执行顺序是无序的,而且所有线程看到的操作执行顺序也可能不一致。比如,在当前线程把写过的数据缓存在本地内存中,在没有刷新到主内存之前,这个写操作仅对当前线程可见;从其他线程的角度来观察,会认为这个写操作根本没有被当前线程执行。只有当前线程把本 地内存中写过的数据刷新到主内存之后,这个写操作才能对其他线程可见。在这种情况 下,当前线程和其他线程看到的操作执行顺序将不一致。

同步程序的顺序一致性效果

顺序一致性模型中,所有操作完全按程序的顺序串行执行;而JMM则是在不改变(正确同步的) 程序执行结果的前提下,尽可能地为编译器和处理器的优化打开方便之门。

未同步程序的执行特性

对于未同步或未正确同步的多线程程序,JMM 只提供最小安全性:线程执行时读取到的值,要么是之前某个线程写入的值,要么是默认值(0,Null,False)。

未同步 程序在两个模型中的执行特性有如下几个差异:

  • 顺序一致性模型保证单线程内的操作会按程序的顺序执行,而 JMM 不保证单线程内的操作会按程序的顺序执行
  • 顺序一致性模型保证所有线程只能看到一致的操作执行顺序,而 JMM 不保证所有线程能看到一致的操作执行顺序
  • JMM 不保证对 64 位的 long 型和 double 型变量的写操作具有原子性,而顺序一致性模型保证对所有的内存读/写操作都具有原子性
3.4 volatile的内存语义 volatile的特性

理解volatile特性的一个好方法是把对volatile变量的单个读/写,看成是使用同一个锁对单个读/写操作做了同步。

特性:

  • 可见性。对一个 volatile 变量的读,总是能看到(任意线程)对这个 volatile 变量最后的写入
  • 原子性:对任意单个 volatile 变量的读/写具有原子性,但类似于 volatile++这种 复合操作不具有原子性
volatile写-读建立的happens-before关系
class VolatileExample {
     int a = 0;
     volatile boolean flag = false;
     public void writer() {
         a = 1; // 1
         flag = true; // 2
     }
     public void reader() {
         if (flag) { // 3
             int i = a; // 4
             ……
         }
     }
}

假设线程A执行 writer()方法之后,线程B执行reader()方法,这个过程建立的 happens-before 关系 :

  • 根据程序次序规则,1 happens-before 2;3 happens-before 4
  • 根据 volatile 规则,2 happens-before 3
  • 根据 happens-before 的传递性规则,1 happens-before 4
volatile 写-读的内存语义
  • volatile 写的内存语义:当写一个 volatile 变量时,JMM 会把该线程对应的本地内存中的共享变量值刷新到主内存
  • volatile 读的内存语义:当读一个 volatile 变量时,JMM 会把该线程对应的本地内存置为无效,线程接下来将从主内存中读取共享变量

总结:

  • 线程 A 写一个 volatile 变量,实质上是线程 A 向接下来将要读这个 volatile 变量的某个线程发出了(其对共享变量所做修改的)消息
  • 线程 B 读一个 volatile 变量,实质上是线程 B 接收了之前某个线程发出的(在写这个 volatile 变量之前对共享变量所做修改的)消息
  • 线程 A 写一个 volatile 变量,随后线程 B 读这个 volatile 变量,这个过程实质上是线程 A 通过主内存向线程 B 发送消息

###volatile 内存语义的实现

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a3NxpnSf-1654791261786)(20190731221427236.png)]

  • 当第二个操作是 volatile 写时,不管第一个操作是什么,都不能重排序。这个规则确保 volatile 写之前的操作不会被编译器重排序到 volatile 写之后
  • 当第一个操作是 volatile 读时,不管第二个操作是什么,都不能重排序。这个规则确保 volatile 读之后的操作不会被编译器重排序到 volatile 读之前
  • 当第一个操作是 volatile 写,第二个操作是 volatile 读时,不能重排序

为了实现 volatile 的内存语义,编译器在生成字节码时,会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。

保守策略:在每个 volatile 写/读操作前后插入一个 StoreLoad /LoadLoad 屏障

优化,编译器可以根据具体情况省略不必要的屏障 :

最后的 StoreLoad 屏障不能省略 ,因为编译器可能无法准确断定后面是否会有 volatile 读或写。

JSR-133为什么要增强 volatile 的内存语义
class VolatileExample {
     int a = 0;
     volatile boolean flag = false;
     public void writer() {
         a = 1; // 1
         flag = true; // 2
     }
     public void reader() {
         if (flag) { // 3
             int i = a; // 4
             ……
         }
     }
}

在 JSR-133 之前的旧 Java 内存模型中,虽然不允许 volatile 变量之间重排序,但旧的 Java 内存模型允许 volatile 变量与普通变量重排序。 在旧的内存模型中,当 1 和 2 之间没有数据依赖关系时,1 和 2 之间就可能被重排序,其结果就是:读线程 B 执行 4 时,不一定能看到写线程 A 在执行 1 时对共享变量的修改。

JSR-133 专家组决定增强 volatile 的内存语义:严格限制编译器和处理器对 volatile 变量与普通变量的重排序, 确保 volatile 的写-读和锁的释放-获取具有相同的内存语义。从编译器重排序规则和处理 器内存屏障插入策略来看,只要 volatile 变量与普通变量之间的重排序可能会破坏 volatile 的内存语义,这种重排序就会被编译器重排序规则和处理器内存屏障插入策略禁 止。

3.5 锁的内存语义 锁的释放和获取的内存语义
  • 当线程释放锁时,JMM 会把该线程对应的本地内存中的共享变量刷新到主内存中
  • 当线程获取锁时,JMM 会把该线程对应的本地内存置为无效,从而使得被监视器保护的临界区代码必须从主内存中读取共享变量

锁释放与 volatile 写有相同的内存语义;锁获取与 volatile 读有相同的内存语义

总结:

  • 线程 A 释放一个锁,实质上是线程 A 向接下来将要获取这个锁的某个线程发出了(线程 A 对共享变量所做修改的)消息
  • 线程 B 获取一个锁,实质上是线程 B 接收了之前某个线程发出的(在释放这个锁之前对共享变量所做修改的)消息
  • 线程 A 释放锁,随后线程 B 获取这个锁,这个过程实质上是线程 A 通过主内存向线程 B 发送消息
锁内存语义的实现
 ReentrantLock lock = new ReentrantLock();
 public void writer() {
     lock.lock(); // 获取锁
     try {
     	a++;
     } finally {
     	lock.unlock();// 释放锁
     }
 }

ReentrantLock 的实现依赖于 Java 同步器框架 AbstractQueuedSynchronizer ,AQS 使用一个整型的 volatile 变量(命名为 state)来维护同步状态。

ReentrantLock 分为公平锁和非公平锁,内存语义总结 :

  • ·公平锁和非公平锁释放时,最后都要写一个 volatile 变量 state
  • 公平锁获取时,首先会去读 volatile 变量
  • 非公平锁获取时,首先会用 CAS 更新 volatile 变量,这个操作同时具有 volatile 读和 volatile 写的内存语义

CAS同时具有 volatile 读和 volatile 写的内存语义

  • 要求:编译器不会对 volatile 读与 volatile 读后面的任意内存操作重排序,编译器不会对 volatile 写与 volatile 写前面的任意内存操作重排序。组合这两个条件,意味着为了同时实现 volatile 读和 volatile 写的内存语义,编译器不能对 CAS 与 CAS 前面和后面的任意内存操作重排序
  • 涉及到的intel 的手册对 lock 前缀的说明如下:
    • 确保对内存的读-改-写操作原子执行 (锁住总线)
    • 禁止该指令,与之前和之后的读和写指令重排序
    • 把写缓冲区中的所有数据刷新到内存中

锁释放-获取的内存语义的实现至少有下面两种方式 :

  • 利用 volatile 变量的写-读所具有的内存语义
  • 利用 CAS 所附带的 volatile 读和 volatile 写的内存语义
concurrent 包的实现

Java的CAS会使用现代处理器上提供的高效机器级别原子指令,这些原子指令以原子方式对内存执行读-改-写操作,这是在多处理器中实现同步的关键。同时,volatile变量的读/写和CAS可以实现线程之间的通信。把这些特性整合在一起,就形成了整个concurrent包得以实现的基石。

如果我们仔细分析concurrent包的源代码实现,会发现一个通用化的实现模式:

  • 声明共享变量为volatile
  • 使用CAS的原子条件更新来实现线程之间的同步
  • 配合以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信
3.6 final域的内存语义 写 final 域的重排序规则
  • JMM 禁止编译器把 final 域的写重排序到构造函数之外
  • 编译器会在 final 域的写之后,构造函数 return 之前,插入一个 StoreStore 屏障。 这个屏障禁止处理器把 final 域的写重排序到构造函数之外
public Main() { // 构造函数
     i = 1; // 写普通域
     j = 2; // 写 final 域
 }

public static void writer() {
	obj = new Main();
}

写 final 域的重排序规则可以确保:在对象引用为任意线程可见之前,对象的 final 域 已经被正确初始化过了,而普通域不具有这个保障。以上图为例,在读线程 B“看到”对 象引用 obj 时,很可能 obj 对象还没有构造完成(对普通域 i 的写操作被重排序到构造函数外,此时初始值 1 还没有写入普通域 i)。

读 final 域的重排序规则

在一个线程中,初次读对象引用与初次读该对象包含的 final 域,JMM 禁止处理器重排序这两个操作(注意,这个规则仅仅针对处理器)。编译器会在读 final 域操作的前面插入一个 LoadLoad 屏障。

public static void reader() { // 读线程 B 执行
     Main object = obj; // 读对象引用
     int a = object.i; // 读普通域
     int b = object.j; // 读 final 域
}

初次读对象引用与初次读该对象包含的 final 域,这两个操作之间存在间接依赖关 系,因此编译器不会重排序这两个操作(大多数处理器)。但有少数处理器允许对存在间接依赖关系的操作做重排序(比如 alpha 处理器),这个规则就是专门用来针对这种处理器的。

现在假设写线程 A 没有发生任何重排序,同时程序在不遵守间接依赖的处理器上执行:

读对象的普通域的操作被处理器重排序到读对象引用之前。读普通域时,该域还没有被写线程 A 写入,这是一个错误的读取操作。 而读 final 域的重排序规则会把读对象 final 域的操作“限定”在读对象引用之后,此时该 final 域已经被 A 线程初始化过了,这是一个正确的读取操作。

读 final 域的重排序规则可以确保:在读一个对象的 final 域之前,一定会先读包含这个 final 域的对象的引用。

final 域为引用类型

对于引用类型,写 final 域的重排序规则对编译器和处理器增加了如下约束:在构造函数内对一个 final 引用的对象的成员域的写入,与随后在构造函数外把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。

为什么 final 引用不能从构造函数内“溢出”

在构造函数内部,不能让这个被构造对象的引用为其他线程所见,也就是对象引用不能在构造函数中“逸出”

final int i;
static Main obj;  //引用类型
public Main() {
     i = 1; // 1 写 final 域
     obj = this; // 2 this 引用在此"逸出"
}

这里操作1和2可能被重排序。在构造函数返回前,被构造对象的引用不能为其他线程所见, 因为此时的 final 域可能还没有被初始化。

JSR-133 为什么要增强 final 的语义

通过为 final 域增加写和读 重排序规则,可以为 Java 程序员提供初始化安全保证:只要对象是正确构造的(被构造 对象的引用在构造函数中没有“逸出”),那么不需要使用同步(指 lock 和 volatile 的使 用)就可以保证任意线程都能看到这个 final 域在构造函数中被初始化之后的值。

3.7 happens-before JMM设计
  • 对于会改变程序执行结果的重排序,JMM 要求编译器和处理器必须禁止这种重排序
  • 对于不会改变程序执行结果的重排序,JMM 对编译器和处理器不做要求

即:只要不改变程序的执行结果(指的是单线程程序和正确同步的多线程程序),编译器和处理器怎么优化都行。

happens-before 的定义

MM 可以通过 happens-before 关系向程序员提供跨线程的内存可见性保证(如果 A 线程的写操作 a 与 B 线程的读操作 b 之间存在 happens-before 关系,尽管 a 操作和 b 操作在不同的线程中执行,但 JMM 向程序员保证 a 操作将对 b 操作可见)。

happens-before 关系本质上和 as-if-serial 语义是一回事:

  • as-if-serial 语义保证单线程内程序的执行结果不被改变,happens-before 关系保证正确同步的多线程程序的执行结果不被改变
  • as-if-serial 语义幻境:单线程程序是按程序的顺序来执行的。happens-before幻境:正确同步的多线程程序是按 happens-before 指定的顺序来执行的。
  • 都是为了在不改变程序执行结果的前提下,尽可能地提高程序执行的并行度
happens-before 规则
  • 程序顺序规则:一个线程中的每个操作,happens-before 于该线程中的任意后续操作
  • 监视器锁规则:对一个锁的解锁,happens-before 于随后对这个锁的加锁
  • volatile 变量规则:对一个 volatile 域的写,happens-before 于任意后续对这个 volatile 域的读
  • 传递性:如果 A happens-before B,且 B happens-before C,那么 A happens-before C
  • start()规则:如果线程 A 执行操作 ThreadB.start()(启动线程 B),那么 A 线程的 ThreadB.start()操作 happens-before 于线程 B 中的任意操作。
    • 线程 A 在执行 ThreadB.start()之前对共享变量所做的修改,接下来在线程 B 开始执行后都将确保对线程 B 可见
  • join()规则:如果线程 A 执行操作 ThreadB.join()并成功返回,那么线程 B 中的任 意操作 happens-before 于线程 A 从 ThreadB.join()操作成功返回
    • 线程 A 执行操作 ThreadB.join()并成功返回后,线程 B 中的任意操作都将对线程 A 可见
3.8 双重检查锁定与延迟初始化

有时候可能需要推迟一些高开销的对象初始化操作,并且只有在使用这些对象时才进行初始化。

//是非线程安全的延迟初始化对象
public class UnsafeLazyInitialization {
     private static Instance instance;
     public static Instance getInstance() {
     if (instance == null) // 1:A 线程执行
         instance = new Instance(); // 2:B 线程执行
         return instance;
     }
}

双重检查锁定:

public class DoubleCheckedLocking { // 1
     private static Instance instance; // 2
     public static Instance getInstance() { // 3
         if (instance == null) { // 4:第一次检查
             synchronized (DoubleCheckedLocking.class) { // 5:加锁
             if (instance == null) // 6:第二次检查
             instance = new Instance(); // 7:问题的根源出在这里
         	} // 8
         } // 9 
         return instance; // 10
     } // 11
}

问题分析:执行instance = new Instance()时,这一行代码可以分解为如下

memory = allocate(); // 1:分配对象的内存空间
ctorInstance(memory); // 2:初始化对象
instance =memory; // 3:设置 instance 指向刚分配的内存地址

2和3之间可能会被重排序,如果发生重排序,另一个并发执行的线程 B 就有可能在第 4 行判断 instance 不为 null。线程 B 接下来将访问 instance 所引用的对象,但此时这个对象可能还没有被 A 线程初始化!

两种解决方案:

  • 不允许 2 和 3 重排序
  • 允许 2 和 3 重排序,但不允许其他线程“看到”这个重排序
基于 volatile 的解决方案

把 instance 声明为 volatile 型,就可以实现线程安全的延迟初始化。当声明对象的引用为 volatile 后,2 和 3 之间的重排序, 在多线程环境中将会被禁止。

public class SafeDoubleCheckedLocking {
     private volatile static Instance instance;
     public static Instance getInstance() {
     if (instance == null) {
         synchronized (SafeDoubleCheckedLocking.class) {
             if (instance == null)
             	instance = new Instance(); // instance 为 volatile,现在没问题了
             }
         }
         return instance;
     }
}
基于类初始化的解决方案

JVM 在类的初始化阶段(即在 Class 被加载后,且被线程使用之前),会执行类的初始化。在执行类的初始化期间,JVM 会去获取一个锁。这个锁可以同步多个线程对同一 个类的初始化。

public class InstanceFactory {
     private static class InstanceHolder {
     	public static Instance instance = new Instance();
     }
     public static Instance getInstance() {
     	return InstanceHolder.instance; // 这里将导致 InstanceHolder 类被初始化
     }
}

Java 语言规范规定,对于每一个类或接口 C,都有一个唯一的初始化锁 LC 与之对应。JVM 在类初始化期间会获取这个初始化锁,并且每个线程至少获取一次锁来确保这个类已经被初始化过了。

四、Java并发编程基础 4.1 线程优先级

Java线程中,通过一个整型成员变量priority来控制优先级,优先级的范围从1~10,在线程构建的时候可以通过setPriority(int)方法来修改优先级,默认优先级是5,优先级高的线程分配时间片的数量要多于优先级低的线程。

设置线程优先级时,针对频繁阻塞(休眠或者I/O操作)的线程需要设置较高优先级,而偏重计算(需要较多CPU时间或者偏运算)的线程则设置较低的优先级,确保处理器不会被独占。

注意:线程优先级不能作为程序正确性的依赖,因为操作系统可以完全不用理会Java线程对于优先级的设定。

线程的状态

在给定的一个时间,线程只能处于其中的一个状态

Java线程状态变迁:

  • 线程在自身的生命周期中,并不是固定地处于某个状态,而是随着代码的执行在不同的状态之间进行切换
  • 线程创建之后,调用 start()方法开始运行。当线程执行 wait() 方法之后,线程进入等待状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态,而超时等待状态相当于在等待状态的基础上增加了超时限制,也就是超时时间到达时将会返回到运行状态。当线程调用同步方法时,在没有获取到锁的情况 下,线程将会进入到阻塞状态。线程在执行 Runnable 的 run()方法之后将会进入到终止状态。
Daemon线程

当一个 Java 虚拟机中不存在非 Daemon 线程的时候, Java 虚拟机将会退出 ,可以通过调用 Thread.setDaemon(true)将线程设置为 Daemon 线程。

Daemon属性需要在启动线程之前设置,不能在启动线程之后设置。

在构建 Daemon 线程时,不能依靠 finally 块中的内容来确保执行关闭或清理 资源的逻辑。

Thread thread = new Thread(new DaemonRunner(), "DaemonRunner");
thread.setDaemon(true);
4.2 启动和终止线程 构造线程

在运行线程之前首先要构造一个线程对象,线程对象在构造的时候需要提供线程所需要的属性,如线程所属的线程组、线程优先级、是否是Daemon线程等信息。

启动线程

线程对象在初始化完成之后,调用 start()方法就可以启动这个线程。线程 start()方法 的含义是:当前线程(即 parent 线程)同步告知 Java 虚拟机,只要线程规划器空闲,应立即启动调用 start()方法的线程。

理解中断

中断可以理解为线程的一个标识位属性,它表示一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了个招呼,其他线程通过调用该线程的 interrupt()方法对其进行中断操作。

线程通过检查自身是否被中断来进行响应,线程通过方法 isInterrupted()来进行判断是否被中断,也可以调用静态方法 Thread.interrupted()对当前线程的中断标识位进行复 位。如果该线程已经处于终结状态,即使该线程被中断过,在调用该线程对象的 isInterrupted()时依旧会返回 false。

从 Java 的 API 中可以看到,许多声明抛出 InterruptedException 的方法(例如 Thread.sleep(longmillis)方法)这些方法在抛出 InterruptedException 之前,Java 虚拟机会先将该线程的中断标识位清除,然后抛出 InterruptedException,此时调用 isInterrupted() 方法将会返回 false。

安全地终止线程

中断操作最适合用来取消或停止任务。通过标识位或者中断操作的方式能够使线程在终止时有机会去清理资源,而不是武断地将线程停止,因此这种终止线程的做法显得更加安全和优雅。

4.3 线程间通信 volatile和synchronized关键字
  • synchronized:可以修饰方法或者以同步块的形式来进行使用,它主要确保多个线程在同一个时刻,只能有一个线程处于方法或者同步块中,它保证了线程对变量访问的可见性和排他性。
    • 同步块的实现使用了 monitorenter 和 monitorexit 指令,而同步方法则是依靠方法修饰符上的 ACC_SYNCHRONIZED 来完成的。无论采用哪种方式,其本质是对一个对象的监视器(monitor)进行获取,而这个获取过程是排他的,也就是同一时刻只能有一个线程获取到由 synchronized 所保护对象的监视器
    • 任意一个对象都拥有自己的监视器,当这个对象由同步块或者这个对象的同步方法调用时,执行方法的线程必须先获取到该对象的监视器才能进入同步块或者同步方法, 而没有获取到监视器(执行该方法)的线程将会被阻塞在同步块和同步方法的入口处, 进入 BLOCKED 状态
  • volatile:可以用来修饰字段(成员变量),就是告知程序任何对该变量的访问均需要从共享内存中获取,而对它的改变必须同步刷新回共享内存,它能保证所有线程对变量访问的可见性。
等待/通知机制

等待/通知机制,是指一个线程 A 调用了对象 O 的 wait()方法进入等待状态,而另一 个线程 B 调用了对象 O 的 notify()或者 notifyAll()方法,线程 A 收到通知后从对象 O 的 wait()方法返回,进而执行后续操作。

public class demo1Main2 {

    static boolean flag = true;
    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread waitThread = new Thread(new Wait(), "WaitThread");
        waitThread.start();
        TimeUnit.SECONDS.sleep(1);
        Thread notifyThread = new Thread(new Notify(), "NotifyThread");
        notifyThread.start();
    }

    static class Wait implements Runnable {
        @Override
        public void run() {
            // 加锁,拥有lock的Monitor
            synchronized (lock) {
                // 当条件不满足时,继续wait,同时释放了lock的锁
                while (flag) {
                    System.out.println(Thread.currentThread() + " flag is true.wa@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 条件满足时,完成工作
                System.out.println(Thread.currentThread() + "flag is false. running@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }

    static class Notify implements Runnable {
        @Override
        public void run() {
            // 加锁,拥有lock的Monitor
            synchronized (lock) {
                // 获取lock的锁,然后进行通知,通知时不会释放lock的锁,
                // 直到当前线程释放了lock后,WaitThread才能从wait方法中返回
                System.out.println(Thread.currentThread() + " hold lock. notify @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag = false;
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 再次加锁
            synchronized (lock) {
                System.out.println(Thread.currentThread() + "hold lock again. sleep@" + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//输出:
Thread[WaitThread,5,main] flag is true.wa@ 16:52:33
Thread[NotifyThread,5,main] hold lock. notify @ 16:52:34
Thread[NotifyThread,5,main]hold lock again. sleep@16:52:39
Thread[WaitThread,5,main]flag is false. running@ 16:52:44

WaitThread 首先获取了对象的锁,然后调用对象的 wait()方法,从而放弃了锁并进入了对象的等待队列 WaitQueue 中,进入等待状态。由于 WaitThread 释放了对象的锁, NotifyThread 随后获取了对象的锁,并调用对象的 notify()方法,将 WaitThread 从 WaitQueue(等待队列) 移到 SynchronizedQueue (同步队列)中,此时 WaitThread 的状态变为阻塞状态。NotifyThread 释放了锁之后, WaitThread 再次获取到锁并从 wait()方法返回继续执行。

可以看出:等待/通知机制依托于同步机制,其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。

需要注意的细节:

  • 使用 wait()、notify()和 notifyAll()时需要先对调用对象加锁
  • 调用 wait()方法后,线程状态由 RUNNING 变为 WAITING,并将当前线程放置到对象的等待队列
  • notify()或 notifyAll()方法调用后,等待线程依旧不会从 wait()返回,需要调用 notify()或 notifAll()的线程释放锁之后,等待线程才有机会从 wait()返回
  • notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中,而 notifyAll() 方法则是将等待队列中所有的线程全部移到同步队列,被移动的线程 状态由 WAITING 变为 BLOCKED
  • 从 wait()方法返回的前提是获得了调用对象的锁
等待/通知的经典范式

等待方:

  • 获取对象的锁
  • 如果条件不满足,那么调用对象的 wait()方法,被通知后仍要检查条件
  • 条件满足则执行对应的逻辑
synchronized(对象) {
     while(条件不满足) { 
     	对象.wait();
     }
     对应的处理逻辑
}

通知方:

  • 获得对象的锁
  • 改变条件
  • 通知所有等待在对象的线程
synchronized(对象){
     改变条件
     对象.notifyAll();
}
Thread.join()的使用

如果一个线程A执行了thread.join() 语句,其含义是:当前线程A等待thread线程终止之后才从thread.join()返回。

线程Thread除了提供join()方法之外,还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。这两个超时方法表示,如果线程thread在给定的超时时间里没有终止,那么将会从该超时方法中返回。

每个线程终止的前提是前驱线程的终止,每个线程等待前驱线程终止后,才从join()方法返回,这里涉及了等待/通知机制(等待前驱线程结束,接收前驱线程结束通知)

ThreadLocal的使用

(102条消息) 多线程系列:TheadLocal(原理、内存泄漏、弱引用)_bohu83的博客-CSDN博客

ThreadLocal,即线程变量,是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上,也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。

4.4 线程应用实例 等待超时模式

应用场景:调用一个方法时等待一段时间,如果该方法能够在给定时间段内得到结果,那么将结果返回,否则返回默认值。

假设超时时间是T,那么可以推断出在当前时间为now+T时就为超时。

定义变量如下:

等待持续时间:REMAINING = T;

超时时间:FUTURE = now + T;

这时仅需要wait(REMAINING)即可,在wait(REMAINING)返回之后会将执行:REMAINING = FUTURE - now。如果REMAINING = 0,表示超时,直接退出,否则将继续执行wait(REMAINING)。 伪代码如下:

// 对当前对象加锁
public synchronized Object get(long mills) throws InterruptedException {
     long future = System.currentTimeMillis() + mills;
     long remaining = mills;
     // 当超时大于 0 并且 result 返回值不满足要求
     while ((result == null) && remaining > 0) {
         wait(remaining);
         remaining = future - System.currentTimeMillis();
     }
     return result;
}

等待超时模式就是在等待/通知范式基础上增加了超时控制,这使得该模 式相比原有范式更具有灵活性,因为即使方法执行时间过长,也不会“永久”阻塞调用 者,而是会按照调用者的要求“按时”返回。

线程池技术及其示例

一个简单的线程池接口定义:

public interface ThreadPool {
     // 执行一个 Job,这个 Job 需要实现 Runnable
     void execute(Job job);
     // 关闭线程池
     void shutdown();
     // 增加工作者线程
     void addWorkers(int num);
     // 减少工作者线程
     void removeWorker(int num);
     // 得到正在等待执行的任务数量
     int getJobSize();
}

客户端可以通过 execute(Job)方法将 Job 提交入线程池执行,而客户端自身不用等待 Job 的执行完成。

public void execute(Job job) {
     if (job != null) {
     	// 添加一个工作,然后进行通知
     	synchronized (jobs) {
     	jobs.addLast(job);
    	jobs.notify();
     	}
     }
}

// 工作者,负责消费任务
 class Worker implements Runnable {
     // 是否工作
     private volatile boolean running = true;
     public void run() {
         while (running) {
         Job job = null;
         synchronized (jobs) {
         // 如果工作者列表是空的,那么就 wait
        while (jobs.isEmpty()) {
             try {
                jobs.wait();
             } catch (InterruptedException ex) {
             // 感知到外部对 WorkerThread 的中断操作,返回
             Thread.currentThread().interrupt();
             return;
     		}
     	}
    	// 取出一个 Job
    	job = jobs.removeFirst();
     	}
        if (job != null) {
             try {
             job.run();
             } catch (Exception ex) {
             // 忽略 Job 执行中的 Exception
             }
         }
     }
 }

当客户端调用 execute(Job)方法时,会不断地向任务列表 jobs 中添加 Job,而每个工作者线程会不断地从 jobs 上取出一个 Job 进行执行,当 jobs 为空时,工作者线程进入等待状态。

五、Java中的锁 5.1 Lock接口
Lock lock = new ReentrantLock();
lock.lock();  //没获取到锁的话会抛异常
try {
    //do something
} finally {
	lock.unlock();
    // 如果lock.lock()放try里,这里就可能会出错。
    // 因为没获取到锁时,不能unlock
}

Lock接口提供的synchronized关键字不具备的主要特性:

Lock的API:

5.2 同步队列器

队列同步器 AbstractQueuedSynchronizer(以下简称同步器),是用来构建锁或者其他同步组件的基础框架,它使用了一个 int 成员变量表示同步状态,通过内置的 FIFO 队列来完成资源获取线程的排队工作。

同步器的主要使用方式是继承,子类通过继承同步器并实现它的抽象方法来管理同步状态,子类推荐被定义为自定义同步组件的静态内部类。

同步器既可以支持独占式地获取同步状态,也可以支持共享式地获取同步状态。

5.3 队列同步器的接口与示例

使用同步器提供的如下 3 个方法来访问或修改同步状态:

  • getState():获取当前同步状态
  • setState(int newState):设置当前同步状态
  • compareAndSetState(int expect,int update):使用 CAS 设置当前状态,该方法能够保证状态设置的原子性

独占锁就是在同一时刻只能有一个线程获取到锁,而其他获取锁的线程只能处于同步队列中等待,只有获取锁的线程释放了锁,后继的线程才能够获取锁。

示例:

//自定义同步组件
class Mutex implements Lock {
     // 静态内部类,自定义同步器,继承了同步器并实现了独占式的获取和释放同步状态。
     private static class Sync extends AbstractQueuedSynchronizer {
         // 是否处于占用状态
         protected boolean isHeldExclusively() {
         	return getState() == 1;
     	}
         
         // 当状态为 0 的时候获取锁
         public boolean tryAcquire(int acquires) {
             if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
             	return true;
         	}
         	return false;
         }
         
         // 释放锁,将状态设置为 0
         protected boolean tryRelease(int releases) {
             if (getState() == 0) throw new IllegalMonitorStateException();
             setExclusiveOwnerThread(null);
             setState(0);
             return true;
         }
         
         // 返回一个 Condition,每个 condition 都包含了一个 condition 队列
         Condition newCondition() {
            return new ConditionObject();
         }
     }
    
     // 仅需要将操作代理到 Sync 上即可
     private final Sync sync = new Sync();
     public void lock() {
     	sync.acquire(1);
     }
     public boolean tryLock() {
     	return sync.tryAcquire(1);
     }
     public void unlock() {
     	sync.release(1);
     }
     public Condition newCondition() {
     	return sync.newCondition();
     }
     public boolean isLocked() {
     	return sync.isHeldExclusively();
     }
     public boolean hasQueuedThreads() {
     	return sync.hasQueuedThreads();
     }
     public void lockInterruptibly() throws InterruptedException {
     	sync.acquireInterruptibly(1);
     }
     public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
     	return sync.tryAcquireNanos(1, unit.toNanos(timeout));
     }
}
5.3 队列同步器的实现分析 同步队列

同步器依赖内部的同步队列(一个 FIFO 双向队列)来完成同步状态的管理。

  • 当前线程获取同步状态失败时,同步器会将当前线程以及等待状态等信息构造成为一个节点 (Node)并将其加入同步队列的尾部,同时会阻塞当前线程。加入队列的过程必须要保证线程安全,因此同步器提供了一个基于 CAS 的设置尾节点的方法: compareAndSetTail(Node expect,Node update)
  • 首节点是获取同步状态成功的节点,首节点的线程在释放同步状态时,将会唤醒后继节点,而后继节点将会在获取同步状态成功时将自己设置为首节点。设置首节点是通过获取同步状态成功的线程来完成的,由于只有一个线程能够成功获取到同步状态,因此设置头节点的方法并不需要使用 CAS 来保证,它只需要将首节点设置成为原首节点的后继节点并断开原首节点的 next 引用即可。
独占式同步状态获取与释放

获取

通过调用同步器的 acquire(int arg)方法可以获取同步状态,该方法对中断不敏感,也就是由于线程获取同步状态失败后进入同步队列中,后续对线程进行中断操作时,线程不会从同步队列中移出

public final void acquire(int arg) {
	if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
 		selfInterrupt();
	}
}
  • 调用自定义同步器实现的 tryAcquire(int arg)方 法,该方法保证线程安全的获取同步状态

  • 如果同步状态获取失败,则构造同步节点 (独占式 Node.EXCLUSIVE,同一时刻只能有一个线程成功获取同步状态)并通过 addWaiter(Node node) 方法将该节点加入到同步队列的尾部

    private Node addWaiter(Node mode) {
         Node node = new Node(Thread.currentThread(), mode);
         // 快速尝试在尾部添加
         Node pred = tail;
         if (pred != null) {
         	node.prev = pred;
             //使用compareAndSetTail方法来确保节点能够被线程安全添加
             if (compareAndSetTail(pred, node)) {  //如果一次CAS就成功则返回
                pred.next = node;
                return node;
             }
         }
         enq(node);
     	return node;
    }
    
    
    private Node enq(final Node node) {
         for (; ; ) {
             Node t = tail;
             if (t == null) { // Must initialize
             	if (compareAndSetHead(new Node())) tail = head;
             } else {
             	node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                 }
             }
         }
    }
    
  • 调用 acquireQueued(Node node,int arg)方法,使得该节点以“死循环”的方式获取同步状态。如果获取不到则阻塞节点中的线程,而被阻塞线程的唤醒主要依靠前驱节点的出队或阻塞线程被中断来实现。

    节点进入同步队列之后,就进入了一个自旋的过程,每个节点(或者说每个线程) 都在自省地观察,当条件满足,获取到了同步状态,就可以从这个自旋过程中退出,否则依旧留在这个自旋过程中(并会阻塞节点的线程)。

    final boolean acquireQueued(final Node node, int arg) {
         boolean failed = true;
         try {
             boolean interrupted = false;
             for (; ; ) {
             	final Node p = node.predecessor();
             	if (p == head && tryAcquire(arg)) {
             		setHead(node);
            		p.next = null; // help GC
             		failed = false;
            		return interrupted;
             	}
             	if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
             		interrupted = true;
             	}
             }
         } finally {
         	if (failed) cancelAcquire(node);
         }
    }
    

    当前线程在“死循环”中尝试获取同步状态,而只有前驱节点是头节点才能够尝试获取同步状态,这是为什么?

    • 第一,头节点是成功获取到同步状态的节点,而头节点的线程释放了同步状态之后,将会唤醒其后继节点,后继节点的线程被唤醒后需要检查自己的前驱节点是否是头节点。
    • 维护同步队列的 FIFO 原则
  • 流程

释放

唤醒头节点的后继节点线程,unparkSuccessor(Node node)方法使用 LockSupport来唤醒处于等待状态的线程。

public final boolean release(int arg) {
 	if (tryRelease(arg)) {
 		Node h = head;
 		if (h != null && h.waitStatus != 0) unparkSuccessor(h);
 		return true;
 	}
 	return false;
}

总结

在获取同步状态时,同 步器维护一个同步队列,获取状态失败的线程都会被加入到队列中并在队列中进行自 旋;移出队列(或停止自旋)的条件是前驱节点为头节点且成功获取了同步状态。在释放同步状态时,同步器调用 tryRelease(int arg)方法释放同步状态,然后唤醒头节点的后继节点。

共享式同步状态获取与释放

共享式获取与独占式获取最主要的区别在于同一时刻能否有多个线程同时获取到同步状态。 写操作要求对资源的独占式访问,而读操作可以是共享式访问。

//同步器的方法,获取
public final void acquireShared(int arg) {
    //尝试获取同步状态,>=0能获取到
	if (tryAcquireShared(arg) < 0) 
		doAcquireShared(arg);
}

private void doAcquireShared(int arg) {
     final Node node = addWaiter(Node.SHARED);
     boolean failed = true;
     try {
         boolean interrupted = false;
         
         for (; ; ) {
             final Node p = node.predecessor();
             if (p == head) {
             	int r = tryAcquireShared(arg);
             	if (r >= 0) {
                     setHeadAndPropagate(node, r);
                     p.next = null;
                     if (interrupted) selfInterrupt();
                     failed = false;
                     return;
            	}
             }
             if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) 
            	interrupted = true;
         }
     } finally {
     	if (failed) cancelAcquire(node);
     }
}
//同步器的方法,释放

public final boolean releaseShared(int arg) {
     if (tryReleaseShared(arg)) {
     	doReleaseShared();
     	return true;
     }
     return false;
}
独占式超时获取同步状态

通过调用同步器的 doAcquireNanos(int arg,long nanosTimeout)方法可以超时获取同步状态,即在指定的时间段内获取同步状态,如果获取到同步状态则返回 true,否则返回 false。

自定义同步组件

设计一个同步工具:该工具在同一时刻,只允许至多两个线程同时访问,超过两个 线程的访问将被阻塞,我们将这个同步工具命名为 TwinsLock

  • 确定访问模式:共享式访问
  • 定义资源数:同步资源数为2
public class TwinsLock implements Lock {
    private final Sync sync = new Sync(2);

    private static final class Sync extends AbstractQueuedSynchronizer {

        Sync(int count) {
            if(count < 0) {
                throw new IllegalArgumentException("count must large than zero");
            }
            setState(count);  //初始化资源数
        }

        @Override
        public int tryAcquireShared(int reducecount) {
            for (;;) {
                int current = getState();  //2
                int newCount = current - reducecount;  //1
                if (newCount < 0 || compareAndSetState(current,newCount)) {
                    //返回值>=0意味着当前线程获取同步状态
                    return newCount;
                }
            }
        }

        @Override
        protected boolean tryReleaseShared(int returnCount) {
            for(;;) {
                int current = getState(); //1
                int newCount = current + returnCount; //2
                if (compareAndSetState(current,newCount)) {
                    return true; //设置新的资源数=原有+待释放的
                }
            }
        }
    }
    @Override
    public void lock() {
        sync.acquireShared(1);
    }

    @Override
    public void unlock() {
        sync.releaseShared(1);
    }
    //其他接口略
}
5.3 重入锁

支持重进入的锁,它表示该锁能够支持一个线程对资源的重复加锁。sychnronized关键字隐式的支持重进入,ReentrantLock虽然没能像sychnronized关键字一样隐式的重进入,但是在调用lock()方法时,已经获取到锁的线程,能够再次调用lock()方法获取锁而不被阻塞。

  • 公平锁:指多个线程在等待同一个锁时,必须按照申请锁的先后顺序来依次获得锁
  • 非公平锁:可以抢占。即如果在某个时刻有线程需要获取锁,而这个时候刚好锁可用,则该线程会直接抢占,而这时阻塞在等待队列的线程不会被唤醒。
  • ReentrantLock提供了一个构造函数,能够控制锁是否是公平的。默认实现的是非公平锁,因为可能会出现线程连续获取锁的情况,因此非公平锁可能造饥饿,但由于线程切换很少,保证其吞吐量大。
实现重进入

重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞

ReentrantLock 是通过组合自定义同步器来实现锁的获取与释放,以非公平性(默认 的)实现为例,获取同步状态:

//ReentrantLock 的 非公平锁 方法
final boolean nonfairTryAcquire(int acquires) {
     final Thread current = Thread.currentThread();
     int c = getState();
     if (c == 0) {
         if (compareAndSetState(0, acquires)) {
             setExclusiveOwnerThread(current);
             return true;
         }
     //识别获取锁的线程是否为当前占据锁的线程
     } else if (current == getExclusiveOwnerThread()) {
         int nextc = c + acquires;
         if (nextc < 0) throw new Error("Maximum lock count exceeded");
         setState(nextc);
         return true;
     }
     return false;
}

成功获取锁的线程再次获取锁,只是增加了同步状态值,这也就要求 ReentrantLock 在释放同步状态时减少同步状态值

//ReentrantLock 的 tryRelease 方法
protected final boolean tryRelease(int releases) {
     int c = getState() - releases;
     if (Thread.currentThread() != getExclusiveOwnerThread()) throw new 
    IllegalMonitorStateException();
     boolean free = false;
     if (c == 0) {
     	free = true;
     	setExclusiveOwnerThread(null);
     }
     setState(c);
     return free;
}

如果该锁被获取了 n 次,那么前(n-1)次 tryRelease(int releases)方法必须返回 false, 而只有同步状态完全释放了,才能返回 true。当同步状态为 0 时,将占有线程设置为 null,并返回 true,表示释放成功。

公平锁和非公平锁的区别
//ReentrantLock 的 tryAcquire 方法
protected final boolean tryAcquire(int acquires) {
     final Thread current = Thread.currentThread();
     int c = getState();
     if (c == 0) {
         //加入了同步队列中当前节点是否有前驱节点的判断,
         //如果该方法返回 true,则表示有线程比当前线程更早地请求获取锁,
         //因此需要等待前驱线程获取并释放锁之后才能继续获取锁。
     	if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
     	setExclusiveOwnerThread(current);
     	return true;
     }
     } else if (current == getExclusiveOwnerThread()) {
     	int nextc = c + acquires;
     	if (nextc < 0) throw new Error("Maximum lock count exceeded");
     	setState(nextc);
     	return true;
     }
     return false;
}

公平性锁每次都是从同步队列中的第一个节点获取到锁,而非公平性锁出现了一个线程连续获取锁的情况,对于非公平锁,只要 CAS 设置同步状态成功(比如在释放锁的一瞬间,刚好有另一个线程请求锁),则表示当前线程获取了锁。

5.4 读写锁
  • 排他锁:同一时刻只允许一个线程进行访问

  • 读写锁:同一时刻可以允许多个读线程访问,但是在写访问时,所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁,一个读锁和一个写锁,通过分离读锁和写锁,使得并发性相比一般的排他锁有了很大的提升

  • 只需要在读操作时获取读锁,写操作时获取写锁即可。当写锁被获取到时,后续(非当前写操作线程)的读写操作都会被阻塞,写锁释放之后,所有操作继续执行

读写锁的实现分析 读写状态的设计

读写锁的自定义同步器需要在同步状态(一个整型变量)上维护多个读线程和 一个写线程的状态,如果在一个整型变量上维护多种状态,就一定需要“按位切割使用”这个变量,读写锁将变量切分成了两个部分,高 16 位表示读,低 16 位表示写。如下:一个线程已经获取了写锁,且重进入了两次,同时也连续获取了两次读锁

假设当前状态为S

  • 写状态:S & 0x0000FFFF;+1即S+1
  • 读状态:S>>>16(无符号补0右移16位);+1即S+(1<<16)就是S+0x00010000
写锁的获取与释放

写锁是一个支持重进入的排他锁

//ReentrantReadWriteLock 的 tryAcquire 方法
protected final boolean tryAcquire(int acquires) {
     Thread current = Thread.currentThread();
     int c = getState();
     int w = exclusiveCount(c);
     if (c != 0) {//进入这个if,就判断是否可以重进入
         // 存在读锁或者当前获取线程不是已经获取写锁的线程
         if (w == 0 || current != getExclusiveOwnerThread()) return false;
         //写锁计数溢出
         if (w + exclusiveCount(acquires) > MAX_COUNT) 
             throw new Error("Maximum lock count exceeded");
         setState(c + acquires); //重进入成功,设置新的state
         return true;
     }
     //走到这,说明c=0,通过CAS获取写锁
     if (writerShouldBlock() || !compareAndSetState(c, c + acquires)) {
     	return false;
     }
     //走到这,说明成功获取锁,设置当前线程             
     setExclusiveOwnerThread(current);
     return true;
}

如果存在读锁,则写锁不能被获取:读写锁要确保写锁的操作对读锁可见,如果允许读锁在已被获取的情况下对写锁的获取,那么正在运行的其他读线程就无法感知到当前写线程的操作。

写锁的释放与 ReentrantLock 的释放过程基本类似,每次释放均减少写状态,当写状态为 0 时表示写锁已被释放。

读锁的获取与释放

读锁是一个支持重进入的共享锁,它能够被多个线程同时获取。

protected final int tryAcquireShared(int unused) {
     for (; ; ) {
         int c = getState();
         int nextc = c + (1 << 16);  //读状态+1
         if (nextc < c)   //溢出
             throw new Error("Maximum lock count exceeded");
         //其它线程获取了写锁
         if (exclusiveCount(c) != 0 && owner != Thread.currentThread()) 
             return -1;
         if (compareAndSetState(c, nextc)) 
             return 1;
     }
}

如果其他线程已经获取了写锁,则当前线程获取读锁失败,进入等待状态。如果当前线程获取了写锁或者写锁未被获取,则当前线程(线程安全,依靠 CAS 保证)增加读状态,成功获取读锁。

读锁的每次释放(线程安全的,可能有多个读线程同时释放读锁)均减少读状态, 减少的值是(1<<16)。

注意:
1. 存在读锁时不能获取写锁
2. 存在写锁时如果请求获取读锁,分两种情况:
	1)写锁与读锁是同一个线程,成功 (锁降级)
	2)不同线程,读锁进入等待状态
锁降级

锁降级指的是写锁降级成为读锁。锁降级是指把持住(当前拥有的) 写锁,再获取到读锁,随后释放(先前拥有的)写锁的过程。

writeLock.lock();  // 锁降级从写锁获取到开始
readLock.lock();  //获取读锁
writeLock.unlock();  //释放读锁

why?主要是为了保证数据的可见性。如果当前线程不获取读锁而是直接释放写锁,假设此刻另一个线程(记作线程 T)获取了写锁并修改了数据,那么当前线程无法感知线程 T 的数据更新。如果当前线程获取读锁,即遵循锁降级的步骤,则线程 T 将会被阻塞,直到当前线程使用数据并释放读锁之后,线程 T 才能获取写锁进行数据更新。

5.5 LockSupport 工具

LockSupport 定义了一组的公共静态方法,这些方法提供了最基本的线程阻塞和唤醒功能,而 LockSupport 也成为构建同步组件的基础工具。

在 Java 6 中,LockSupport 增加了 park(Object blocker)、parkNanos(Object blocker,long nanos) 和 parkUntil(Object blocker,long deadline)3 个方法,用于实现阻塞当前线程的功能,其中参数 blocker 是用来标识当前线程在等待的对象。

5.6 Condition 接口

Condition 接口与 Lock 配合可以实现等待/通知模式。

Condition 接口与示例
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();  //由lock创建

public void conditionWait() throws InterruptedException {
     lock.lock();
     try {
     	condition.await(); //等待
     } finally {
     	lock.unlock();
     }
}
public void conditionSignal() throws InterruptedException {
     lock.lock();
     try {
     	condition.signal();  //通知
     } finally {
     	lock.unlock();
     }
}

调用await()、signal()等方法时,需要提前获取到Condition对象关联的锁。Condition 对象是由 Lock 对象(调用 Lock 对象的 newCondition()方法)创建出来的,即Condition 是依赖 Lock 对象的。

Condition 的实现分析

ConditionObject 是同步器 AbstractQueuedSynchronizer 的内部类,因为 Condition 的 操作需要获取相关联的锁。

等待队列

等待队列是一个 FIFO 的队列,在队列中的每个节点都包含了一个线程引用,该线程就是在 Condition 对象上等待的线程,如果一个线程调用了 Condition.await()方法,那么该线程将会释放锁、构造成节点加入等待队列并从尾部加入等待队列。

Condition 拥有首尾节点的引用,而新增节点只需要将原有的尾节点 nextWaiter 指向它,并且更新尾节点即可。上述节点引用更新的过程并没有使用 CAS 保证,原因在于调用 await()方法的线程必定是获取了锁的线程, 也就是说该过程是由锁来保证线程安全的。

等待

调用 Condition 的 await()方法(或者以 await 开头的方法),会使当前线程进入等待队列并释放锁,唤醒同步队列中的后继节点,同时线程状态变为等待状态。当从 await()方法返回时,当前线程一定获取了 Condition 相关联的锁。如果从队列(同步队列和等待队列)的角度看 await()方法, 当调用 await()方法时,相当于同步队列的首节点(获取了锁的节点)移动到 Condition 的等待队列中。

同步队列的首节点并不会直接加入等待队列,而是通过 addConditionWaiter()方法把当前线程构造成一个新的节点并将其加入等待队列中。

通知

调用 Condition 的 signal()方法,将会唤醒在等待队列中等待时间最长的节点(首节点),在唤醒节点之前,会将节点移到同步队列中。

七、Java中的13个原子操作类 7.1 原子更新基本类型类
  • AtomicBoolean:原子更新布尔类型
  • AtomicInteger:原子更新整型
  • AtomicLong:原子更新长整型

AtomicInteger 的常用方法如下:

  • int addAndGet(int delta):以原子方式将输入的数值与实例中的值 (AtomicInteger 里的 value)相加,并返回结果
  • boolean compareAndSet(int expect,int update):如果输入的数值等于预期值, 则以原子方式将该值设置为输入的值
  • int getAndIncrement():以原子方式将当前值加 1,注意,这里返回的是自增前的值
  • void lazySet(int newValue):最终会设置成 newValue,使用 lazySet 设置值后, 可能导致其他线程在之后的一小段时间内还是可以读到旧的值
  • int getAndSet(int newValue):以原子方式设置为 newValue 的值,并返回旧值
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerTest {
     static AtomicInteger ai = new AtomicInteger(1);
     public static void main(String[] args) {
     	System.out.println(ai.getAndIncrement()); //1
     	System.out.println(ai.get());  //2
 }
}

getAndIncrement 是如何实现原子操作 :

public final int getAndIncrement() {
     for (; ; ) {  //死循环
     	int current = get();
     	int next = current + 1;  //2
     	if (compareAndSet(current, next))  //CAS
            return current;
     }
}
public final boolean compareAndSet(int expect, int update) {
 	return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
7.2 原子更新数组

通过原子的方式更新数组里的某个元素,Atomic 包提供了以下 4 个类

  • AtomicIntegerArray:原子更新整型数组里的元素
    • int addAndGet(int i,int delta):以原子方式将输入值与数组中索引 i 的元素相加。
    • boolean compareAndSet(int i,int expect,int update):如果当前值等于预期值, 则以原子方式将数组位置 i 的元素设置成 update 值
  • AtomicLongArray:原子更新长整型数组里的元素
  • AtomicReferenceArray:原子更新引用类型数组里的元素
public static void main(String[] args) {
     static int[] value = new int[]{1,2};
     static AtomicIntegerArray ai = new AtomicIntegerArray(value);
     ai.getAndSet(0, 3);
     System.out.println(ai.get(0));  //3
     System.out.println(value[0]);   //1
}

数组 value 通过构造方法传递进去,然后 AtomicIntegerArray 会将当 前数组复制一份,所以当 AtomicIntegerArray 对内部的数组元素进行修改时,不会影响 传入的数组。

7.3 原子更新引用类型

原子更新基本类型的 AtomicInteger,只能更新一个变量,如果要原子更新多个变量,就需要使用这个原子更新引用类型提供的类。Atomic 包提供了以下 3 个类:

  • AtomicReference:原子更新引用类型
  • AtomicReferenceFieldUpdater:原子更新引用类型里的字段
  • AtomicMarkableReference:原子更新带有标记位的引用类型。可以原子更新一个 布尔类型的标记位和引用类型
public class AtomicReferenceTest {
 public static AtomicReference atomicUserRef = new AtomicReference();
 public static void main(String[] args) {
     User user = new User("conan", 15);
     atomicUserRef.set(user);
     User updateUser = new User("Shinichi", 17); 
     atomicUserRef.compareAndSet(user, updateUser);
     System.out.println(atomicUserRef.get().getName());   //Shinichi
     System.out.println(atomicUserRef.get().getOld());   //17
 }
}
7.4 原子更新字段类

如果需原子地更新某个类里的某个字段时,就需要使用原子更新字段类

  • AtomicIntegerFieldUpdater:原子更新整型的字段的更新器
  • AtomicLongFieldUpdater:原子更新长整型字段的更新器
  • AtomicStampedReference:原子更新带有版本号的引用类型。该类将整数值与引 用关联起来,可用于原子的更新数据和数据的版本号,可以解决使用 CAS 进行 原子更新时可能出现的 ABA 问题

要想原子地更新字段类需要两步。第一步,因为原子更新字段类都是抽象类,每次 使用的时候必须使用静态方法 newUpdater()创建一个更新器,并且需要设置想要更新的类和属性。第二步,更新类的字段(属性)必须使用 public volatile 修饰符。

public class AtomicIntegerFieldUpdaterTest {
     // 创建原子更新器,并设置需要更新的对象类和对象的属性
     private static AtomicIntegerFieldUpdater a = AtomicIntegerFieldUpdater.
     newUpdater(User.class, "old");
    
     public static void main(String[] args) { // 设置柯南的年龄是 10 岁
         User conan = new User("conan", 10);
         // 柯南长了一岁,但是仍然会输出旧的年龄
         System.out.println(a.getAndIncrement(conan));  //10
         // 输出柯南现在的年龄
         System.out.println(a.get(conan));   //11
     }
    
 public static class User {
     private String name;
     public volatile int old;
     public User(String name, int old) {
     	this.name = name;
     	this.old = old;
     }
     public String getName() {
     	return name;
     }
 	public int getOld() {
		return old;
 	}
 }
}
十、Executor框架 10.1 Executor框架简介 结构
  • 任务。包括被执行任务需要实现的接口:Runnable 接口或 Callable 接口
  • 任务的执行。包括任务执行机制的核心接口 Executor,以及继承自 Executor 的 ExecutorService 接口。Executor 框架有两个关键类实现了 ExecutorService 接口 (ThreadPoolExecutor 和 ScheduledThreadPoolExecutor)
  • 异步计算的结果。包括接口 Future 和实现 Future 接口的 FutureTask 类
成员