java 赋值 原子性_Java内存模型之原子性问题

本博客系列是学习并发编程过程中的记录总结。由于文章比较多，写的时间也比较散，所以我整理了个目录贴(传送门)，方便查阅。

前言

之前的文章中讲到，JMM是内存模型规范在Java语言中的体现。JMM保证了在多核CPU多线程编程环境下，对共享变量读写的原子性、可见性和有序性。

本文就具体来讲讲JMM是如何保证共享变量访问的原子性的。

原子性问题

原子性是指：一个或多个操作，要么全部执行且在执行过程中不被任何因素打断，要么全部不执行。在Java中当我们讨论一个操作具有原子性问题是一般就是指这个操作会被线程的随机调度打断。

下面就是一段会出现原子性问题的代码：

public class AtomicProblem {

private static Logger logger = LoggerFactory.getLogger(AtomicProblem.class);

public static final int THREAD_COUNT = 10;

public static void main(String[] args) throws Exception {

BankAccount sharedAccount = new BankAccount("account-csx",0.00);

ArrayList threads = new ArrayList<>();

for (int i = 0; i < THREAD_COUNT; i++) {

Thread thread = new Thread(new Runnable() {

@Override

public void run() {

for (int j = 0; j < 1000 ; j++) {

sharedAccount.deposit(10.00);

}

}

});

thread.start();

threads.add(thread);

}

for (Thread thread : threads) {

thread.join();

}

logger.info("the balance is:{}",sharedAccount.getBalance());

}

public static class BankAccount {

private String accountName;

public double getBalance() {

return balance;

}

private double balance;

public BankAccount(String accountName, double balance){

this.accountName = accountName;

this.balance =balance;

}

public double deposit(double amount){

balance = balance + amount;

return balance;

}

public double withdraw(double amount){

balance = balance - amount;

return balance;

}

public String getAccountName() {

return accountName;

}

public void setAccountName(String accountName) {

this.accountName = accountName;

}

}

}

上面的代码中开启了10个线程，每个线程会对共享的银行账户进行1000次存款操作，每次存款10块，所以理论上最后银行账户中的钱应该是10 * 1000 * 10 = 100000块。我执行了多次上面的代码，很多次最后的结果的确是100000，但是也有几次的结果并不是我们预期的。

14:40:25.981 [main] INFO com.csx.demo.spring.boot.concurrent.jmm.AtomicProblem - the balance is:98260.0

出现上面结果的原因就是因为下面的操作并不是原子操作，其中的balance是一个共享变量。在多线程环境下可能会被打断。

balance = balance + amount;

上面的赋值操作被分为多步执行完成，下面简单解析下两个线程对balance同时加10的过程(模拟存款过程，假设balance的初始值还是0)

线程1从共享内存中加载balance的初始值0到工作内存

线程1对工作内存中的值加10

//此时线程1的CPU时间耗尽，线程2获得执行机会

线程2从共享内存中加载balance的初始值到工作内存，此时balance的值还是0

线程2对工作内存中的值加10，此时线程2工作内存中的副本值是10

线程2将balance的副本值刷新回共享内存，此时共享内存中balance的值是10

//线程2CPU时间片耗尽，线程1又获得执行机会

线程1将工作内存中的副本值刷新回共享内存，但是此时副本的值还是10，所以最后共享内存中的值也是10

上面简单模拟了一个原子性问题导致程序最终结果出错的过程。

JMM对原子性问题的保证

自带原子性保证

在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作(例外就是long和double的非原子性协定，大家只要知道这件事情就可以了，无须太过在意这些几乎不会发生的例外情况)。

a = true; //原子性

a = 5; //原子性

a = b; //非原子性，分两步完成，第一步加载b的值，第二步将b赋值给a

a = b + 2; //非原子性，分三步完成

a ++; //非原子性，分三步完成

synchronized

synchronized可以保证操作结果的原子性。synchronized保证原子性的原理也很简单，因为synchronized可以防止多个线程并发执行一段代码。还是用上面存款的场景做列子，我们只需要将存款的方法设置成synchronized的就能保证原子性了。

public synchronized double getBalance() {

return balance;

}

public synchronized double deposit(double amount){

balance = balance + amount; //1

return balance;

}

加了synchronized后，当一个线程没执行完deposit这个方法前，其他线程是不能执行这段代码的。其实我们发现synchronized并不能将上面的代码1编程原子性操作，上面的代码1还是有可能被中断的，但是即使被中断了其他线程也不能访问共享变量balance，当之前被中断的线程继续执行时得到的结果还是正确的。

因此synchronized对原子性问题的保证是从最终结果上来保证的，也就是说它只保证最终的结果正确，中间操作的是否被打断没法保证。这个和CAS操作需要对比着看。

PS：对于上面的getBalance方法大家可能会有点疑惑：只读操作为什么还要加上synchronized关键字。其实这边加上synchronized关键字的目的是为了保证balance变量的可见性，进入synchronized代码块每次都会去从主内存中读取最新值。

Lock锁

public double deposit(double amount) {

readWriteLock.writeLock().lock();

try {

balance = balance + amount;

return balance;

} finally {

readWriteLock.writeLock().unlock();

}

}

Lock锁保证原子性的原理和synchronized类似，这边不进行赘述了。

原子操作类型

public static class BankAccount {

//省略其他代码

private AtomicDouble balance;

public double deposit(double amount) {

return balance.addAndGet(amount);

}

//省略其他代码

}

JDK提供了很多原子操作类来保证操作的原子性。原子操作类的底层是使用CAS机制的，这个机制对原子性的保证和synchronized有本质的区别。CAS机制保证了整个赋值操作是原子的不能被打断的，而synchronized值能保证代码最后执行结果的正确性，也就是说synchronized能消除原子性问题对代码最后执行结果的影响。

PS：JVM中的CAS操作是利用处理器提供的CMPXCHG指令实现的。

简单总结

在多线程编程环境下(无论是多核CPU还是单核CPU)，对共享变量的访问存在原子性问题。这个问题可能会导致程序错误的执行结果。JMM主要提供了如下的方式来保证操作的原子，保证程序不受原子性问题的影响。

synchronized机制：保证程序最终正确性，是的程序不受原子性问题的影响；

Lock接口：和synchronized类似；

原子操作类：底层使用CAS机制，能保证操作真正的原子性。