在Java中通过多个线程生成唯一的素数

Question

In this code below multiple producer threads sometimes generate the same prime numbers. How I can ensure that different producers always generate a unique prime number?

public class UniquePrimes {


    private static BlockingQueue<Integer> linkedBlockingQueue = new LinkedBlockingQueue<Integer>(); 
    static ConcurrentHashMap<Integer, String> primesproduced = new ConcurrentHashMap<Integer, String>();

    public static void main(String[] args) {

        Scanner reader = new Scanner(System.in);
        System.out.print("Enter number of threads you want to create: ");
        int NOOFTHREADS = reader.nextInt();
        reader.close();

        ExecutorService executorPool = Executors.newFixedThreadPool(NOOFTHREADS);

        AtomicInteger currentPrime = new AtomicInteger();
        Runnable producer = () -> {
            String threadName = Thread.currentThread().getName();

            int p = 0;
            try {

                p = generateNextPrime(currentPrime.incrementAndGet());
                linkedBlockingQueue.put(p);
                primesproduced.put(p, threadName);
                System.out.println("Thread " + threadName + " produced prime number " + p);

            } catch (InterruptedException e) {

                e.printStackTrace();
            }
        };



        List<Runnable> tasks = new ArrayList<Runnable>();

        for (int i = 0; i < NOOFTHREADS; i++) {
            tasks.add(producer);

        }

        CompletableFuture<?>[] futures = tasks.stream().map(task -> CompletableFuture.runAsync(task, executorPool))
                .toArray(CompletableFuture[]::new);

        CompletableFuture.allOf(futures).join();
        executorPool.shutdown();

        System.out.println("\nTotal unique primes produced: " + primesproduced.size() + " and they are: ");


        System.out.print(
        primesproduced.entrySet().stream().filter(map -> map.getKey().intValue()>0).map(k -> "[" + k + "]").collect(Collectors.joining(",")));

        }
    }

    private static int generateNextPrime(int currentPrime) {    

        currentPrime++;
        if (currentPrime < 2) {
            currentPrime = 2;

            return currentPrime;

        }
        for (int i = 2; i < currentPrime; i++) {
            if (currentPrime % i == 0) {
                currentPrime++;
                i = 2;
            } else {
                continue;
            }
        }       
        return currentPrime;
    }
}

Currently multiple producers can generate the same prime value. How can I ensure that each producer generates a new prime value not generated previously by other producers?

Thanks for any help.

Answer 1

You need a different strategy. Your current strategy is for threads to start searching for a prime at currentPrime + 1 . Since each thread is doing the same thing, which means that they will be searching overlapping regions to primes. This is inefficient (duplicated work), and leads to two or threads occasionally discovering the same prime.

A better strategy is to make sure that each thread searches a different range. For example

value = atomicInt.addAndGet(1000);

adds 1000 to atomicInt and sets value to the value of atomicInt immediately prior to the successful add. So you could view value as the start of a range of 1000 integers that are assigned to the current thread for searching.

Another hint: look at the Sieve of Eratosthenes if you want better performance.

I am guessing that you are doing this as a homework or learning exercise, so I won't code it for you.