i wrote program finding new number. problem program doesn't stop. know have threads don't what.
primes class (main):
public class primes { /** * queue holding candidates want check primality. */ private blockingqueue<integer> candidatequeue; /** * queue holding primes want print before inserting result set. */ private blockingqueue<integer> primesqueue; /** * set holding numbers have determined prime. */ private set<integer> primenumbers; /** * create new instance of primes checker program. */ public primes() { // todo: if best type of blockingqueue use, , best size? // feel free change both. candidatequeue = new linkedblockingqueue<integer>(); // todo: if best type of blockingqueue use, , best size? // feel free change both. primesqueue = new linkedblockingqueue<integer>(); // todo: hashset best option here, , there options // make perform better? feel free change different type of set or // add parameters constructor. primenumbers = new hashset<integer>(); } /** * run primes finder, looking primes between smallest , biggest (inclusive). * * @param smallest smallest number check * @param biggest biggest number check * * @return {@link set} containing prime numbers have found */ public set<integer> findprimesinrange(int smallest, int biggest) { // todo: should create number generator , primes printer, // number of primality checkers. should create these // threads can run prime numbers. should have @ least // 2 instances of {@link primalitychecker}, have more if makes // program faster. // todo: here make compiler happy, should return real... numbergenerator = new numbergenerator( smallest,biggest,candidatequeue); new thread(a).start(); primalitychecker p1 = new primalitychecker(candidatequeue,primesqueue); new thread(p1).start(); primalitychecker p2 = new primalitychecker(candidatequeue,primesqueue); new thread(p2).start(); primesprinter pp = new primesprinter(primesqueue,primenumbers); thread t1= new thread(pp); t1.start(); // t1.interrupt(); return primenumbers; } public static void main(string[] args) { primes p = new primes(); // remember, 1 not prime! http://en.wikipedia.org/wiki/prime_number p.findprimesinrange(2, 100); } } numbergenerator class:
public class numbergenerator implements runnable { /** biggest number plan check */ private final int biggestnumbertocheck; /** queue place numbers generate, need checked */ private final blockingqueue<integer> candidatequeue; private final int smallestnumberstart; // todo: other state need? /** * create new instance of numbergenerator class, hand out numbers * need checked. * * @param smallest smallest number check * @param biggest biggest number check * @param queue queue put numbers check */ public numbergenerator(int smallest, int biggest, blockingqueue<integer> queue) { biggestnumbertocheck = biggest; candidatequeue = queue; smallestnumberstart = smallest; } public void run(){ for(int i=smallestnumberstart; i<=biggestnumbertocheck; i++){ //int rand= threadlocalrandom.current().nextint(smallestnumberstart, biggestnumbertocheck); candidatequeue.add(i); } } // todo: can decide how want turn runnable thread. // please @ code examples we've discussed in class , @ lecture slides, // @ concurrency tutorial: http://docs.oracle.com/javase/tutorial/essential/concurrency/ } primalitychecker:
public class primalitychecker implements runnable { /** queue holds generated numbers have not yet checked */ private final blockingqueue<integer> candidatequeue; /** queue place numbers when determine prime */ private final blockingqueue<integer> primesqueue; // todo: other state need? /** * create instance of primalitychecker class, check numbers see if * prime , insert them result queue. * * @param candidates queue holds candidates check * @param primes queue holds prime numbers have found */ public primalitychecker(blockingqueue<integer> candidates, blockingqueue<integer> primes) { candidatequeue = candidates; primesqueue = primes; } public void run(){ iterator<integer> itr = candidatequeue.iterator(); while(itr.hasnext()){ integer queue = null; try { queue = candidatequeue.take(); } catch (interruptedexception e1) { // todo auto-generated catch block e1.printstacktrace(); } if (isprime(queue)) { primesqueue.add(queue); // try { // system.out.println(primesqueue.take()); // } catch (interruptedexception e) { // todo auto-generated catch block // e.printstacktrace(); //} } } //catch (interruptedexception e) { // todo auto-generated catch block // e.printstacktrace(); //} // } public static boolean isprime(int number){ for(int i=2; i<number; i++){ if(number%i == 0){ return false; } } return true; } // todo: can decide how want turn runnable thread. // please @ code examples we've discussed in class , @ lecture slides, // @ concurrency tutorial: http://docs.oracle.com/javase/tutorial/essential/concurrency/ } primeprinter:
public class primesprinter implements runnable { /** queue holds numbers have determined prime have not yet processed */ private final blockingqueue<integer> primesqueue; /** set holds prime numbers have found */ private final set<integer> primesset; // todo: other state need? /** * create instance of primesprinter class, print numbers * come in on primes queue , place them in primes set. * * @param primes queue holds prime numbers have found not yet processed * @param primesset set holds prime numbers have found */ public primesprinter(blockingqueue<integer> primes, set<integer> primesset) { primesqueue = primes; this.primesset = primesset; } @override public void run() { // iterator<integer> itr = primesqueue.iterator(); // while (!thread.currentthread().isinterrupted()){ while(primesqueue.size()>=0){ integer queue; try { queue=primesqueue.take(); //queue = primesqueue.poll(100, timeunit.milliseconds); //if(queue==null){ // break; //} system.out.println(queue); primesset.add(queue); } catch (interruptedexception e) { // todo auto-generated catch block e.printstacktrace(); } } }
below updated code, let me know if helps.
import java.util.concurrent.blockingqueue; public class numbergenerator implements runnable { private final int biggestnumbertocheck; private final blockingqueue<integer> candidatequeue; private final int smallestnumberstart; public numbergenerator(int smallest, int biggest, blockingqueue<integer> queue) { biggestnumbertocheck = biggest; candidatequeue = queue; smallestnumberstart = smallest; } public void run() { (int = smallestnumberstart; <= biggestnumbertocheck; i++) { candidatequeue.add(i); } } } primalitychecker
import java.util.iterator; import java.util.concurrent.blockingqueue; public class primalitychecker implements runnable { private final blockingqueue<integer> candidatequeue; private final blockingqueue<integer> primesqueue; public primalitychecker(blockingqueue<integer> candidates, blockingqueue<integer> primes) { candidatequeue = candidates; primesqueue = primes; } public void run() { iterator<integer> itr = candidatequeue.iterator(); while (itr.hasnext()) { integer queue = null; try { queue = candidatequeue.take(); } catch (interruptedexception e1) { system.out.println("primalitychecker thread interruped"); return; } if (isprime(queue)) { primesqueue.add(queue); } } } public static boolean isprime(int number) { (int = 2; < number; i++) { if (number % == 0) { return false; } } return true; } } primesprinter
import java.util.set; import java.util.concurrent.blockingqueue; public class primesprinter implements runnable { private final blockingqueue<integer> primesqueue; private final set<integer> primesset; public primesprinter(blockingqueue<integer> primes, set<integer> primesset) { primesqueue = primes; this.primesset = primesset; } @override public void run() { while (!thread.currentthread().isinterrupted()) { while (primesqueue.size() > 0) { integer queue; try { queue = primesqueue.take(); system.out.println(queue); primesset.add(queue); } catch (interruptedexception e) { system.out.println("primes printer interrupted"); e.printstacktrace(); } } } } } primes
import java.util.hashset; import java.util.set; import java.util.concurrent.blockingqueue; import java.util.concurrent.linkedblockingqueue; public class primes { private blockingqueue<integer> candidatequeue; private blockingqueue<integer> primesqueue; private set<integer> primenumbers; public primes() { candidatequeue = new linkedblockingqueue<integer>(); primesqueue = new linkedblockingqueue<integer>(); primenumbers = new hashset<integer>(); } public void findprimesinrange(int smallest, int biggest) { numbergenerator = new numbergenerator(smallest, biggest, candidatequeue); thread threada = new thread(a); threada.start(); primalitychecker p1 = new primalitychecker(candidatequeue, primesqueue); thread threadp1 = new thread(p1); threadp1.start(); primalitychecker p2 = new primalitychecker(candidatequeue, primesqueue); thread threadp2 = new thread(p2); threadp2.start(); primesprinter pp = new primesprinter(primesqueue, primenumbers); thread threadpp = new thread(pp); threadpp.start(); while (true) { try { thread.sleep(1000); if (candidatequeue.size() == 0 && primesqueue.size() == 0) { threada.interrupt(); threadp1.interrupt(); threadp2.interrupt(); threadpp.interrupt(); break; } } catch (interruptedexception e) { e.printstacktrace(); } } } public static void main(string[] args) { primes p = new primes(); p.findprimesinrange(2, 100); } } 