使用ThreadPool查找素数n…n

Question

So as the title suggests I am trying to find all the primes from 0 to MAX_LIMIT

sample input: javac Main.java 8 100

this means create 8 threads and find primes from 0 to 100, including 100. my program takes two command line arguments: the first is the number of threads, the second is the range of primes (0 to n).

sample output:

Prime Number: 2 Thread #: 13

Prime Number: 7 Thread #: 15

Prime Number: 7 Thread #: 16

Prime Number: 11 Thread #: 18

:

Then the system will hang and ill have to stop the process:

Process finished with exit code 137

My question is:

Why does my thread pool go over its limit (thread numbers like 13 or 16, instead of 1-8) and how can I make the threads not all calculate the same number at the same time? I'm thinking of using a cache of some sort like adding numbers to an array list or something but I do not know if that would be the correct approach to use.

It is possible that I am misunderstanding what a ThreadPool is and am in fact using something completely unrelated to it.

I am also unsure of why it is hanging and not printing all the primes from 0 to 100 in this case.

If there is an easier way to do what I am trying to do I would be interested in hearing it.

I'll be here working on this and will check back on this thread frequently.

Yes this is homework for an operating systems class about threads, I wouldn't normally ask for help but I am at a loss. All Code is located in one file.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

private static int MAX_THREADS;
private static int MAX_LIMIT;
private static int numToTest = 0;

public static void main(String[] args) {

int max_threads = Integer.parseInt(args[0]);
int max_limit = Integer.parseInt(args[1]);

MAX_THREADS = max_threads;
MAX_LIMIT = max_limit;

Foo();
}



private static void Foo() {

    class PrimeNumberGen implements Runnable {

        int num = numToTest;

        PrimeNumberGen(int n) {num = n;}

        boolean isPrime(int n) { //first test is 0
            if(n<2) return false;
            if(n==2) return true;
            if(n%2==0) return false;

            int max = n/2;
            for(int i=3; i< max; i=i+2) {
                if (n % i == 0)
                    return false;
            }
                    return true;
        }




        public void  run() {
            numToTest++;
            if(isPrime(num)) {

                System.out.println("Prime Number: "+num+" Thread #:
          "+Thread.currentThread().getId());

            }
            else {
                numToTest++;
            }

        }
    }
    //Thread t = new Thread(new PrimeNumberGen(num));
    //t.start();
    ExecutorService executor = Executors.newFixedThreadPool(MAX_THREADS);
    for (int i = 0;i <= MAX_LIMIT; i++) {
        Runnable worker = new PrimeNumberGen(numToTest);
        executor.execute(worker);
    }


 }
}

Answer 1

Regarding the second part of your question, take a look at the Sieve of Eratosthenes.

Change

Runnable worker = new PrimeNumberGen(numToTest); to

Runnable worker = new PrimeNumberGen(i);

You can actually throw away this numToTest variable it's not needed anymore.

Answer 2

Your Thread id is a unique number of a thread. This can start at any number and doesn't have to be sequential. Over the life of a thread pool you can have more than the maximum number of threads, but no more than the maximum at any time.

BTW If you have to find multiple primes, using a Sieve of Eratosthenes will be much faster as it is a lower time complexity. It is usually single threaded, but it will still be faster.

Answer 3

The problem for the duplicate prime numbers is that the threads do not see the updates of the other thread all the time, eg

Prime Number: 7 Thread #: 15

Prime Number: 7 Thread #: 16 (Thread 16 does not see the values from thread 15 perhaps they are running on different cores)

is because numToTest++; is not thread safe since numToTest is not volatile and the operation ++ is not atomic. I wrote a blog entry under http://blog.vmlens.com/2013/08/18/java-race-conditions-or-how-to-find-an-irreproducable-bug/ to explain this type of bug.

One solution would be to use AtomicInteger, see http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/atomic/AtomicInteger.html .

Your program seams to hang since you did not stop the thread pool. See How to stop the execution of Executor ThreadPool in java? how to do this.

Answer 4

Regarding the thread pool going over its limit,

Change

System.out.println("Prime Number: "+num+" Thread #:
      "+Thread.currentThread().getId());

to

System.out.println("Prime Number: "+num+" Thread #:
      "+Thread.currentThread().getName());

The thread ID is a positive long number generated when this thread was created, not the actual thread number; calling getName() will outputs something like

pool-1-thread-3

Ref : https://www.tutorialspoint.com/java/lang/thread_getid.htm