java：使用2個線程打印奇數偶數

Question

我想用2個不同的線程交替打印奇數和偶數。我能夠實現它使用等待，通知和同步塊，但現在我想評估，如果我們可以實現它，而無需使用等待，通知和同步。

以下是代碼我有，但它不工作：

public class OddEvenUsingAtomic { 

AtomicInteger nm = new AtomicInteger(0); 
AtomicBoolean chk = new AtomicBoolean(true); 

public static void main(String args[]) { 
    final OddEvenUsingAtomic pc = new OddEvenUsingAtomic(); 

    new Thread(new Runnable() { 

     @Override 
     public void run() { 
      while (true) { 

       try { 
        Thread.sleep(1000); 
       } catch (InterruptedException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
       } 

       if (pc.chk.compareAndSet(true, false)) { 

        System.out.println("Odd: " + pc.nm.incrementAndGet()); 
       } 
      } 

     } 

    }).start(); 

    new Thread(new Runnable() { 

     @Override 
     public void run() { 
      try { 
       Thread.sleep(1000); 
      } catch (InterruptedException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } 
      while (true) { 
       if (pc.chk.compareAndSet(false, true)) { 

        System.out.println("Even: " + pc.nm.incrementAndGet()); 
       } 
      } 

     } 

    }).start(); 
} 

}

任何想法？

我創建布魯諾建議後另一個版本，這似乎是更好的工作：

import java.util.concurrent.atomic.AtomicBoolean; 
import java.util.concurrent.atomic.AtomicInteger; 

public class OddEvenUsingAtomic { 

    AtomicInteger nm = new AtomicInteger(0); 
    AtomicBoolean chk = new AtomicBoolean(true); 

    public static void main(String args[]) { 
     final OddEvenUsingAtomic pc = new OddEvenUsingAtomic(); 

     new Thread(new Runnable() { 

      @Override 
      public void run() { 
       while (true) { 

        try { 
         Thread.sleep(1000); 
        } catch (InterruptedException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } 

        if (pc.chk.get() == Boolean.TRUE) { 

         System.out.println("Odd: " + pc.nm.incrementAndGet()); 
         pc.chk.compareAndSet(true, false); 
        } 
       } 

      } 

     }).start(); 

     new Thread(new Runnable() { 

      @Override 
      public void run() { 
       try { 
        Thread.sleep(1000); 
       } catch (InterruptedException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
       } 
       while (true) { 
        if (pc.chk.get() == Boolean.FALSE) { 

         System.out.println("Even: " + pc.nm.incrementAndGet()); 
         pc.chk.compareAndSet(false, true); 
        } 
       } 

      } 

     }).start(); 
    } 
} 

Answer 1

的代碼不正確同步，這就是問題所在。

下面的執行順序是允許在你的代碼：

1. 第一線看到chk == true，將其設置爲false並進入if塊。
2. 第二個線程看到chk == false，將其設置爲true並輸入if塊。

現在，你有兩個自己的if塊中2個線程，準備：

1. incrementAndGet()數
2. 打印。

因此，你完全無法控制將要發生的事情。

• 您可以讓任何線程調用incrementAndGet()，因此您可以讓線程「奇數」打印，首先是奇數，後來是偶數。
• 你可以讓第一個線程打印數字，循環，看到條件再次滿足（因爲第二個線程已經設置了chk到true再次打印，所有這些在第二個線程之前有機會打印）。

正如你所看到的，達到你想要的結果，你必須具備以下操作自動完成的：

• compareAndSet()布爾
• incrementAndGet()數
• 打印它

如果3個操作不是原子的，那麼你可以讓這些線程被安排在任何位置運行操作sible命令，你無法控制輸出。實現這一目標的最簡單方法是使用synchronized塊：

public static void main(final String... args) { 
    final Object o = new Object(); 
    // ... thread 1 ... 
    synchronized(o) { 
     if (boolean is in the expected state) { change boolean, get number, increment, print } 
    } 
    // ... thread 2 ... 
    synchronized(o) { 
     if (boolean is in the expected state) { change boolean, get number, increment, print } 
    } 
} 

Answer 2

這裏有兩個線程打印的賠率，並沒有等待找齊，通知或同步的（至少不是在代碼中可以看到）：

import java.util.concurrent.*; 

public class ThreadSignaling { 
    public static void main(String[] args) { 
     BlockingQueue<Integer> evens = new LinkedBlockingQueue<>(); 
     BlockingQueue<Integer> odds = new LinkedBlockingQueue<>(); 
     ExecutorService executorService = Executors.newFixedThreadPool(2); 
     executorService.submit(() -> takeAndOfferNext(evens, odds)); 
     executorService.submit(() -> takeAndOfferNext(odds, evens)); 
     evens.offer(0); 
    } 

    private static void takeAndOfferNext(BlockingQueue<Integer> takeFrom, 
             BlockingQueue<Integer> offerTo) { 
     while (true) { 
      try { 
       int i = takeFrom.take(); 
       System.out.println(i); 
       offerTo.offer(i + 1); 
      } catch (InterruptedException e) { 
       throw new IllegalStateException("Unexpected interrupt", e); 
      } 
     } 
    } 
} 

Answer 3

class MultiThreading { 

    Integer counter = 0; 
    Thread even; 
    Thread odd; 
    boolean flagEven = true; 
    boolean flagOdd; 

    class ThreadEven implements Runnable { 
     @Override 
     public void run() { 
      try { 
       while (counter < 100) { 
        if (flagEven) { 
         System.out.println(counter); 
         counter++; 
         flagEven = false; 
         flagOdd = true; 
        } 
       } 
      } catch (Exception e) { 
       e.printStackTrace(); 
      } 
     } 
    } 

    class ThreadOdd implements Runnable { 
     @Override 
     public void run() { 
      try { 
       synchronized (even) { 
        while (counter < 100) { 
         if (flagOdd) { 
          System.out.println(counter); 
          counter++; 
          flagOdd = false; 
          flagEven = true; 
         } 
        } 
       } 
      } catch (Exception e) { 
       e.printStackTrace(); 
      } 
     } 
    } 

    public void start() { 
     even = new Thread(new ThreadEven()); 
     odd = new Thread(new ThreadOdd()); 
     even.start(); 
     odd.start(); 
    } 

} 

}

呼叫的主要方法

new MultiThreading().start();