併發性，對象可見性

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沒有足夠的障礙來確保可見性實際上是不可能的。我忘記了檢測另一個線程的死亡是與同步關係。用於空閒工作線程的阻塞機制也需要一個障礙。