我的多线程“嘶嘶声”实现线程安全吗？

Question

出于教育目的，我正在使用多线程实现经典的“嘶嘶声”问题。

“嘶嘶声”游戏是：

指定先走的玩家说出数字“1”，然后每个玩家依次数一个数字。然而，任何能被三整除的数字都被单词 fizz 代替，任何能被五整除的数字都被单词 Buzz 代替。能被两者整除的数字会变成嗡嗡声

在我的实现中，我有 4 个线程：

• 如果数字不是 3 或 5 的倍数，则第一个线程打印数字并递增当前计数器。
• 第二个线程打印“嘶嘶”...
• 第三个线程打印“嗡嗡声”...
• 第四线程打印“嘶嘶声”...

我不使用任何锁定和线程同步机制。 我的多线程“嘶嘶声”实现线程安全吗？如果不是，为什么？ 我在“可疑”地方的实现代码中添加了 cmets。

我的实现：

package threads;    
import java.util.function.IntFunction;    
public class FizzBuzzGameRunner {

    // not volatile
    // if other thread updates currentNum and current thread will see old (cached) value
    // nothing bad can happen, just burn some CPU cycles uselessly
    private int currentNum = 1;

    public static void main(String... args) throws InterruptedException {
        FizzBuzzGameRunner fizzBuzzGame = new FizzBuzzGameRunner();
        startAll(
                fizzBuzzGame.createRunnable(n -> (n % 3 != 0 && n % 5 != 0) ? String.valueOf(n) : null),
                fizzBuzzGame.createRunnable(n -> (n % 3 == 0 && n % 5 != 0) ? "fizz" : null),
                fizzBuzzGame.createRunnable(n -> (n % 3 != 0 && n % 5 == 0) ? "buzz" : null),
                fizzBuzzGame.createRunnable(n -> (n % 3 == 0 && n % 5 == 0) ? "fizz buzz" : null)
        );
        Thread.sleep(1000);
    }

    private static void startAll(Runnable... workers) {
        for (Runnable w : workers) {
            Thread t = new Thread(w);
            t.setDaemon(true);
            t.start();
        }
    }

    private Runnable createRunnable(IntFunction<String> singleStep) {
        return () -> {
            while (true) {
                int currNum = this.currentNum;
                // no synchronization
                String result = singleStep.apply(currNum);
                if (result != null) {
                    //Even without synchronization this block will be
                    //executed maximum by single thread simultaneously.
                    //Because each thread increments this.currentNum as part of that action,
                    //but no other thread will increment for the same value.
                    System.out.println(result);
                    this.currentNum++;
                }
            }
        };
    }
}

我知道我的例子完全是人为的。实现多线程“Fizz Buzz”算法启发了一本名著，为“编码面试”做准备。我只是想证明书中的例子（需要有 4 个线程）可以在不使用同步和锁的情况下解决。

Answer 1

好的，我更改了它，而不是打印输出，而是将其发布到队列中。我让队列检查该值是否满足条件。它总是中断，因为队列正在填满。或者，您可以将输出写入文件并运行数千次以查看它是否全部损坏。 它对我来说永远不会坏。虽然不能证明它是无种族的，但反过来会显示出种族。

import java.util.function.IntFunction;
import java.util.concurrent.ArrayBlockingQueue;


public class FizzBuzzGameRunner {
    static ArrayBlockingQueue<String> output = new ArrayBlockingQueue<>(100);
    private int currentNum = 1;

    public static void main(String... args) throws InterruptedException {

        FizzBuzzGameRunner fizzBuzzGame = new FizzBuzzGameRunner();
        startAll(
                fizzBuzzGame.createRunnable(
                        n -> {
                            if (n % 3 != 0 && n % 5 != 0) {
                                return String.valueOf(n);
                            }
                            return null;
                        }),
                fizzBuzzGame.createRunnable(
                        n -> {
                            if (n % 3 == 0 && n % 5 != 0) {
                                return "fizz";
                            }
                            return null;
                        }),
                fizzBuzzGame.createRunnable(
                        n -> {
                            if (n % 3 != 0 && n % 5 == 0) {
                                return "buzz";
                            }
                            return null;
                        }),
                fizzBuzzGame.createRunnable(
                        n -> {
                            if (n % 3 == 0 && n % 5 == 0) {
                                return "fizz buzz";
                            }
                            return null;
                        })
        );

        int n = 1;
        String s;
        while(true){
            s = output.take();
            if (n % 3 != 0 && n % 5 != 0) {
                if(!String.valueOf(n).equals(s)){
                    break;
                }
            }
            if (n % 3 == 0 && n % 5 != 0) {
                if(!"fizz".equals(s)) break;
            }
            if (n % 3 != 0 && n % 5 == 0) {
                if(!"buzz".equals(s)) break;
            }
            if (n % 3 == 0 && n % 5 == 0) {
                if(!"fizz buzz".equals(s)) break;
            }
            n++;
        }

        System.out.println(s + " out of order after" + n);
    }

    private static void startAll(Runnable... workers) {
        for (Runnable w : workers) {
            Thread t = new Thread(w);
            t.setDaemon(true);
            t.start();
        }
    }

    private Runnable createRunnable(IntFunction<String> singleStep) {
        return () -> {
            while (true) {
                int currNum = this.currentNum;
                // no synchronization
                // even if other thread updates currentNum nothing bad can happen
                String result = singleStep.apply(currNum);
                if (result != null) {
                    //even without synchronization this block will be 
                    //executed maximum by single thread simultaneously
                    try{
                        output.put(result);
                    } catch(InterruptedException e){
                        break;
                    }
                    this.currentNum++;
                }
            }
        };
    }



}

Answer 2

它不是无种族的（这是我认为你真正要问的），因为当另一个线程写入时，线程从 currentNum 读取，没有任何同步。不保证每个线程都能看到最新的值 - 每个线程都会看到它自己上次写入的值，或者任何其他线程此后写入的任何值。

这可能意味着您最终在任何线程中都没有前向进展，因为每个线程可能根本看不到其他线程所做的更改。你可以使用AtomicInteger 来解决这个问题。

我也不确定this.currentNum++; 的效果是否可以保证以与源线程中相同的方式被其他线程看到。我怀疑理论上，输出和增量可以重新排序，例如：

              this.currentNum++;
              System.out.println(result);

这可能导致输出不一致。