The Big Programming Thread - Page 482

import java.util.concurrent.*;

public class ThreadTest2 {
   
   private static final int FINISH = 2000000;
   private static int maxDivisorCount;
   private static int numberWithMaxDivsisors;
   private static ArrayBlockingQueue<DivisorTask> blockingQueue;
   
   /**
    * Gets the number of threads from the user and counts primes using that many threads.
    */
   public static void main(String[] args) {
      int processors = Runtime.getRuntime().availableProcessors();
      if (processors == 1)
         System.out.println("Your computer has only 1 available processor.\n");
      else
         System.out.println("Your computer has " + processors + " available processors.\n");
      int numberOfThreads = 0;
      while (numberOfThreads < 1 || numberOfThreads > 1000) {
         System.out.print("How many threads do you want to use  (from 1 to 1000) ?  ");
         //numberOfThreads = TextIO.getlnInt();
         numberOfThreads = 8;
         if (numberOfThreads < 1 || numberOfThreads > 1000)
            System.out.println("Please enter 1, 2, 3, 4, 5, 6, 7, or 8 !");
      }
      countDivisorsWithThreads(numberOfThreads);
   }
   
   private static void countDivisorsWithThreads(int numberOfThreads) {
	  blockingQueue = new ArrayBlockingQueue<DivisorTask>(10000);
	  int numTasks = 100;
	  int increment = FINISH/numTasks;
      System.out.println("\nCounting primes between 1 and " 
            + (FINISH) + " using " + numberOfThreads + " threads...\n");
      long startTime = System.currentTimeMillis();
      CountDivisorsThread[] worker = new CountDivisorsThread[numberOfThreads];
      for (int i = 0; i < numberOfThreads; i++)
         worker[i] = new CountDivisorsThread();
      numberWithMaxDivsisors = 0;
      maxDivisorCount = 0;
      for (int i = 0; i < numTasks; i++) 
    	  try {
    		  blockingQueue.put(new DivisorTask(i * increment + 1, (i+1) * increment));
    	  }
      	  catch (InterruptedException e) {
      		  
      	  }
      for (int i = 0; i < numberOfThreads; i++)
          worker[i].start();         
      for (int i = 0; i < numberOfThreads; i++) {
         while (worker[i].isAlive()) {
            try {
               worker[i].join();
            }
            catch (InterruptedException e) {
            	
            }
         }
      }
      if (blockingQueue.isEmpty())
    	  worker = null;
      
      long elapsedTime = System.currentTimeMillis() - startTime;
      System.out.println("\nThe number with most divisors is " + numberWithMaxDivsisors + ".");
      System.out.println("\nThe number of divisors is " + maxDivisorCount + ".");
      System.out.println("\nTotal elapsed time:  " + (elapsedTime/1000.0) + " seconds.\n");
   }
      
   private static class CountDivisorsThread extends Thread {
	   public CountDivisorsThread() {
		   
	   }
	   
	   public void run() {
		   DivisorTask task = null;
//		   try {
//			   task = blockingQueue.take();
//		   }
//		   catch (InterruptedException e) {
//			   
//		   }
//		   while (!blockingQueue.isEmpty()) {
//			   task.run();
//			   try {
//				   task = blockingQueue.take();
//			   }
//			   catch (InterruptedException e) {
//				   
//			   }
//		   }
		   
		   while (!blockingQueue.isEmpty()) {
			   try {
				   task = blockingQueue.take();
			   }
			   catch (InterruptedException e) {
				   
			   }
			   task.run();
		   }
	   }
	   
   }
   
   private static class DivisorTask {
	   int numDivisorsThread;
	   int numWithMostThread;
	   int min, max;
	   public DivisorTask(int min, int max) {
		   this.min = min;
	       this.max = max;
	       numDivisorsThread = 0;
	       numWithMostThread = 0;
	   }
	   public void run() {
		   int currentNum;
		   int currentDivisor;
		   for (int i = min; i < max + 1; i++) {
			   currentNum = i;
			   currentDivisor = countDivisors(i);
			   if (currentDivisor > numDivisorsThread) {
				   numWithMostThread = currentNum;
				   numDivisorsThread = currentDivisor;
			   }
		   }
	       System.out.println("The DIVnumber between " + min + " and " + max + " is " + numWithMostThread
	    		   + "\n" + "The number of divisors that it has is " + numDivisorsThread + "\n"
	    		   + "Is the task queue empty?: " + blockingQueue.isEmpty());         
	       if (numDivisorsThread > maxDivisorCount) {
	    	   newMax(numDivisorsThread, numWithMostThread);
	       }
	   }
   }
   
   private static int countDivisors(int num) {
      int count = 0;
      for (int i = 1; i < Math.sqrt(num); i++) {
         if (num % i == 0)
            count += 2;
      }
      if (Math.sqrt(num) - (int)Math.sqrt(num) == 0)
    	  count++;
      return count;
   }
   
   synchronized private static void newMax(int divisors, int number) {
	   maxDivisorCount = divisors;
	   numberWithMaxDivsisors = number;
   }
   
}