并发性，对象可见性

Question

我想弄清楚下面的代码是否存在任何潜在的并发问题。具体而言，可见性问题与易变变量有关。 挥发性定义为：这个变量的值将不会被缓存线程本地：所有读取和写入将直接进入“主内存”

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（）（这将会按顺序发生而不是同时执行，因为executor是单线程的），总会看到更新的test.state值？如果没有，不退出Test.run（）确保所做的任何更改使得线程在本地被写回主内存？否则，当线程在本地进行更改时，如果线程退出时还没有写回主内存？

Answer 1

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

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 2

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

但是，将Test类的新实例传递给​​的每个调用是否更有意义？即

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

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

Answer 3

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

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

而不是使用同步的，你也可以使用AtomicInteger#getAndIncrement()（如果之前如果你不需要的）。

private AtomicInteger state = new AtomicInteger(); 

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

Answer 4

您的代码，具体地该位

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

将需要状态值的原子测试，然后增量到状态在并发上下文。所以即使你的变量是不稳定的并且涉及多个线程，你也会遇到并发问题。

但是，您的设计基于声明总是只有一个测试实例，和，该单个实例仅授予单个（相同）线程。 （但请注意，单实例实际上是主线程和执行程序线程之间的共享状态。）

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

Answer 5

状态在此特定代码中是非易失性的，因为只有一个线程，并且只有该线程才能访问该字段，这是完全正确的。禁用在你唯一的线程中缓存这个字段的值只会给性能带来影响。

不过，如果你想使用的状态的值，在其运行循环的主线程，你必须让外地挥发性：

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

然而，即使这样可能无法正常使用挥发性工作，因为线程之间没有同步。

由于该字段是私有的，因此如果主线程执行一个可以访问该字段的方法，则只有一个问题。

Answer 6

原来我是这样想的：

如果任务总是由 同一个线程中执行，就不会有 问题。但Excecutor产生的 newSingleThreadExecutor()可能会创建 新线程来替换那些因为任何原因而被杀死的线程。关于什么时候替换 线程将被创建或哪个线程 将创建它，没有 保证。

如果一个线程执行某些写入，然后 上一个新的线程调用start()，这些 写将是可见的新 线程。但是不能保证该规则适用于这种情况。

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