4 нить найти простое число

Question

Я пытаюсь использовать 4-равномерно сбалансированные потоки, чтобы найти простое число от 10 до 30. Я хочу знать, сколько простых чисел для каждого потока, сколько всего и распечатать простое число , Я запускал программу несколько раз, каждый раз для каждого выхода. Может ли кто-нибудь помочь мне разобраться с проблемой.

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

Как @Louis упоминается в комментарии к вашему вопросу, все ваши темы переписывают друг друга.

Когда Thread1 помещает его в простые числа [0], другие потоки не сообщаются, а затем также помещают свою работу в простые числа [0] (что перезаписывает уже выполненную работу). Вы получаете разные выходы главным образом потому, что порядок выполнения потоков «случайный».

Простым решением является отсутствие индекса для каждой нити (a, b, c, d), но для использования AtomicInteger от java.util.concurrent.atomic.AtomicInteger.

Краткий пример того, как использовать 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; 
       } 
      } 

Если вы хотите сохранить количество сколько простых чисел каждая нить использует, то вы все еще можете использовать a,b,c,d, но они не должны использоваться в качестве индексов к общим данные.