Question

我正在编写一个生成大量随机数的程序。我曾经在开头设置一个固定的种子，以保持结果可复制。我现在面临的问题是，在一个天真的实现中，由于并发性，我失去了伪随机性。

我的问题是：是否有可能在没有线程间通信的情况下保留伪随机性，如果是，如何？

以下代码应说明我的问题。每次运行，程序返回不同的三倍总和。显然，访问顺序在大多数情况下也会有所不同。

public class PseudorandomConcurrency {

    private static Random rng;
    private static int numDraws = 2;
    private static int numThread = 3;
    private static int numRuns = 3;
    private static int order;

    public static class Generator implements Runnable{

        private static synchronized void incOrder(){
            order++;
        }

        private static synchronized int getOrder(){
            return order;
        }

        @Override
        public void run() {
            int sum = 0;
            ArrayList<Integer> order = new ArrayList<Integer>();
            for (int j = 0; j < numDraws; j++) {
                incOrder();
                order.add(getOrder());
                sum += rng.nextInt(10);
            }
            System.out.println(sum+" order: "+order.toString());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < numRuns; i++) {
            order=0;
            System.out.println("#####");
            rng = new Random(1);
            ArrayList<Thread> threads= new ArrayList<Thread>();
            for (int j = 0; j < numThread; j++) {
                threads.add(new Thread(new Generator()));
            }

            for (Thread thread : threads) {
                thread.start();
            }
            Thread.sleep(1000);
        }
    }
}

Answer 1

我的问题是：是否有可能在没有线程间通信的情况下保留伪随机性，如果是，如何？

是的。使每个线程使用单独的随机数生成器（具有不同但确定的种子）。

并发程序中的伪随机性

1 个答案: