一 . 可见性(visibility)
volatile关键字修饰的变量,如果值发生了改变,其他线程会立刻获取到,从而避免了出现脏读的情况。
public class TestVolatile {
public static void main(String[] args) {
MyData myData = new MyData();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("进入操作数据线程");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//调用方法 赋值
myData.changeData();
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"操作数据线程").start();
// 主线程查看数据是否改了
while (myData.data == 0){
}
System.out.println("main线程结束");
}
}
class MyData{
int data = 0;
public void changeData(){
this.data = 2020;
}
}
如上面代码,有两个线程在操作MyDdata数据类,看一下执行结果
从结果可以看出,main线程一直就没有获取到数据更新信息,内存中的数据存储用图直观的看一下
main线程的内存线程并没获取到数据更新。
下面变量加上volatile的效果
public class TestVolatile {
public static void main(String[] args) {
MyData myData = new MyData();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("进入操作数据线程");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//调用方法 赋值
myData.changeData();
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"操作数据线程").start();
// 主线程查看数据是否改了
while (myData.data == 0){
}
System.out.println("main线程结束");
}
}
class MyData{
volatile int data = 0;
public void changeData(){
this.data = 2020;
}
}
看一下执行结果
发现main方法已经获取到了数据更新。从而验证了volatile的可见性。
二 . 无法保证原子性
直接上代码
public class TestVolatile1 {
public static void main(String[] args) {
MyData1 myData = new MyData1();
new Thread(new Runnable() {
@Override
public void run() {
//调用方法 赋值
myData.changeData();
for(int i = 0;i < 9999;i++) {
myData.changeData();
}
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"线程1").start();
new Thread(new Runnable() {
@Override
public void run() {
//调用方法 赋值
myData.changeData();
for(int i = 0;i < 9999;i++) {
myData.changeData();
}
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"线程2").start();
new Thread(new Runnable() {
@Override
public void run() {
//调用方法 赋值
myData.changeData();
for(int i = 0;i < 9999;i++) {
myData.changeData();
}
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"线程3").start();
new Thread(new Runnable() {
@Override
public void run() {
//调用方法 赋值
myData.changeData();
for(int i = 0;i < 9999;i++) {
myData.changeData();
}
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"线程4").start();
while (Thread.activeCount() > 1) {
Thread.yield();
}
System.out.println("最终数值 :"+myData.data);
}
}
class MyData1{
volatile int data = 0;
public void changeData(){
data++;
}
}
咱们可以预测一下,如果正常的话,咱们应该得到的最终数据应该是40000 ,但结果如下
可以看到最终数据并不是我们想要的结果,多线程同时操作volatile修饰变量,无法保证数据的原子性。
那如何解决这个问题呢,用sychornized,可以处理,但是这是重量级锁,不推荐使用,还可以用 AtomicInteger 来处理这个情况实现代码如下
import java.util.concurrent.atomic.AtomicInteger;
public class TestVolatile1 {
public static void main(String[] args) {
MyData1 myData = new MyData1();
new Thread(new Runnable() {
@Override
public void run() {
//调用方法 赋值
myData.changeData();
for(int i = 0;i < 9999;i++) {
myData.changeData();
}
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"线程1").start();
new Thread(new Runnable() {
@Override
public void run() {
//调用方法 赋值
myData.changeData();
for(int i = 0;i < 9999;i++) {
myData.changeData();
}
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"线程2").start();
new Thread(new Runnable() {
@Override
public void run() {
//调用方法 赋值
myData.changeData();
for(int i = 0;i < 9999;i++) {
myData.changeData();
}
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"线程3").start();
new Thread(new Runnable() {
@Override
public void run() {
//调用方法 赋值
myData.changeData();
for(int i = 0;i < 9999;i++) {
myData.changeData();
}
System.out.println(Thread.currentThread().getName()+" : "+myData.data);
}
},"线程4").start();
while (Thread.activeCount() > 1) {
Thread.yield();
}
System.out.println("最终数值 :"+myData.data);
}
}
class MyData1{
AtomicInteger data = new AtomicInteger();
public void changeData(){
data.getAndIncrement();
}
}
执行结果如下
如此数据原子性问题便解决了。
三 . 指令重排
在JVM在编译Java代码的时候,或者CPU在执行JVM字节码的时候,对指令顺序进行重新排序。在不改变程序执行结果的前提下,优化程序的运行效率(不改变单线程下的程序执行结果)
看一段简单的代码
public class Data {
int a = 1; //步骤1
int b = 2; //步骤2
int c = a+b; //步骤3
}
单线程下,代码执行结果c的结果3,但是在执行的过程时候并不一定是1 , 2,3这个执行顺序,在发生指令重排后,可能是2,1,3。单线程下对工程并没有什么影响。
但是如果是多线程,就会出现问题。查看如下方法
public class Volatile {
int a = 1;
boolean flag = false;
public void dosome1() {
a = 2;// 步骤1
flag = true; //步骤2
}
public void dosome2() {
if(flag){
int b = a+a; // 步骤3
}
}
}
上面的代码步骤3其实是两个步骤,为了好理解,可以看成为一个步骤。
如果线程A 操作dosome1 而线程而B 操作dosome2 如果不发生指令重排
可能顺序可能是 1,2,3 b=4 ,这也是我们期望的,
还会出现以下顺序
1,3,2 3,1,2 这两种可能性,如果是这两个,代表不符合条件,没有声明b变量。
但是如果发生重排后,因为1,2没有依赖关系,很有可能发生指令重排,那名执行的结果就可能出现以下顺序
2,3,1 如果出现这个顺序,就会声明变量b,结果为2;这个结果就会很恐怖了,就好比我们做了一个工程,每次执行的结果无法确定。这必然是不行的。为了解决这个问题,我们便可以用volatile来修饰变量。当然sychornized也可以解决。
重排是个比较麻烦的过程,这是一个简单理解,后续再做详细的探讨。