java - 在哪些情况下 volatile 比锁定更好？

Question

在 The Java Language Specification, Java SE 9 Edition有一句话:

The Java programming language allows threads to access shared variables (§17.1). As a rule, to ensure that shared variables are consistently and reliably updated, a thread should ensure that it has exclusive use of such variables by obtaining a lock that, conventionally, enforces mutual exclusion for those shared variables.

The Java programming language provides a second mechanism, volatile fields, that is more convenient than locking for some purposes.

我试图找出使用 volatile 比锁定更方便的用途？

Answer 1

I'm trying to figure out for which purposes using volatile is more convenient than locking?

在简单情况下，这是一种更方便的¹解决方案，其中 volatile 是需要同步的唯一状态，并且操作本质上是原子的。

例如:

public class Processor extends Thread {
    private volatile stopped;

    public void run() {
        while (!stopped) {
            // do stuff
        }
    }

    public void stop() {
        stopped = true;
    }
}

public class Test {
    public static void main(String[] args) {
        Processor p = new Processor();
        p.start();
        Thread.sleep(1000);
        p.stop();
    }
}

如果您使用常规变量来停止，那么您在读取和写入时需要使用同步(或其他形式或锁定)...这更重要代码不太方便。

 public class Processor extends Thread {
    private stopped;

    public void run() {
        while (!isStopped()) {
            // do stuff
        }
    }

    public synchronized void stop() {
        stopped = true;
    }

    private synchronized boolean isStopped() {
        return stopped;
    }
}

但是，这只能作为简单情况下锁定的替代方案。如果 protected 状态需要的不仅仅是原子读取和原子写入，那么它将不起作用。例如:

public class Counter {
    private volatile int counter;

    public void increment() {
        counter = counter + 1;
    }

    private int get() {
        return counter;
    }
}

由于 increment() 的实现方式，上述内容不是线程安全的。为了正确(线程安全)行为，增量 = 增量 + 1 需要以原子方式完成。 volatile 不提供这种保证。内存读取和写入操作单独是原子的，但作为一个序列它们不是原子的。

据我所知，没有线程安全的方法来使用仅 volatile 变量来实现Counter。您需要锁或 AtomicInteger (通常依赖于 CAS 硬件支持...)

<小时/>

^{1 - 如果只计算代码行数会更方便。如果您还考虑到代码作者和维护者在推理解决方案正确性方面所花费的工作，我认为“便利”在很大程度上是一种幻觉。}

<小时/>

Volatile is better than locking in which cases?

这是一个更困难的问题，因为“更好”是一个负载词。但是，如果您的意思是“性能更高”，那么在有效的情况下， volatile 通常会更好:

• volatile 读取或写入只会导致内存屏障。
• 锁定操作通常使用 CAS 指令和一些处理争用的代码来实现。 CAS 引入了内存屏障。
• 原子类型通常也通过 CAS 实现。

这个分析有点粗略，但最根本的是，如果 volatile 能够强大地完成这项工作，那么它可能比其他替代方案更有效。但有两个注意事项:

• 大多数涉及线程间通信或同步的操作对于 volatile 来说都过于复杂
• 一般情况下，volatile的性能优势太小，不显着。如果存在争用或同步瓶颈，情况就会发生变化。