关于计算素数的cyclicBarrier

Question

我必须计算从1到10000的质数，我将范围划分为8线程(numbers of my CPU cores)，因此每个线程都必须检查1250编号。我不明白为什么在程序结束时，我会把它作为输出：

numbers found: 0

workerThread：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class WorkerThread extends Thread {

    private CyclicBarrier cyclicBarrier;
    private PrimeNumber primeNumber;
    private int min;
    private int max;

    public WorkerThread(CyclicBarrier cyclicBarrier, int min, int max,
            PrimeNumber primeNumber) {
        this.cyclicBarrier = cyclicBarrier;
        this.primeNumber = primeNumber;
        this.max = max;
        this.min = min;
    }

    @Override
    public void run() {

        primeNumber.calculatePrimeNumber(min,max);

        try {
            cyclicBarrier.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
        primeNumber.printNumbers();
    }
}

主修班：

import java.util.concurrent.CyclicBarrier;

public class PrimeNumber {

    private Integer totalPrimeNumber;

    private int min;
    private int max;
    private int limit;

    public PrimeNumber(int min, int max) {
        totalPrimeNumber = new Integer(0);
        this.min = min;
        this.max = max;
    }

    public void calculatePrimeNumber(int min, int max) {

        boolean found = false;
        for (int i = min; i <= max; i++) {
            for (int j = 3; j <= Math.sqrt(min); j++) {
                if (min % 2 == 0)
                    break;
                else if (min % j == 0) {
                    found = false;
                    break;
                }
                found = true;
            }
            if (found) {
                totalPrimeNumber++;
            }
        }
    }

    public void printNumbers() {
        synchronized (totalPrimeNumber) {
            System.out.println("numbers found" + totalPrimeNumber);
        }

    }

    public void setMin(int min) {
        this.min = min;
    }

    public void setMax(int max) {
        this.max = max;
    }

    public int getMin() {
        return min;
    }

    public int getMax() {
        return max;
    }

    private void setLimit(int max) {
        this.limit = max;
    }

    private int getLimit() {
        return limit;
    }

    public static void main(String args[]) {

        int cores = Runtime.getRuntime().availableProcessors();

        CyclicBarrier cyclicBarrier = new CyclicBarrier(cores);
        PrimeNumber primeNumber = new PrimeNumber(1, 10000);

        int numberToCheck = primeNumber.getMax() - primeNumber.getMin();
        int numberToDivide = numberToCheck / cores;

        primeNumber.setMin(1);
        primeNumber.setLimit(primeNumber.getMax());
        primeNumber.setMax(numberToDivide);

        for (int i = 0; i < cores; i++) {
            if (i == 7) {
                primeNumber.setMax(primeNumber.getLimit());
                WorkerThread workerThread = new WorkerThread(cyclicBarrier,
                        primeNumber.getMin(), primeNumber.getMax(), primeNumber);
                workerThread.start();
            } else {
                WorkerThread workerThread = new WorkerThread(cyclicBarrier,
                        primeNumber.getMin(), primeNumber.getMax(), primeNumber);
                workerThread.start();
                primeNumber.setMin(primeNumber.getMax() + 1);
                primeNumber.setMax(primeNumber.getMax() + numberToDivide);
            }
        }

    }

}

Answer 1

您只测试过min值

for (int j = 3; j <= Math.sqrt(min); j++) {
    if (min % 2 == 0) // min never changes
        break;
    else if (min % j == 0)

很可能您打算在每次使用i的情况下测试min。

在这里，使用调试器或编写单元测试可以为您解决这个问题。

我认为这样做的目的是看到大量CPU被使用。如果您想要速度，您可以优化这很多，虽然我怀疑埃拉托斯提尼筛在一个线程将更快。