如何使用volatile变量编写简单的线程安全类？

Question

我想写一个简单的线程安全类，可以用来设置或获取整数值。

最简单的方法是使用synchronized关键字：

public class MyIntegerHolder {

    private Integer value;

    synchronized public Integer getValue() {
        return value;
    }

    synchronized public void setValue(Integer value) {
        this.value = value;
    }

}

我也可以尝试使用挥发性：

public class MyIntegerHolder {

    private volatile Integer value;

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

}

带有易失性关键字线程安全的类吗？

考虑下面的事件顺序：

1. 线程A将该值设置为5

根据Java语言规范

• “1”发生在“3”之前

但我不明白“1”怎么会出现在“2”之前，所以我怀疑“1”不会出现在“2”之前。

我怀疑线程C的读数可能是7或5。我认为带有volatile关键字的类不是线程安全的，以下顺序也是可能的：

1. 线程A将该值设置为5

我假设MyIntegerHolder with volatile不是线程安全的，对吗？

是否可以使用AtomicInteger创建线程安全的整数保持器：

public class MyIntegerHolder {

    private AtomicInteger atomicInteger = new AtomicInteger();

    public Integer getValue() {
        return atomicInteger.get();
    }

    public void setValue(Integer value) {
        atomicInteger.set(value);
    }

}

？

以下是《Java并发性练习手册》的一部分：

“原子变量的读写与易失性变量具有相同的内存语义。”

编写线程安全MyIntegerHolder的最佳（最好是非阻塞）方式是什么？

如果你知道答案，我想知道你为什么认为它是正确的。它符合规格吗？如果是，怎么做？

Answer 1

Java语言规范的第17章定义了内存操作（如读取和写入共享变量）的“发生在”关系。只有在写操作发生在读操作之前，一个线程的写操作的结果才能保证对另一个线程的读操作可见。

1. 同步的和易失性的构造，以及Thread.start（）和Thread.join（）方法，可以形成发生前关系。特别是：线程中的每个操作都发生在该线程中按程序顺序稍后出现的每个操作之前。
2. 监视器的解锁（同步块或方法退出）发生在同一监视器的每个后续锁（同步块或方法条目）之前。而且因为在发生之前发生的关系是可传递的，所以线程在解锁之前的所有动作都发生在监控的任何线程锁定之后的所有动作之前。
3. 对易失性字段的写入发生在同一字段的每次后续读取之前。易失性字段的写入和读取与进入和退出监视器具有类似的内存一致性效果，但不需要互斥锁定。
4. 在启动线程中的任何操作之前，会发生对线程启动的调用。
5. 线程中的所有操作都发生在任何其他线程从该线程的连接成功返回之前。

参考：http://developer.android.com/reference/java/util/concurrent/package-summary.html

根据我的理解，3的意思是：如果你写（不是基于读取结果）/读取就可以了。如果写入（基于读取结果，例如增量）/读取不正常。因为volatile“不需要互斥锁定”

Answer 2

如果只需要对变量进行get/set，就可以像之前那样声明它为volatile。如果您检查AtomicInteger设置/获取的工作方式，您将看到相同的实现

private volatile int value;
...

public final int get() {
    return value;
}

public final void set(int newValue) {
    value = newValue;
}

但是你不能像这样简单地增加一个不稳定的场。这就是我们使用原子nteger.increment和获取或getAnd增量方法的地方。

Answer 3

关键字synchronized表示如果线程A和线程B想要访问整数，它们不能同时访问。A告诉B等我做完。

另一方面，volatile使线程更“友好”。他们开始互相交谈，一起工作来完成任务。因此，当B试图访问时，A将通知B在那一刻之前所做的一切。B现在意识到了这些变化，可以从A离开的地方继续工作。

在Java中，由于这个原因，您有原子，它在封面下使用易失性关键字，所以它们几乎在做同样的事情，但是它们节省了您的时间和精力。

你要找的是AtomicInteger，你说得对。对于您尝试执行的操作，这是最佳选择。

There are two main uses of `AtomicInteger`:

 * As an atomic counter (incrementAndGet(), etc) that can be used by many threads concurrently

 * As a primitive that supports compare-and-swap instruction (compareAndSet()) to implement non-blocking algorithms. 

概括地回答你的问题

这取决于你需要什么。我不是说同步是错误的，易失性是好的，否则好Java的人早就删除了同步。没有绝对的答案，有很多具体的案例和使用场景。

我的一些书签：

并发提示

核心Java并发

Java并发

使现代化

Java并发规范如下：

包java。util。同时发生的原子的

一个支持单变量无锁线程安全编程的小类工具包。

Instances of classes `AtomicBoolean`, `AtomicInteger`, `AtomicLong`, and `AtomicReference` each provide access and updates to a single variable of the corresponding type.
Each class also provides appropriate utility methods for that type.
For example, classes `AtomicLong` and AtomicInteger provide atomic increment methods.

The memory effects for accesses and updates of atomics generally follow the rules for volatiles:

get has the memory effects of reading a volatile variable.
set has the memory effects of writing (assigning) a volatile variable.

也从这里开始

Java编程语言volatile关键字：

（在Java的所有版本中）对易失性变量的读取和写入有全局顺序。这意味着每个访问易失性字段的线程将在继续之前读取其当前值，而不是（潜在地）使用缓存值。（但是，不能保证易失性读写与常规读写的相对顺序，这意味着它通常不是一个有用的线程构造。）