PHP8.1.21版本已发布
vue8.1.21版本已发布
jquery8.1.21版本已发布

详细了解一下Java并发编程三要素

WBOY
WBOY 转载
2022-04-22 11:54:48 2485浏览

本篇文章给大家带来了关于java的相关知识,其中主要介绍了关于并发编程三要素的相关问题,包括了原子性、可见性、有序性以及它们产生的原因和定义等等内容,下面一起来看一下,希望对大家有帮助。

推荐学习:《java视频教程

1 原子性

1.1 原子性的定义

原子性指的是一个或者多个操作,要么全部执行并且在执行的过程中不被其他操作打断,要么就全部都不执行。

1.2 原子性问题原因

线程切换是产生原子性问题的原因,线程切换是为了提高 CPU 的利用率。

以 count ++ 为例,至少需要三条 CPU 指令:

  • 指令 1:首先,需要把变量 count 从内存加载到 CPU 的寄存器;
  • 指令 2:之后,在寄存器中执行 +1 操作;
  • 指令 3:最后,将结果写入内存(缓存机制导致可能写入的是 CPU 缓存而不是内存)。

我们假设 count=0,如果线程 A 在指令 1 执行完后做线程切换,线程 A 和线程 B 按照下图的序列执行,那么我们会发现两个线程都执行了 count+=1 的操作,但是得到的结果不是我们期望的 2,而是 1。

1.3 原子性操作

多线程环境下中,Java 只保证了基本数据类型的变量和赋值操作才是原子性的( 注:在32位的JDK环境下,对64位数据的读取不是原子性操作*,如long、double )

1.4 原子性问题如何解决

如果我们能够保证对共享变量的修改是互斥的,那么,无论是单核 CPU 还是多核 CPU,就都能保证原子性了。加锁可以解决原子性问题,如使用 synchronized、lock 。

2 可见性

2.1 可见性定义

可见性指多个线程操作一个共享变量时,其中一个线程对变量进行修改后,其他线程可以立即看到修改的结果。

2.2 可见性问题原因

CPU 缓存与内存的数据一致性是导致可见性问题的原因,CPU 缓存是为了提高 CPU 的效率。

2.3 可见性问题解决

产生可见性问题的原因是 CPU 缓存,那我们禁用 CPU 缓存就可以了。

  • volatile 字段能禁用 CPU 缓存,解决可见性问题。
  • synchronized 和锁都可以保证可见性。

2.4 可见性规则是什么

可见性规则就是 Happens-Before 规则 。

Happens-Before 规则:

  • 简单来说就是: 前面一个操作的结果对后续操作是可见的
  • Happens-Before 约束了编译器的优化行为,虽允许编译器优化,但是要求编译器优化后一定遵守 Happens-Before 规则。

2.5 Happens-Before 规则

  • 程序的顺序性规则

在一个线程中,按照程序顺序,前面的操作 Happens-Before 于后续的任意操作。

class Example {
  public void test() {
    int x = 42;   ①
    int y = 20;   ②
  }
 
}

①  Happens-Before ② 。

  • volatile 变量规则

对一个 volatile 变量的写操作, Happens-Before 于后续对这个 volatile 变量的读操作。

  • 传递性规则

如果 A Happens-Before B,且 B Happens-Before C,那么 A Happens-Before C。

class Example {
  int x = 0;
  volatile int y = 0;
  public void writer() {
    x = 42;      ①
    y = 1;       ②
  }
  public void reader() {
    if (y == 1) {  ③
      // 这里x会是多少呢?
    }
  }
}
  • ① Happens-Before ② ,满足规则1-顺序性规则。
  • ② Happens-Before ③,满足规则2-volatile 变量规则。
  • ① Happens-Before ③,满足规则3-传递性规则。如果 y == 1,则 x = 42;
  • 管程中锁的规则

对一个锁的解锁 Happens-Before 于后续对这个锁的加锁。

管程是一种通用的同步原语,在 Java 中指的就是 synchronized,synchronized 是 Java 里对管程的实现。

synchronized (this) { //此处自动加锁
  // x是共享变量,初始值=10
  if (this.x <p>假设 x 的初始值是 10,线程 A 执行完代码块后 x 的值会变成 12(执行完自动释放锁);</p><p>线程 B 进入代码块时,能够看到线程 A 对 x 的写操作,也就是线程 B 能够看到 x==12。</p>
  • 线程 start() 规则

它是指主线程 A 启动子线程 B 后,子线程 B 能够看到主线程在启动子线程 B 前的操作。

  • 线程 join() 规则

它是指主线程 A 等待子线程 B 完成(主线程 A 通过调用子线程 B 的 join() 方法实现),当子线程 B 完成后(主线程 A 中 join() 方法返回),主线程能够看到子线程的操作。当然所谓的“看到”,指的是对共享变量的操作。

3 有序性

3.1 有序性的定义

有序性,即程序的执行顺序按照代码的先后顺序来执行。

3.2 有序性问题原因

编译器为了优化性能,有时候会改变程序中语句的先后顺序。

例如:“a=6;b=7;”编译器优化后可能变成“b=7;a=6;”,在这个例子中,编译器调整了语句的顺序,但是不影响程序的最终结果。

以双重检查代码为例:

public class Singleton {
  static Singleton instance;
  static Singleton getInstance(){
    if (instance == null) {    ①
      synchronized(Singleton.class) {
        if (instance == null)
          instance = new Singleton();  ②
        }
    }
    return instance;
  }
}

上面的代码有问题,问题在 ② 操作上:经过优化后的执行路径是这样的:

  1. 分配一块内存 M;
  2. 将 M 的地址赋值给 instance 变量;
  3. 最后在内存 M 上初始化 Singleton 对象。

优化后会导致什么问题呢?我们假设线程 A 先执行 getInstance() 方法,当执行完 ① 时恰好发生了线程切换,切换到了线程 B 上;如果此时线程 B 也执行 getInstance() 方法,那么线程 B 在执行第一个判断时会发现 instance != null ,所以直接返回 instance,而此时的 instance 是没有初始化过的,如果我们这个时候访问 instance 的成员变量就可能触发空指针异常。

如何解决双重检查问题?变量用 volatile 来修饰,禁止指令重排序

public class Singleton {
  static volatile Singleton instance;
  static Singleton getInstance(){
    if (instance == null) {    ①
      synchronized(Singleton.class) {
        if (instance == null)
          instance = new Singleton();  ②
        }
    }
    return instance;
  }
}

推荐学习:《java视频教程

声明:本文转载于:CSDN,如有侵犯,请联系admin@php.cn删除