1.变量原子性引发的问题
这里我们通过一个很经典的案例i++来分析下原子性问题
int i = 10;
i = i++;
此时i的值为：10
执行完i++后为什么结果是10，原因是因为i++操作，jvm底层实际是分为以下三步：（读-改-写）
int temp = i;
i = i + 1;
i = temp;
2.模拟原子性异常情况
package com.pyy.juc;
public class TestAtomicDemo {
public static void main(String[] args) {
AtomicDemo ad = new AtomicDemo();
for (int i = 0; i < 10; i++) {
new Thread(ad).start();
}
}
}
class AtomicDemo implements Runnable {
private volatile int serialNumber = 0;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
}
public int getSerialNumber() {
return serialNumber++;
}
}
结果：
Thread-3:0
Thread-1:8
Thread-2:7
Thread-7:3
Thread-5:0
Thread-6:2
Thread-4:1
Thread-0:6
Thread-9:5
Thread-8:4
通过结果我们发现出现 多个0线程安全情况。而引发这个情况的原因，就是变量的原子性问题引起的。
这里我们即使使用volatile修饰变量，但依次存在线程安全问题。原因就是因为 i++操作被jvm底层拆分成三部读-写-改操作。
虽然volatile 修饰后变量的修改（都在主存中执行）但由于原子性的问题，导致变量分步修改过程中其它线程读到了修改之前的变量值。
3. 解决原子性问题-原子变量AtomicXxx
JDK1.5之后，java.util.concurrent.atomic 包下提供了常用的原子变量AtomicXxx:
- 使用volatile 保证
内存可见性 - 使用CAS（Compare-And-Swap） 算法保证数据的原子性
CAS 算法其实是硬件对于并发操作共享数据的支持
CAS 包含了三个操作数：
内存值：V
预估值：A
更新值：B
当且仅当 V==A 时，V = B，否则将不做任何操作
下面通过一段代码模拟下CAS：
/*
* 模拟CAS算法
*/
class CAS {
// 内存值
private volatile int value;
// 获取内存值
public synchronized int getValue() {
return value;
}
//无论更新成功还是失败，都会返回旧的内存值
public synchronized int compareAndSwap(int expectedValue, int newValue) {
int oldValue = value;
if (oldValue == expectedValue) {
this.value = newValue;
}
return oldValue;
}
//判断更新是否成功，如果更新成功，旧的内存值会和预估值相等
public synchronized boolean compareAndSet(int expectedValue, int newValue) {
return expectedValue == compareAndSwap(expectedValue, newValue);
}
}
public class TestCAS {
public static void main(String[] args) {
CAS cas = new CAS();
//创建10个线程来模拟多线程环境
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
int expectedValue = cas.getValue();
boolean b = cas.compareAndSet(expectedValue, (int) (Math.random() * 101));
System.out.println(b);
}
}).start();
}
}
}
CAS算法之所以要比之前使用synchronized的效率高，是因为这次如果不成功，它不会放弃cpu执行权，会紧接着多次尝试，直到修改完毕。
代码使用AtomicXxx重构完毕后（解决变量原子性问题）：
package com.pyy.juc;
import java.util.concurrent.atomic.AtomicInteger;
public class TestAtomicDemo {
public static void main(String[] args) {
AtomicDemo ad = new AtomicDemo();
for (int i = 0; i < 10; i++) {
new Thread(ad).start();
}
}
}
class AtomicDemo implements Runnable {
//private int serialNumber = 0;
private AtomicInteger serialNumber = new AtomicInteger();
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
}
public int getSerialNumber() {
//return serialNumber++;
return serialNumber.getAndIncrement();
}
}
