并发——同步访问共享的可变数据

深碍√TFBOYSˉ_ 2024-03-16 16:18 56阅读 0赞

关键字 synchronized 可以保证在同一时刻，只有一个线程可以执行某一个方法，或者某一段代码块。许多程序员把同步的概念仅仅理解为一种互斥的方式。即，当一个对象被一个线程修改的时候，可以阻止另一个线程观察到内部不一致的状态。

这种观点是正确的，但是它并没有说明同步的全部意义。如果没有同步，一个线程的变化就不能被其他线程看到。同步不仅可以阻止一个线程看到对象处于不一致的状态之中，它还可以保证进入同步方法或代码块的每个线程，都看到由一个同步锁保护的之前所有的修改效果。

你可能听说过，为了提高性能，在读或者写原子数据的时候，应该避免使用同步。这个建议是非常危险而错误的。虽然语言规范保证了线程在读取原子数据的时候，不会看到任意的数值，但是它并不保证一个线程写入的值对于另一个线程将是可见的。为了在线程间进行可靠的通信，也为了互斥访问，同步是必要的。这归因于 java 语言规范中的内存模型，它规定了一个线程所做的变化何时以及如何变成对其他线程可见。

如果对共享的可变数据的访问不能同步，其后果将非常可怕，即使这个变量是原子可读写的。

测试以下代码

public class StopThread {
        private static boolean  stop;
    
        public static void main(String[] args) throws InterruptedException {
            System.out.println(LocalDateTime.now());
            Thread t = new Thread(()->{
                int i = 0;
                while(!stop){
                    i++;
                }
                System.out.println(LocalDateTime.now());
            });
            t.start();
            Thread.sleep(1000);
            stop = true;
        }
    }

看上去这段代码的意思就是1s 之后停止，但实际上，它根本不会停止；后台线程永远在循环

问题在于，没有同步，就不能保证后台线程什么时候会发现主线程修改了 stop 的值

想要修复的这个问题，可以加上同步操作

public class StopThread {
        private static boolean  stop;
    
        private static synchronized  void setStop(){
            stop = true;
        }
        private static synchronized boolean getStop(){
            return stop;
        }
    
        public static void main(String[] args) throws InterruptedException {
            System.out.println(LocalDateTime.now());
            Thread t = new Thread(()->{
                int i = 0;
                while(!getStop()){
                    i++;
                }
                System.out.println(LocalDateTime.now());
            });
            t.start();
            Thread.sleep(1000);
            setStop();
    
        }
    }

注意，在上面的修改中，写和读方法都添加了同步关键字。如果只有一个则可能无效，读和写是两个动作，都需要被同步，才能真正完成同步。

synchronized 关键字由java 自动帮我们处理为锁，实际上，针对上面的要求，我们可以用一个更简单高效的关键字来处理：volatile

也就是在stop 前加上 volatile 修饰，就可以了，不需要再用 同步处理读和写。volatile 不提供锁和互斥操作，它只保证内存可见性，这里我们需要的也就是内存可见性——任何线程所修改之后，立刻被其他线程所见。

所以，要正确区分 synchronized 和 volatile 。synchronized 提供互斥操作，也就是任意时刻，所修饰的代码块或方法只能有一个线程在执行。而volatile 只能保证可见，没有互斥性。

以下代码可以做个试验

private static volatile int count = 0;
    public static void main(String[] args) throws InterruptedException {
        for(int x =0;x<10;x++){
            new Thread(() ->{
                for(int i =0;i<1000;i++){
                    count ++;
                }
            }).start();
        }
        Thread.sleep(2000); // 保证多线程已经结束
        System.out.println(count);
    }

多次执行之后，你会发现，count 不一定是 10000，大概率是9000多。

因为 voletile 只可见，不提供互斥，而 count++ 实际上是3个动作，先读取count 值，然后+1 ，最后写回到count 值

所以，可能发生 2个（或多个）线程同时读取到 count 比如 6，然后同时在内存中计算出 7，最后都写回7.这样6经过2次自增，结果却是7 。多次循环下来，最后结果就是不到10000

这样的需求，就只能使用同步，或者锁， 或者 原子类。

综上，如果需要多线程，一定要注意互斥性。如果只需要可见，则需要 volatile 可见性。如果无法确认，多数时候，还是用互斥比较稳妥，至少保证程序不出错。

多线程编程中一定要注意，并且，这种bug 非常难以处理。在debug 环境下，往往无法复现真正的多线程中的大量并发，也就很难复现这样的错误。