本篇内容介绍了“Java并发编程的三要素是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
为安丘等地区用户提供了全套网页设计制作服务，及安丘网站建设行业解决方案。主营业务为成都网站制作、网站建设、安丘网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！
原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。
线程切换是产生原子性问题的原因，线程切换是为了提高 CPU 的利用率。
以 count ++ 为例，至少需要三条 CPU 指令：
指令 1：首先，需要把变量 count 从内存加载到 CPU 的寄存器；
指令 2：之后，在寄存器中执行 +1 操作；
指令 3：最后，将结果写入内存（缓存机制导致可能写入的是 CPU 缓存而不是内存）。
我们假设 count=0，如果线程 A 在指令 1 执行完后做线程切换，线程 A 和线程 B 按照下图的序列执行，那么我们会发现两个线程都执行了 count+=1 的操作，但是得到的结果不是我们期望的 2，而是 1。
多线程环境下中，Java 只保证了基本数据类型的变量和赋值操作才是原子性的（ 注：在32位的JDK环境下，对64位数据的读取不是原子性操作*，如long、double）
如果我们能够保证对共享变量的修改是互斥的，那么，无论是单核 CPU 还是多核 CPU，就都能保证原子性了。加锁可以解决原子性问题，如使用 synchronized、lock 。
可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。
CPU 缓存与内存的数据一致性是导致可见性问题的原因，CPU 缓存是为了提高 CPU 的效率。
产生可见性问题的原因是 CPU 缓存，那我们禁用 CPU 缓存就可以了。
volatile 字段能禁用 CPU 缓存，解决可见性问题。
synchronized 和锁都可以保证可见性。
可见性规则就是 Happens-Before 规则 。
Happens-Before 规则：
简单来说就是： 前面一个操作的结果对后续操作是可见的。
Happens-Before 约束了编译器的优化行为，虽允许编译器优化，但是要求编译器优化后一定遵守 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 < 12) {
this.x = 12;
}
} //此处自动解锁假设 x 的初始值是 10，线程 A 执行完代码块后 x 的值会变成 12（执行完自动释放锁）;
线程 B 进入代码块时，能够看到线程 A 对 x 的写操作，也就是线程 B 能够看到 x==12。
线程 start() 规则
它是指主线程 A 启动子线程 B 后，子线程 B 能够看到主线程在启动子线程 B 前的操作。
线程 join() 规则
它是指主线程 A 等待子线程 B 完成（主线程 A 通过调用子线程 B 的 join() 方法实现），当子线程 B 完成后（主线程 A 中 join() 方法返回），主线程能够看到子线程的操作。当然所谓的“看到”，指的是对共享变量的操作。
有序性，即程序的执行顺序按照代码的先后顺序来执行。
编译器为了优化性能，有时候会改变程序中语句的先后顺序。
例如：“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;
}
}上面的代码有问题，问题在 ② 操作上：经过优化后的执行路径是这样的：
分配一块内存 M；
将 M 的地址赋值给 instance 变量；
最后在内存 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并发编程的三要素是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！
