有哪些方法可以保证变量的可见性？

参考回答

在多线程编程中，变量的可见性问题是指一个线程对变量的修改，能否及时被其他线程看到。以下几种方法可以保证变量的可见性：

1. volatile关键字：直接修饰变量，确保变量的更新对所有线程可见。
2. synchronized关键字：通过锁机制同步变量的读写，确保线程之间的可见性。
3. final关键字：对不可变对象，final修饰的字段在对象构造完成后对所有线程可见。
4. 显式的线程通信机制：比如 wait() 和 notify()。
5. java.util.concurrent 包中的工具类：如 Atomic 类、Lock 等。

详细讲解与拓展

为什么会有可见性问题？

可见性问题主要源于 Java 内存模型（Java Memory Model, JMM）。JMM规定：

1. 每个线程有自己的工作内存（线程缓存），它从主内存中读取和写入变量。
2. 如果一个线程对变量的修改仅保留在工作内存中，而没有刷新到主内存中，其他线程无法及时看到变化。

方法一：使用 volatile

volatile 是一种轻量级的同步机制，用于保证变量的可见性。它确保：

1. 每次读取 volatile 变量时，直接从主内存中读取。
2. 每次写入 volatile 变量时，立即刷新到主内存。

代码示例：

class VolatileExample {
    private volatile boolean running = true;

    public void stopRunning() {
        running = false; // 修改值
    }

    public void doWork() {
        while (running) {
            // 循环检测 running 的值
        }
        System.out.println("Stopped!");
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        VolatileExample example = new VolatileExample();
        Thread thread = new Thread(example::doWork);
        thread.start();

        Thread.sleep(1000);
        example.stopRunning(); // 通知停止工作
    }
}

注意事项：

• volatile 不能保证复合操作的原子性（如 i++）。
• 使用场景：适合状态标志的场景，如开关变量。

方法二：使用 synchronized

synchronized 保证了：

1. 同步块内的代码对其他线程是互斥的（保证原子性）。
2. 进入同步块时，会刷新线程工作内存，确保可见性。

代码示例：

class SharedData {
    private int value = 0;

    public synchronized void increment() {
        value++;
    }

    public synchronized int getValue() {
        return value;
    }
}

优点：

• 解决了可见性和原子性问题。
• 适用于更复杂的同步逻辑。

方法三：使用 final

当一个变量被 final 修饰时，且初始化在构造函数中完成，则该变量在对象被构造后对所有线程可见。

代码示例：

class FinalExample {
    private final int value;

    public FinalExample(int value) {
        this.value = value; // 在构造函数中完成赋值
    }

    public int getValue() {
        return value;
    }
}

关键点：

• final 保证了不可变性，从而解决了可见性问题。
• 适合用于常量和不可变对象的设计。

方法四：使用显式的线程通信机制

如前面提到的 wait() 和 notify()，它们可以通过共享锁对象协调线程间的通信，同时刷新线程工作内存。

示例见线程通信部分，不再赘述。

方法五：使用 java.util.concurrent 包中的工具类

1. Atomic 类：

• 保证变量的可见性和原子性。

• 常见类：AtomicInteger、AtomicBoolean。

• 代码示例：

  “`java
  import java.util.concurrent.atomic.AtomicInteger;

  public class AtomicExample {
  private AtomicInteger count = new AtomicInteger(0);

  <pre><code> public void increment() {
  count.incrementAndGet(); // 原子递增
  }

  public int getValue() {
  return count.get();
  }
  </code></pre>

  }

  “`

2. ReentrantLock：

• 提供显式的锁机制。
• 支持更灵活的同步控制。

代码示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class LockExample {
    private int value = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            value++;
        } finally {
            lock.unlock();
        }
    }

    public int getValue() {
        lock.lock();
        try {
            return value;
        } finally {
            lock.unlock();
        }
    }
}

拓展知识

对比几种可见性保证方式

指令重排序与可见性

• volatile 能防止指令重排序。
• 使用锁时，Java 内存模型规定会自动插入内存屏障，保证变量的可见性和顺序性。

综上所述，选择哪种方法取决于具体的应用场景，比如简单状态标志使用 volatile，复杂逻辑则用 synchronized 或并发工具类。

帅地永久会员

打赏 收藏 海报挣佣金 推广链接