并发，对象可见性

Question

我试图弄清楚下面的代码是否存在任何潜在的并发问题。具体来说，与易失性变量相关的可见性问题。 Volatile 定义为：这个变量的值永远不会被线程本地缓存：所有的读写都会直接进入“主存”

public static void main(String [] args)
{
    Test test = new Test();

    // This will always single threaded
    ExecutorService ex = Executors.newSingleThreadExecutor();

    for (int i=0; i<10; ++i)
        ex.execute(test);
}

private static class Test implements Runnable {
    // non volatile variable in question
    private int state = 0;

    @Override
    public void run() {
        // will we always see updated state value? Will updating state value
        // guarantee future run's see the value?
        if (this.state != -1)
            this.state++;
    }
}

对于上述单线程执行器：

可以使 test.state 非易失性吗？换句话说，每个连续的 Test.run() （这将顺序发生而不是同时发生，因为再次执行器是单线程的），总是看到更新的 test.state 值?如果不是，是否退出 Test.run() 确保本地线程所做的任何更改都被写回主内存？否则，如果不是在线程退出时，本地所做的更改何时会被写回主内存？

Answer 1

只要它只是一个线程，就没有必要让它变得易变。如果你要使用多个线程，你不仅应该使用 volatile，还应该使用 synchronize。 递增数字不是原子操作 - 这是一个常见的误解。

public void run() {
    synchronize (this) {
        if (this.state != -1)
            this.state++;
    }
}

除了使用同步之外，您还可以使用AtomicInteger#getAndIncrement()（如果之前不需要 if）。

private AtomicInteger state = new AtomicInteger();

public void run() {
    state.getAndIncrement()
}

Answer 2

原来我是这样想的：

如果任务总是由 相同的线程，不会有 问题。但是Excecutor出品 newSingleThreadExecutor() 可以创建 新线程来替换那些 因任何原因被杀。没有 保证何时更换 将创建线程或创建哪个线程 将创建它。

如果一个线程执行了一些写操作，那么 在新线程上调用start()，那些 写入将对新用户可见 线。但不能保证 该规则适用于这种情况。

但不可否认的是正确的：创建一个正确的ExecutorService 没有足够的障碍来确保可见性实际上是不可能的。我忘记了检测另一个线程的死亡是 synchronizes-with 关系。用于空闲工作线程的阻塞机制也需要屏障。

Answer 3

是的，它是安全的，即使执行器在中间替换了它的线程。线程开始/终止也是同步点。

http://java.sun.com/docs/books/jls/third_edition/html/memory.html#17.4.4

一个简单的例子：

static int state;
static public void main(String... args) {
    state = 0;                   // (1)
    Thread t = new Thread() {
        public void run() {
            state = state + 1;   // (2) 
        }
    };
    t.start();
    t.join();
    System.out.println(state);  // (3)
}

保证 (1)、(2)、(3) 有序且按预期运行。

对于单线程执行器，“任务保证顺序执行”，它必须在开始下一个任务之前以某种方式检测一个任务的完成，这必然会正确同步不同的run()的

Answer 4

您的代码，特别是这一位

            if (this.state != -1)
                    this.state++;

需要对状态值进行原子测试，然后在并发上下文中对状态进行增量。因此，即使您的变量是易变的并且涉及多个线程，您也会遇到并发问题。

但您的设计基于断言始终只有一个 Test 实例，并且，该单个实例仅授予单个（相同）线程。 （但请注意，单个实例实际上是主线程和执行线程之间的共享状态。）

我认为您需要使这些假设更加明确（例如，在代码中，使用 ThreadLocal 和 ThreadLocal.get()）。这是为了防止未来的错误（当一些其他开发人员可能不小心违反设计假设时），并且防止对the Executor method you are using 的内部实现做出假设，这可能在某些实现中仅提供单线程执行器（即顺序而不是每次调用 execute(runnable) 时必须使用相同的线程。

Answer 5

在这个特定的代码中，状态是非易失性的完全没问题，因为只有一个线程，并且只有那个线程访问该字段。在您拥有的唯一线程中禁用缓存该字段的值只会影响性能。

但是，如果您希望在运行循环的主线程中使用 state 的值，则必须使该字段为 volatile：

    for (int i=0; i<10; ++i) {
            ex.execute(test);
            System.out.println(test.getState());
    }

但是，即使这样也可能无法在 volatile 上正常工作，因为线程之间没有同步。

由于该字段是私有的，因此只有在主线程执行可以访问该字段的方法时才会出现问题。

Answer 6

如果您的 ExecutorService 是单线程的，那么就没有共享状态，所以我看不出有什么问题。

但是，将Test 类的新实例传递给对execute() 的每次调用不是更有意义吗？即

for (int i=0; i<10; ++i)
    ex.execute(new Test());

这样就不会有任何共享状态了。