共享

Question

我想分享這樣的多個線程之間的可變多個不同線程之間的變量：

boolean flag = true; 
T1 main = new T1(); 
T2 help = new T2(); 
main.start(); 
help.start(); 

我想主要和幫助線程在那裏，這是兩個不同的Java類我之間共享flag已創建。有沒有辦法做到這一點？謝謝！

Answer 1

T1和T2都可以引用包含此變量的類。然後，您可以使此變量易變，這意味着對這個變量的更改在兩個線程中都是直接可見的。

請參閱this article瞭解更多信息。

易變變量共享同步的可見性特徵，但不包括原子性特徵。這意味着線程 會自動查看volatile變量的最新值。 它們可用於提供線程安全性，但僅限於 受限情況：那些不在 多個變量之間或在變量的當前值與其未來值之間施加約束的情況。

並注意使用volatile與vs更復雜的手段共享狀態的優點/缺點。

Answer 2

1. 使其成爲靜態可以解決此問題。
2. 參考其他線程的主線程，使該變量可見

Answer 3

爲了使它的T1實例之間可見T2你可以讓這兩個類包含到包含變量的對象的引用。

如果要在線程運行時修改變量，則需要考慮同步。最佳方法取決於您的具體要求，但主要選項如下：

• 使變量volatile;
• 將它變成AtomicBoolean;
• 圍繞使用它的代碼使用全面的同步。

Answer 4

除了其他建議 - 你也可以包裝標誌在控制類，使它的一個最終比如在你的父類：

public class Test { 
    class Control { 
    public volatile boolean flag = false; 
    } 
    final Control control = new Control(); 

    class T1 implements Runnable { 
    @Override 
    public void run() { 
     while (!control.flag) { 

     } 
    } 
    } 

    class T2 implements Runnable { 
    @Override 
    public void run() { 
     while (!control.flag) { 

     } 
    } 
    } 

    private void test() { 
    T1 main = new T1(); 
    T2 help = new T2(); 

    new Thread(main).start(); 
    new Thread(help).start(); 
    } 

    public static void main(String[] args) throws InterruptedException { 
    try { 
     Test test = new Test(); 
     test.test(); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
    } 
} 

Answer 5

可以使用鎖變量「一」和「b」並將它們同步，以便按相反的順序鎖定「關鍵部分」。例如。通知「a」，然後鎖定「b」，「打印」，通知「b」，然後鎖定「a」。

請參考下面的代碼的： -

public class EvenOdd { 

static int a = 0; 

public static void main(String[] args) { 

    EvenOdd eo = new EvenOdd(); 

    A aobj = eo.new A(); 
    B bobj = eo.new B(); 

    aobj.a = Lock.lock1; 
    aobj.b = Lock.lock2; 

    bobj.a = Lock.lock2; 
    bobj.b = Lock.lock1; 

    Thread t1 = new Thread(aobj); 
    Thread t2 = new Thread(bobj); 

    t1.start(); 
    t2.start(); 

} 

static class Lock { 
    final static Object lock1 = new Object(); 
    final static Object lock2 = new Object(); 
} 

class A implements Runnable { 

    Object a; 
    Object b; 

    public void run() { 
     while (EvenOdd.a < 10) { 
      try { 
       System.out.println(++EvenOdd.a + " A "); 
       synchronized (a) { 
        a.notify(); 
       } 
       synchronized (b) { 
        b.wait(); 
       } 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 

     } 
    } 
} 

class B implements Runnable { 

    Object a; 
    Object b; 

    public void run() { 
     while (EvenOdd.a < 10) { 

      try { 
       synchronized (b) { 
        b.wait(); 
        System.out.println(++EvenOdd.a + " B "); 
       } 
       synchronized (a) { 
        a.notify(); 
       } 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 

     } 
    } 
} 

}

OUTPUT： - 1所述的 2 B 3甲 4 B 5所述的 第6 B 7所述的 8 B 9 A 10 B