总结

原子操作问题 : 线程中 , 对变量副本 count 进行自增操作 , 不是原子操作 , 首先 从工作内存中读取变量副本到执行引擎 ( 操作数栈 ) 中 , 然后 再 进行自增运算 , 最后 写回到线程工作内存中 , 这是 $3$ 个操作 , 如果变量 在这 $3$ 个操作的空档时间进行了修改 , 那么就会产生无法预知的效果 ;

总结一下 : 线程 A 的变量副本入操作数栈的时刻 , 该共享变量被线程 B 修改并且同步更新 , 此时入栈的这个变量自增是无效的 , 但是也算自增了 $1$ 次 , 因此这里就丢失了 $1$ 次计算机会 ;

一、原子性问题示例

开启 $20$ 个线程 , 对某个线程共享 int 类型变量进行自增 , 每个线程自增 $10000$ 次 , 那么按照正常执行 , $20$ 个线程执行完毕后的变量值应该是 $200000$ ;

代码示例 :

public class Main {
    private volatile static int count = 0;

    private static void increase() {
        count++;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i ++) {
            new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i ++) {
                        increase();
                        System.out.println(count);
                    }
                }
            }.start();
        }
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
 

执行结果 : 多运行几次 , 有的时候会出现结果不是 200000 的情况 , 这就是出现问题的情景 ;

二、线程操作原子性问题分析

上述程序中 , 将变量 int count 设置成 volatile 类型的 , 只能保证其 可见性 和 有序性 , 无法保证 线程操作的 原子性 ;

在线程中对 int count = 0 进行累加操作 , 首先将变量 int count = 0 加载到线程工作内存的变量副本中 , 这里创建了 $20$ 个线程 , 就会有 $20$ 个线程对应的工作内存空间 , 需要将 count 变量拷贝 $20$ 份到相应的线程工作内存中 ;

有这样一种极端情况 , 当某个线程 A , 将 变量副本 加载到 线程执行引擎 时 , 就是 线程栈 中的 栈帧 的的 操作数栈 中 , 此时将要开始执行相关操作 , 在线程执行引擎没有执行之前 ,

与此同时 , 线程 B 修改了 count 副本变量 , 并进行了同步 , 主内存 , 包括 线程 A 的副本变量也已经更新了最新的值 ,

当前 线程栈中的栈帧中的操作数栈 中 , 还压着一个副本变量 , 虽然 该变量已经过时 , 该 count++ 操作无效 , 这样就 丢失了 $1$ 次 count 变量自增的操作 , 导致 最终输出的值是 $19999$ ;

原子操作问题 : 线程中 , 对变量副本 count 进行自增操作 , 不是原子操作 , 首先 从工作内存中读取变量副本到执行引擎 ( 操作数栈 ) 中 , 然后 再 进行自增运算 , 最后 写回到线程工作内存中 , 这是 $3$ 个操作 , 如果变量 在这 $3$ 个操作的空档时间进行了修改 , 那么就会产生无法预知的效果 ;

总结一下 : 线程 A 的变量副本入操作数栈的时刻 , 该共享变量被线程 B 修改并且同步更新 , 此时入栈的这个变量自增是无效的 , 但是也算自增了 $1$ 次 , 因此这里就丢失了 $1$ 次计算机会 ;

三、使用 synchronized 解决线程原子性问题

使用 synchronized 修饰 increase 方法 ;

    private static void increase() {
        count++;
    }

  

 

  
1
  
2
  
3
 

方法 , 相当于在方法体重添加了 synchronized 代码块 ;

    private static void increase() {
        synchronized (Main.class) {
            count++;
        }
    }

  

 

  
1
  
2
  
3
  
4
  
5
 

一旦某个线程执行 synchronized 方法或代码块中的代码 , 则当前线程持有互斥锁 , 只能由当前线程访问 count 变量 ;

代码示例 :

public class Main {
    private volatile static int count = 0;

    private synchronized static void increase() {
        count++;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i ++) {
            new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i ++) {
                        increase();
                        System.out.println(count);
                    }
                }
            }.start();
        }
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
 

执行结果 :

文章来源: hanshuliang.blog.csdn.net，作者：韩曙亮，版权归原作者所有，如需转载，请联系作者。

原文链接：hanshuliang.blog.csdn.net/article/details/120178057