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();
}

}

有任何想法吗？

根据Bruno的建议，我创建了另一个版本，该版本似乎效果更好：

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()，因此可以先打印线程“ Odd”，首先打印奇数，然后再打印偶数。
• 您可以让第一个线程循环打印数字，看看条件是否再次满足（因为第二个线程已再次设置chk为true打印，所有这些都在第二个线程有机会打印之前）。

如您所见，要获得所需的结果，必须原子完成以下操作：

• compareAndSet() 布尔值
• incrementAndGet() 数字
• 打印它

如果这3个操作不是原子操作，则可以安排线程以任何可能的顺序运行这些操作，而您无法控制输出。实现此目的的最简单方法是使用同步块：

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 }
    }
}