4 线程查找素数

Question

I try to use 4-evenly-balanced threads to find prime number from 10 to 30. I want to know how many prime number for each thread, how many for total, and print out the prime number. I ran the program for several times, the output is different for each time. Could someone help me figure out the problem.

public class Prime extends Thread    
{
   int thread;
   static long max=30;
   static long min=10;
   static long[] primes = new long[100];
   static int a=0;
   static int b=0;
   static int c=0;
   static int d=0;

   public Prime(int threadID)
   {
      thread = threadID;
   }
   public void run()
   {
      for(long i = min; i<=max; i++){
         if(isPrime(i)){
            if(thread ==1){
               if(i<=15){
                  primes[a++] = i;
               }          
            }
            if(thread ==2){
               if(i>15 && i <=20){
                  primes[b++] = i;
               }
            }
            if(thread ==3){
               if(i>20 && i<=25){
                  {
                     primes[c++] = i;
                  }
               }
            }
            if(thread ==4){
               if(i>25){
                  primes[d++] = i;
               }
            }
         }
      } 
      if(thread ==1){System.out.println("Thread 1 contains "+a+" prime numbers");}
      if(thread ==2){System.out.println("Thread 2 contains "+b+" prime numbers");}
      if(thread ==3){System.out.println("Thread 3 contains "+c+" prime numbers");}
      if(thread ==4){System.out.println("Thread 4 contains "+d+" prime numbers");}
   }

   public static boolean isPrime(long n) {
      for (int i = 2; i < Math.sqrt(n); i++) {         
         if (n % i == 0) {
            return false;
         }
      }
      return true;
   }

   public static void main(String[] arg)
   {
      Thread th1 = new Prime(1);
      Thread th2 = new Prime(2);
      Thread th3 = new Prime(3);
      Thread th4 = new Prime(4);

      th1.start();
      th2.start();
      th3.start();
      th4.start();

      try{th1.join();}
      catch(InterruptedException ie){}
      try{th2.join();}
      catch(InterruptedException ie){}
      try{th3.join();}
      catch(InterruptedException ie){}
      try{th4.join();}
      catch(InterruptedException ie){}

      int total = a+b+c+d;
      System.out.println("Total number of prime: "+total);
      for (int i=0;i<10; i++){
         System.out.println(""+i+": "+Prime.primes[i]);
      }
   }
}

Answer 1

As @Louis mentioned in a comment to your question, all of your threads are overwriting each other.

When Thread1 puts it's work in primes[0], the other threads aren't informed and then also put their work in primes[0] (which overwrites the work already there). You get different outputs mostly because the order that the threads run is "random."

A simple solution would be to not have an index for each thread (a,b,c,d) but to use an AtomicInteger from java.util.concurrent.atomic.AtomicInteger .

Short example of how to use the AtomicInteger

import java.util.concurrent.atomic.AtomicInteger;

public class Prime extends Thread    
{
   int thread;
   static long max=30;
   static long min=10;
   static long[] primes = new long[100];
   static AtomicInteger index = new AtomicInteger(0);

   public Prime(int threadID)
   {
      thread = threadID;
   }
   public void run()
   {
      for(long i = min; i<=max; i++){
         if(isPrime(i)){
            if(thread ==1){
               if(i<=15){
                  primes[index.getAndAdd(1)] = i;
               }          
            }
            if(thread ==2){
               if(i>15 && i <=20){
                  primes[index.getAndAdd(1)] = i;
               }
            }

If you want to keep count of how many primes each thread uses then you can still use your a,b,c,d but they shouldn't be used as indexes to shared data.