多线程陷阱：Java内存模型与可见性问题全解析

最新推荐文章于 2024-07-09 09:27:59 发布

逆流的小鱼168

最新推荐文章于 2024-07-09 09:27:59 发布

阅读量841

点赞数 24

分类专栏： Java 多线程后端文章标签： java 开发语言

本文链接：https://blog.csdn.net/feiying101/article/details/138474511

版权

Java 同时被 3 个专栏收录

101 篇文章

订阅专栏

后端

90 篇文章

订阅专栏

多线程

64 篇文章

订阅专栏

1. 介绍并发编程中的可见性问题

并发编程是现代软件开发中不可或缺的一部分，它让我们能够在多核处理器上高效运行程序。然而，并发带来了一系列挑战，其中最微妙而又难以捉摸的就是可见性问题。

1.1 定义并发中的可见性

在并发编程中，可见性指的是在一个线程中对共享变量的修改，能够及时地被其他线程观察到。可见性问题发生时，一个线程的更改可能对其他线程不可见，导致程序运行出现错误行为。

1.2 可见性问题表现

一个典型的表现是，即使一个线程已经将某个共享变量的值修改，其他线程仍然看到的是修改前的值。这种问题不容易重现和预测，因此调试起来非常困难。

1.3 可见性问题的影响

可见性问题会导致程序状态不一致，增加系统的复杂度，并可能引起数据丢失或者错误输出。在某些严重的情况下，还可能引起系统崩溃或安全漏洞。

2. CPU和内存模型基础

在深入了解可见性问题之前，理解CPU和内存间是如何交互的，对于把握并发编程至关重要。

2.1 单核CPU的工作方式

在单核CPU系统中，尽管线程可以交替执行，但在任何时刻真正执行指令的只有一个线程。所有的变量都存储在同一个内存中，任何线程的变化都能被接下来执行的线程看到。

class SingleCoreExample {
    private int sharedVar = 0;
    
    public void updateVar() {
        sharedVar = 1; // 更改可以直接被其他线程看到
    }
    
    public int getVar() {
        return sharedVar; // 总是得到最新的值
    }
}

2.2 多核CPU的工作机制

多核处理器拥有多个执行单元，可以同时执行多个线程。每个核可能有自己的缓存，这就导致了可见性问题：一个核上的线程更改了数据，而这个数据的更新并没有立即反映到另一个核的缓存中。

class MultiCoreExample {
    private volatile int sharedVar = 0;
    
    public void updateVar() {
        sharedVar = 1; // 更改可能不会立即对其他核上的线程可见
    }
    
    public int getVar() {
        return sharedVar; // 可能得到的是旧值
    }
}

2.3 内存模型简介

内存模型定义了不同线程如何交互和访问内存，以及变量如何被更新和共享。它是理解多线程编程中可见性（以及其他并发问题）的基础。

3. 内存模型与Java可见性问题

Java内存模型（Java Memory Model, JMM）是Java多线程编程的基石。它决定了一个线程对共享变量的写入何时对其他线程可见，以及如何同步线程间的共享变量。

3.1 Java内存模型(JMM)简述

JMM为开发者定义了一系列规则，用以解释线程如何以及何时可以看到其他线程修改过的变量值。它确立了happens-before这一原则，是理解内存操作顺序的关键。

public class MemoryModelBasics {
    // JMM 中的happens-before规则示例
}

3.2 JMM中的可见性

在JMM中，如果一个线程修改了某个变量的值，JMM会确保后续的读取操作能够获取到这个新值，前提是符合happens-before原则。

public class VisibilityInJMM {
    // JMM 可见性示例
    private int sharedVar = 0;

    public synchronized void updateVar() {
        sharedVar = 1; // 同步块确保更新操作对其他线程可见
    }

    public synchronized int getVar() {
        return sharedVar; // 同步块确保读取操作能获取最新的值
    }
}

3.3 happens-before原则

happens-before原则是JMM中的核心概念，它定义了一个既定的规则集，用于确定两个操作之间的先行发生关系，从而解决可见性问题。

public class HappensBeforeExample {
    // happens-before原则的代码实现示例
    private volatile int signal = 0;

    public void sendSignal() {
        signal = 1; // volatile变量写操作
    }

    public void waitForSignal() {
        while (signal != 1) {
            // 这里循环直到signal更新为1
        }
        // signal现在对这个线程是可见的
    }
}

4. 深入理解Java的可见性问题

理解Java的可见性问题对写出安全的并发代码至关重要。Java提供了几种机制来保证变量操作的可见性。

4.1 volatile关键字的作用

volatile关键字在Java中扮演着非常重要的角色。它能确保变量的更改对所有线程立即可见，并防止指令重排序。

class VolatileExample {
    private volatile int counter = 0;
    
    public void increment() {
        counter++;  // volatile保证counter更新对所有线程可见
    }
    
    public int getCounter() {
        return counter; // 直接读取最新值
    }
}

4.2 synchronized解决可见性示例

使用synchronized关键字可以保证在同一时刻，只有一个线程能访问同步的代码区域，同时确保进入或退出同步代码块的变量更新对其他线程是可见的。

class SynchronizedExample {
    private int sharedState = 0;

    public synchronized void updateSharedState() {
        sharedState = 1; // 保证写操作对其他线程可见
    }

    public synchronized int getSharedState() {
        return sharedState; // 保证读操作能得到最新的写操作
    }
}

4.3 final字段的内存语义

在Java中，使用final关键字声明的字段，一旦被初始化后，就不能被更改。JMM保证了任何线程能看到final字段在构造函数中的初始值。

class FinalFieldExample {
    private final int value;

    public FinalFieldExample(int value) {
        this.value = value; // 在构造函数中的写操作，其他线程可见
    }

    public int getValue() {
        return value; // 保证其他线程看到的是初始化时的值
    }
}

5. 代码示例与分析

通过一系列的示例，我们可以更好地理解Java中的可见性问题及解决策略。

5.1 不使用同步机制的可见性问题

以下代码展示了不使用同步机制可能导致的可见性问题。

class NoVisibility {
    private boolean ready = false;
    private int number;

    private class ReaderThread extends Thread {
        public void run() {
            while (!ready) {
                Thread.yield(); // 使当前线程重新竞争CPU执行时间
            }
            System.out.println(number);
        }
    }

    public void writeValues() {
        number = 42;
        ready = true;
    }

    public static void main(String[] args) {
        NoVisibility visibility = new NoVisibility();
        visibility.new ReaderThread().start();
        visibility.writeValues();
    }
}

在这个例子中，写入变量ready的值为true可能不会立即对读线程可见，导致程序挂起或输出错误。

5.2 使用volatile修饰的变量

将变量声明为volatile，则JMM将确保写入这个变量的操作对其他线程立即可见。

class VolatileVisibility {
    private volatile boolean ready = false;
    private volatile int number;

    private class ReaderThread extends Thread {
        public void run() {
            while (!ready) {
                Thread.yield();
            }
            System.out.println(number);
        }
    }

    public void writeValues() {
        number = 42;
        ready = true;
    }

    public static void main(String[] args) {
        VolatileVisibility visibility = new VolatileVisibility();
        visibility.new ReaderThread().start();
        visibility.writeValues();
    }
}

在这个例子中，使用volatile关键字可以保证number和ready更新对所有线程即时可见。

5.3 使用synchronized确保可见性

使用synchronized关键字同步对共享变量的访问，可以确保每次只有一个线程能执行同步代码，进而确保变量的更改对所有线程都是可见的。

class SynchronizedVisibility {
    private boolean ready = false;
    private int number;

    public synchronized void writeValues() {
        number = 42;
        ready = true;
    }

    public synchronized void waitForReady() {
        while (!ready) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重新设置中断状态
            }
        }
        System.out.println(number);
    }
}

在这个例子中，对ready和number变量的访问是同步的，能保证一个线程的改动被其他线程看到。

5.4 final字段可见性保证

当构造对象时，如果一个变量被声明为final，那么它一旦被赋值并且构造过程结束，其他线程就能看到final变量的值。

class FinalVisibility {
    private final int value;

    public FinalVisibility(int value) {
        this.value = value; // final变量在构造后，对其他线程可见
    }

    public int getValue() {
        return value;
    }
}

在这个例子中，任何线程访问value都能看到一个一致的值，因为它是一个final变量。

6. 实战案例：解决实际开发中的可见性问题

在实际的软件开发中，可见性问题往往隐藏在复杂的业务逻辑之中，诊断和解决这些问题需要开发者具备扎实的理论知识和实战经验。

6.1 实战场景描述

假设我们在开发一个高性能的数据处理系统，该系统由多个模块组成，一个模块负责数据的接收，另一个模块负责数据的处理。我们发现在高并发情况下，数据处理模块有时会遗漏某些数据。

6.2 问题诊断过程

初步调查：我们确认系统没有抛出异常，并且日志文件中也没有错误信息。
性能指标监控：我们查看了系统的性能监控指标，没有发现明显的瓶颈。
代码审查：我们对相关的数据共享逻辑进行了代码审查。
并发测试：我们构造特定的并发测试场景，模拟出了数据丢失的情况。

6.3 解决方案及代码实现

通过并发测试和代码审查，我们发现问题出在一个共享变量上，这个变量没有正确同步，导致在高并发下数据不一致。我们决定采取以下措施：

class DataProcessor {
    private volatile boolean dataReady = false;
    private List<String> buffer = new ArrayList<>();

    public void onDataReceived(String data) {
        synchronized (this) {
            buffer.add(data);
            dataReady = true;
        }
    }

    public void processData() {
        while (true) {
            if (dataReady) {
                synchronized (this) {
                    if (!buffer.isEmpty()) {
                        // 处理缓冲区中的数据
                        processData(buffer.remove(0));
                    }
                    if (buffer.isEmpty()) {
                        dataReady = false;
                    }
                }
            }
        }
    }
    
    // 其他代码省略
}