当前位置：首页 > news >正文

Java并发编程-理论基础

news 来源：原创 2025/6/9 8:40:55

Java并发编程-理论基础

1、什么是进程？

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

2、什么是线程？

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程，如Win32线程；由用户进程自行调度的用户线程，如Linux平台的POSIX Thread；或者由内核与用户进程，如Windows 7的线程，进行混合调度。

同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈（call stack），自己的寄存器环境（register context），自己的线程本地存储（thread-local storage）。

一个进程可以有很多线程，每条线程并行执行不同的任务。

在多核或多CPU，或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见，即提高了程序的执行吞吐率。在单CPU单核的计算机上，使用多线程技术，也可以把进程中负责I/O处理、人机交互而常被阻塞的部分与密集计算的部分分开来执行，编写专门的workhorse线程执行密集计算，从而提高了程序的执行效率。

进程与线程的对比：

特性	进程	线程
定义	资源分配的基本单位	CPU调度的基本单位
内存空间	独立内存空间	共享进程内存空间
通信	需要IPC机制(管道、消息队列等)	可直接读写进程数据段
创建开销	大(需要分配独立资源)	小(共享已有资源)
稳定性	一个进程崩溃不影响其他进程	一个线程崩溃可能导致整个进程崩溃
并发性	进程间并发	线程间并发

3、为什么需要多线程？

从CPU、内存、I/O速度差异的角度分析
计算机系统中，CPU、内存、I/O设备的速度差异极大：

CPU 计算速度极快（纳秒级）
内存访问速度较慢（百纳秒级）
I/O设备（磁盘、网络）更慢（毫秒级，比CPU慢百万倍）

为了合理利用CPU的高性能，计算机体系结构、操作系统和编译器分别采用了优化手段，但也引入了并发问题：

1. CPU缓存（Cache）——解决CPU与内存速度差异

问题：CPU计算速度远高于内存访问速度，直接读写内存会导致CPU大部分时间等待（内存墙问题）。
解决方案：引入多级缓存（L1/L2/L3 Cache），减少CPU访问内存的次数。
副作用（可见性问题）：

- 多线程环境下，一个线程修改了缓存数据，另一个线程可能无法立即看到（缓存一致性问题）。
- 需要内存屏障（Memory Barrier）或volatile关键字保证可见性。

总结：缓存提高CPU利用率，但导致多线程间数据不可见。

2. 进程/线程分时复用——解决CPU与I/O速度差异

问题：I/O操作（磁盘、网络）极慢，单线程程序会让CPU大部分时间等待I/O。
解决方案：

- 进程：操作系统提供隔离的执行环境，但切换开销大。
- 线程：轻量级执行单元，共享进程资源，切换成本低。
- 多线程：当一个线程等待I/O时，CPU可以执行其他线程（提高利用率）。

副作用（原子性问题）：

- 线程切换可能导致非原子操作被中断（如i++并非原子操作）。
- 需要锁（synchronized）或CAS（Compare-And-Swap）保证原子性。

总结：多线程提高CPU利用率，但导致竞态条件（Race Condition）。

3. 编译器/CPU指令重排序——优化缓存利用率

问题：为了减少CPU等待数据的时间，编译器和CPU会优化指令执行顺序（如乱序执行）。
解决方案：

- 指令重排：调整无关指令的顺序，提高缓存命中率。

副作用（有序性问题）：

- 多线程环境下，指令重排可能导致逻辑错误（如单例模式的双重检查锁失效）。
- 需要内存屏障（Memory Barrier）或volatile禁止重排序。

总结：指令重排提高性能，但导致多线程执行顺序不可预测。

4、线程不安全如何产生的？（Java中）

如果多个线程对同一个共享数据进行访问而不采取同步操作的话，那么操作的结果是不一致的。

银行账户取款问题

public class UnsafeBankAccount {private int balance; // 共享数据public UnsafeBankAccount(int initialBalance) {this.balance = initialBalance;}// 不安全的取款方法public void withdraw(int amount) {if (amount <= balance) {// 模拟一些处理时间try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}balance -= amount;System.out.println(Thread.currentThread().getName() + " 取款 " + amount + " 成功，余额: " + balance);} else {System.out.println(Thread.currentThread().getName() + " 取款 " + amount + " 失败，余额不足");}}public static void main(String[] args) {UnsafeBankAccount account = new UnsafeBankAccount(1000);// 创建多个线程同时取款for (int i = 0; i < 10; i++) {new Thread(() -> account.withdraw(800)).start();}}
}

运行结果：

问题分析

竞态条件(Race Condition)

- 多个线程同时检查余额 if (amount <= balance)
- 在检查后但实际扣款前，其他线程可能已经修改了余额
- 导致多个线程都认为可以取款，最终余额变为负数

操作非原子性

balance -= amount 不是原子操作，它实际上是：

- java复制下载

int temp = balance;
temp = temp - amount;
balance = temp;

- 线程可能在中间步骤被中断

内存可见性问题

- 一个线程对balance的修改可能不会立即对其他线程可见
- 导致线程看到的是过期的balance值

线程不安全的核心原因

共享数据的并发访问：多个线程同时读写同一个变量
操作的非原子性：操作不是一次性完成的，可能被中断
缺乏同步机制：没有使用synchronized、Lock等同步手段
内存可见性问题：线程可能看不到其他线程的最新修改

5、并发三要素

在并发编程中，问题的根源可以归结为三个核心要素：可见性、原子性、有序性

可见性（visibility）

可见性问题指的是一个线程对共享变量的修改，另一个线程不能立即看到。这是由于现代计算机架构中CPU缓存与主内存之间的同步延迟导致的。

可见性问题源于现代计算机的多级存储架构：

CPU缓存架构：每个CPU核心有自己的缓存（L1、L2），多个核心共享L3缓存
缓存一致性协议：如MESI协议，但存在延迟
编译器优化：可能将变量缓存在寄存器中而不是从内存读取

在Java内存模型(JMM)中，每个线程有自己的工作内存（可以理解为CPU缓存的抽象），导致线程对共享变量的修改可能不会立即同步到主内存，其他线程也就无法立即看到修改。

可见性完整案例

案例1：体现可见性问题的服务控制器（基础可见性问题）

package com.taiyuan.javademoone.threaddemo.demo001;import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;/*** 修改后的ServiceController，强制体现可见性问题* 通过纯空循环和长时间运行来暴露可见性问题*/
public class ServiceController {// 无volatile修饰，保证会出现可见性问题private static boolean isRunning = true;//TODO 解决方案1、添加volatile修饰，保证可见性//    private static volatile boolean isRunning = true;// TODO 解决方案2、AtomicBoolean，保证可见性//    private static AtomicBoolean isRunning = new AtomicBoolean(true);// TODO 解决方案3、使用synchronized关键字，保证可见性//    public static synchronized boolean isRunning() {//        return isRunning;//    }//    public static synchronized void stopRunning() {//        isRunning = false;//    }// TODO 解决方案4、使用Lock，保证可见性private static final Lock lock = new ReentrantLock();public static boolean isRunning() {lock.lock();try {return isRunning;} finally {lock.unlock();}}public static void stopRunning() {lock.lock();try {isRunning = false;} finally {lock.unlock();}}// 添加一个计数器，用于验证循环执行次数private static long counter = 0;public static void main(String[] args) throws InterruptedException {// 工作线程 - 使用纯空循环Thread worker = new Thread(() -> {while (isRunning) {counter++;  // 纯计数操作，无任何同步点}System.out.println("工作线程停止，循环次数: " + counter);});worker.start();// 主线程稍后停止服务Thread.sleep(3000);isRunning = false;//        stopRunning();System.out.println("主线程将isRunning设置为false");// 等待工作线程结束(最多10秒)worker.join(10000);if (worker.isAlive()) {System.out.println("警告：工作线程未能正常停止！");System.out.println("最后计数: " + counter);}}
}

解决可见性问题：

方案1：使用volatile（推荐）

private static volatile boolean isRunning = true;

方案2：使用AtomicBoolean

private static AtomicBoolean isRunning = new AtomicBoolean(true);// 在循环中
while (isRunning.get()) { ... }// 设置停止
isRunning.set(false);

方案3：使用synchronized方法

private static boolean isRunning = true;public static synchronized boolean isRunning() {return isRunning;
}public static synchronized void stopRunning() {isRunning = false;
}// 使用方式
while (isRunning()) { ... }
stopRunning();

方案4：使用Lock

private static boolean isRunning = true;
private static final Lock lock = new ReentrantLock();public static boolean isRunning() {lock.lock();try {return isRunning;} finally {lock.unlock();}
}public static void stopRunning() {lock.lock();try {isRunning = false;} finally {lock.unlock();}
}

原子性（Atomicity）

原子性是指一个操作或一系列操作作为一个不可分割的整体执行，要么全部完成，要么完全不执行。在多线程环境中，非原子操作会导致竞态条件（Race Condition），产生不可预期的结果。

原子性三要素：

不可分割：操作过程不会被线程调度打断
完全成功或完全失败：没有中间状态
状态一致性：操作前后系统状态保持一致

原子性案例：

1、银行账户转账（经典竞态条件）

package com.taiyuan.javademoone.threaddemo.demo002;/*** BankAccount 类表示一个银行账户，用于演示多线程环境下的转账操作*/
public class BankAccount {// 定义账户余额private int balance;// 构造函数，初始化账户余额public BankAccount(int initialBalance) {this.balance = initialBalance;}/** transfer 方法用于从一个账户向另一个账户转账*/public void transfer(BankAccount dest, int amount) {// 判断账户余额是否足够if (this.balance >= amount) {// 模拟处理延迟（放大竞态窗口）try { Thread.sleep(10); } catch (InterruptedException e) {}// 扣款this.balance -= amount;// 收款dest.balance += amount;// 打印转账成功信息System.out.println(Thread.currentThread().getName() +" 转账成功: " + amount);}}/*** 获取账户余额*/public int getBalance() {return balance;}
}

2、测试类（暴露问题）

package com.taiyuan.javademoone.threaddemo.demo002;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;/*** 银行转账示例*/
public class BankTransferDemo {public static void main(String[] args) throws InterruptedException {// 创建两个账户，初始余额为1000BankAccount accountA = new BankAccount(1000);BankAccount accountB = new BankAccount(1000);// 输出初始余额System.out.println("初始余额:");System.out.println("账户A: " + accountA.getBalance());System.out.println("账户B: " + accountB.getBalance());// 创建转账线程池ExecutorService executor = Executors.newFixedThreadPool(10);// 模拟100次从A向B转账10元for (int i = 0; i < 100; i++) {executor.execute(() -> accountA.transfer(accountB, 10));}// 模拟100次从B向A转账10元for (int i = 0; i < 100; i++) {executor.execute(() -> accountB.transfer(accountA, 10));}// 关闭线程池executor.shutdown();// 等待线程池中的任务执行完毕executor.awaitTermination(1, TimeUnit.MINUTES);// 输出最终余额System.out.println("\n最终余额:");System.out.println("账户A: " + accountA.getBalance());System.out.println("账户B: " + accountB.getBalance());System.out.println("总额: " + (accountA.getBalance() + accountB.getBalance()));}
}

测试结果

结果分析：

出现总额不为2070的情况，说明发生了竞态条件导致金额不一致。

3、解决方案

1、synchronized方法同步

package com.taiyuan.javademoone.threaddemo.demo003;/*** 线程安全的银行账户类（使用synchronized解决原子性问题）*/
public class SynchronizedBankAccount {private int balance;public SynchronizedBankAccount(int initialBalance) {this.balance = initialBalance;}/*** 线程安全的转账方法** @param dest   目标账户* @param amount 转账金额* @return 转账成功返回true，否则返回false*/public boolean transfer(SynchronizedBankAccount dest, int amount) {// 按照账户对象的哈希值确定锁顺序，避免死锁SynchronizedBankAccount first = this.hashCode() < dest.hashCode() ? this : dest;SynchronizedBankAccount second = this.hashCode() < dest.hashCode() ? dest : this;// 先锁定账户1，再锁定账户2  （避免死锁）synchronized (first) {synchronized (second) {// 检查余额是否充足if (this.balance < amount) {System.out.println(Thread.currentThread().getName() +" 转账失败: 余额不足 (当前余额=" + this.balance + ")");return false;}// 模拟处理延迟try {Thread.sleep(10);} catch (InterruptedException e) {Thread.currentThread().interrupt();return false;}// 执行转账this.balance -= amount;dest.balance += amount;System.out.println(Thread.currentThread().getName() +" 转账成功: " + amount +" (转出账户余额=" + this.balance +", 目标账户余额=" + dest.balance + ")");return true;}}}/*** 获取账户余额（线程安全）*/public synchronized int getBalance() {return balance;}
}

测试：

package com.taiyuan.javademoone.threaddemo.demo003;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;/*** 银行账户转账测试类* 本类用于测试在多线程环境下，两个银行账户之间的转账操作是否能够正确执行* 通过创建两个初始余额相同的银行账户，使用固定数量的线程执行多次相互转账操作，* 最后检查两个账户的总余额是否与初始总余额相等，以此验证转账操作的线程安全性*/
public class BankTransferTest {// 初始余额常量private static final int INITIAL_BALANCE = 1000;// 每次转账金额常量private static final int TRANSFER_AMOUNT = 10;// 转账操作次数常量private static final int TRANSFER_COUNT = 100;// 线程池线程数量常量private static final int THREAD_COUNT = 10;public static void main(String[] args) throws InterruptedException {// 创建两个银行账户SynchronizedBankAccount accountA = new SynchronizedBankAccount(INITIAL_BALANCE);SynchronizedBankAccount accountB = new SynchronizedBankAccount(INITIAL_BALANCE);// 打印初始余额System.out.println("========== 初始余额 ==========");System.out.println("账户A余额: " + accountA.getBalance());System.out.println("账户B余额: " + accountB.getBalance());System.out.println("总额: " + (accountA.getBalance() + accountB.getBalance()));// 创建线程池ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);// 启动转账任务System.out.println("\n========== 开始转账 ==========");for (int i = 0; i < TRANSFER_COUNT; i++) {// A向B转账executor.execute(() -> accountA.transfer(accountB, TRANSFER_AMOUNT));// B向A转账executor.execute(() -> accountB.transfer(accountA, TRANSFER_AMOUNT));}// 关闭线程池并等待任务完成executor.shutdown();executor.awaitTermination(1, TimeUnit.MINUTES);// 打印最终余额System.out.println("\n========== 最终余额 ==========");System.out.println("账户A余额: " + accountA.getBalance());System.out.println("账户B余额: " + accountB.getBalance());// 验证总额不变int total = accountA.getBalance() + accountB.getBalance();int expectedTotal = 2 * INITIAL_BALANCE;System.out.println("总额: 实际=" + total + ", 预期=" + expectedTotal +(total == expectedTotal ? " (正确)" : " (错误!)"));}
}

运行结果：

2、ReentrantLock显式锁

package com.taiyuan.javademoone.threaddemo.demo004;import java.util.concurrent.locks.ReentrantLock;/*** BankAccount 类表示一个银行账户，使用ReentrantLock保证线程安全*/
public class BankLockAccount {// 账户余额private int balance;// 可重入锁private final ReentrantLock lock = new ReentrantLock();// 构造函数，初始化账户余额public BankLockAccount(int initialBalance) {this.balance = initialBalance;}/*** transfer 方法用于从一个账户向另一个账户转账* 使用ReentrantLock保证线程安全*/public void transfer(BankLockAccount dest, int amount) {// 确定锁获取顺序（例如通过hashCode比较）这种通过对象哈希码决定锁顺序的方法是一种常见的死锁避免策略，称为锁排序（Lock Ordering）。BankLockAccount first = this.hashCode() < dest.hashCode() ? this : dest;BankLockAccount second = this.hashCode() < dest.hashCode() ? dest : this;first.lock.lock();try {second.lock.lock();try {if (this.balance >= amount) {try { Thread.sleep(10); } catch (InterruptedException e) {}this.balance -= amount;dest.balance += amount;System.out.println(Thread.currentThread().getName() +" 转账成功: " + amount);}} finally {second.lock.unlock();}} finally {first.lock.unlock();}}/*** 获取账户余额*/public int getBalance() {lock.lock();try {return balance;} finally {lock.unlock();}}
}

测试：

package com.taiyuan.javademoone.threaddemo.demo004;import java.util.concurrent.locks.ReentrantLock;/*** BankAccount 类表示一个银行账户，使用ReentrantLock保证线程安全*/
public class BankLockAccount {// 账户余额private int balance;// 可重入锁private final ReentrantLock lock = new ReentrantLock();// 构造函数，初始化账户余额public BankLockAccount(int initialBalance) {this.balance = initialBalance;}/*** transfer 方法用于从一个账户向另一个账户转账* 使用ReentrantLock保证线程安全*/public void transfer(BankLockAccount dest, int amount) {// 确定锁获取顺序（例如通过hashCode比较）这种通过对象哈希码决定锁顺序的方法是一种常见的死锁避免策略，称为锁排序（Lock Ordering）。BankLockAccount first = this.hashCode() < dest.hashCode() ? this : dest;BankLockAccount second = this.hashCode() < dest.hashCode() ? dest : this;first.lock.lock();try {second.lock.lock();try {if (this.balance >= amount) {try { Thread.sleep(10); } catch (InterruptedException e) {}this.balance -= amount;dest.balance += amount;System.out.println(Thread.currentThread().getName() +" 转账成功: " + amount);}} finally {second.lock.unlock();}} finally {first.lock.unlock();}}/*** 获取账户余额*/public int getBalance() {lock.lock();try {return balance;} finally {lock.unlock();}}
}

3、使用AtomicReference（无锁方案）

package com.taiyuan.javademoone.threaddemo.demo0005;import java.util.concurrent.atomic.AtomicReference;/*** 使用AtomicReference实现的无锁银行账户*/
public class AtomicBankAccount {// 使用AtomicReference包装账户余额// AtomicReference<Integer>：提供对 Integer 类型值的原子操作，确保多线程环境下数据一致性。/*** AtomicReference 是 Java 中 java.util.concurrent.atomic 包的一部分，* 它提供了一种原子操作方式，用于更新引用类型的变量。* 与其他原子类（如 AtomicInteger 和 AtomicLong）类似，* AtomicReference 允许你在多线程环境下安全地对对象引用进行更新，* 而无需使用传统的同步机制（例如 synchronized 关键字）。*/private final AtomicReference<Integer> balanceRef;public AtomicBankAccount(int initialBalance) {this.balanceRef = new AtomicReference<>(initialBalance);}/*** 无锁转账实现** @param dest   目标账户* @param amount 转账金额* @return 转账成功返回true，否则返回false*/public boolean transfer(AtomicBankAccount dest, int amount) {// 参数检查if (amount <= 0) {return false;}/** CAS 是一种 硬件支持的原子指令，它在 Java 中通过 AtomicReference 和 Unsafe 类等机制实现。它的核心思想是：* 在更新一个值时，先检查该值是否与预期一致，如果一致则更新为新值，否则重试。*/// 使用CAS循环实现原子转账操作while (true) {// 获取当前转出账户余额的快照Integer current = balanceRef.get();// 检查当前余额是否足够进行转账if (current < amount) {// 余额不足时打印转账失败信息，并返回false表示转账失败System.out.println(Thread.currentThread().getName() +" 转账失败: 余额不足");return false;}// 模拟处理转账过程中的延迟，增加并发情况下冲突的可能性try {Thread.sleep((int) (Math.random() * 10));} catch (InterruptedException e) {// 当线程被中断时，设置中断标志并返回false表示转账失败Thread.currentThread().interrupt();return false;}// 使用CAS操作更新转出账户的余额if (balanceRef.compareAndSet(current, current - amount)) {// 更新目标账户余额，同样需要使用CAS操作以确保原子性while (true) {// 获取目标账户当前余额的快照Integer destCurrent = dest.balanceRef.get();// 使用CAS操作更新目标账户余额，成功则打印转账信息并返回true表示转账成功if (dest.balanceRef.compareAndSet(destCurrent, destCurrent + amount)) {System.out.println(Thread.currentThread().getName() +" 转账成功: " + amount +" (转出账户余额=" + (current - amount) +", 目标账户余额=" + (destCurrent + amount) + ")");return true;}}}// CAS操作失败则重试整个转账过程}}public int getBalance() {return balanceRef.get();}
}

测试：

package com.taiyuan.javademoone.threaddemo.demo0005;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;/*** AtomicBankTransferTest 类用于演示使用原子操作实现银行账户转账的线程安全性*/
public class AtomicBankTransferTest {// 定义初始余额常量private static final int INITIAL_BALANCE = 1000;// 定义每次转账金额常量private static final int TRANSFER_AMOUNT = 10;// 定义转账次数常量private static final int TRANSFER_COUNT = 100;// 定义线程池大小常量private static final int THREAD_COUNT = 10;/*** 主函数执行多个线程安全的转账操作* @param args 命令行参数* @throws InterruptedException 如果在等待线程池终止时被中断*/public static void main(String[] args) throws InterruptedException {// 初始化两个账户，账户A和账户B，每个账户初始余额为INITIAL_BALANCEAtomicBankAccount accountA = new AtomicBankAccount(INITIAL_BALANCE);AtomicBankAccount accountB = new AtomicBankAccount(INITIAL_BALANCE);// 打印初始余额System.out.println("初始余额:");System.out.println("账户A: " + accountA.getBalance());System.out.println("账户B: " + accountB.getBalance());// 创建固定大小的线程池ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);// 启动转账任务for (int i = 0; i < TRANSFER_COUNT; i++) {// 从账户A向账户B转账TRANSFER_AMOUNT金额executor.execute(() -> accountA.transfer(accountB, TRANSFER_AMOUNT));// 从账户B向账户A转账TRANSFER_AMOUNT金额executor.execute(() -> accountB.transfer(accountA, TRANSFER_AMOUNT));}// 关闭线程池，并等待所有任务完成executor.shutdown();// 等待所有任务完成executor.awaitTermination(1, TimeUnit.MINUTES);// 打印最终余额System.out.println("\n最终余额:");System.out.println("账户A: " + accountA.getBalance());System.out.println("账户B: " + accountB.getBalance());System.out.println("总额: " + (accountA.getBalance() + accountB.getBalance()));}
}

有序性(Ordering)

有序性（ordering）：指程序执行的顺序必须符合预期，不能出现乱序的情况。在多线程环境下，由于编译器、处理器、缓存等因素的影响，程序执行的顺序可能会出现不一致的情况，导致程序出现错误。为了保证有序性，可以使用volatile关键字或者显式地使用锁来实现。同时，Java提供了happens-before规则，它可以保证在特定情况下，操作的顺序是按照预期的顺序执行的。

导致有序性问题的三大原因：

编译器优化重排序：在不改变单线程语义的前提下，编译器可能调整指令顺序
处理器指令级并行：现代CPU采用流水线、乱序执行等技术
内存系统重排序：由于多级缓存的存在，内存操作可能表现出乱序行为

Java提供了多种机制来保证有序性：

1. volatile关键字

volatile关键字可以：

禁止指令重排序（通过内存屏障实现）
保证变量的可见性

2. synchronized关键字

synchronized通过互斥锁保证：

同一时刻只有一个线程能访问同步代码块
在进入同步块前会清空工作内存，退出时会将变量刷新回主内存
禁止指令重排序

3. final关键字

正确初始化的final字段可以保证：

在构造函数完成初始化后对其他线程可见
禁止对final字段的写操作重排序到构造函数之外

4. happens-before原则

Java内存模型定义的happens-before关系保证了有序性，包括：

程序顺序规则
监视器锁规则
volatile变量规则
线程启动规则
线程终止规则
线程中断规则
对象终结规则
传递性

5. 原子类

java.util.concurrent.atomic包下的原子类使用CAS操作和volatile语义保证有序性。

6、什么是happens-before原则？

Happens-Before原则是Java内存模型(JMM)的核心理论，它从语言层面定义了多线程环境中操作之间的可见性规则，为开发者提供了一种理解并发程序行为的框架。

Happens-Before关系本质上是一种可见性保证契约：

如果操作A happens-before 操作B，那么A的所有写操作对B都是可见的
这种关系可以跨线程传递
JVM必须遵守这些规则，但可以在不违反规则的前提下进行优化

Happens-Before（先行发生）原则的定义：

程序次序规则（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的结论。