import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import javax.swing.SwingWorker;




public class TestField {
	
	
	public static void main(String[] args) {
		
		//Storing stuff, obvious stuff
		int numIterations = 5000;
		double singleTimeSum = 0, multiTimeSum = 0;
		
		//hasPrint and anything to do with it are simply a convenience thing, for print out the percentage complete every 10%
		boolean hasPrint = true;
		
		for(int i=0; i<numIterations; i++) {
			//Again, these two lines are just convenience, they print out x% every 10 percent
			if(!hasPrint && ((i*100)/numIterations) % 10 == 0) System.out.println((i*100)/numIterations + "%");
			hasPrint = ((i*100)/numIterations) % 10 == 0;

			//Run test
			new Go();
			
			
			try {
				//We gotta hold up while our threads properly die, otherwise it makes them faster than it can destroy them,
				//and computer is SAD
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			//Add time to sum
			singleTimeSum += singleTime;
			multiTimeSum += multiTime;
			
			//and reset times
			singleTime = 0;
			multiTime = 0;
		}
		
		//Print out results
		System.out.println("Results (across " + numIterations + " tests): ");
		System.out.println("Single-Thread time:\t" + (singleTimeSum / (float)numIterations));
		System.out.println("Multi-Thread time:\t" + (multiTimeSum / (float)numIterations));
	}

	
	//Go references these variables, as though "out" parameters from a class.
	static double multiTime, singleTime;
	
	//Runs the test once, stores results in multiTime, singleTime
	static class Go {
		public Go() {
			
			//Fill an array of 20k random doubles, just, because.
			final double[] array = new double[20000];
			for (int i = 0; i < array.length; i++) array[i] = Math.random();
			
			//The two threads store their results in here
			final double[] threadTime = new double[2];
			
			//This is the worker thread
			SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {

				@Override
				protected Void doInBackground() throws Exception {
					double temp;
					
					//For timing, start clock
					long localTime = System.nanoTime();
					
					//read from the array start-to-end, 6000 times
					for(int readIndex = 0; readIndex < 6000; readIndex++) {
						for (int i = 0; i < array.length; i++) {
							temp = array[i];
						}
					}
					
					//Store end time now, so that we may perform processign with this value without overhead
					long endTime = System.nanoTime();
					
					//Store in our array, without knowing which thread will end first
					if(threadTime[0] < 0) threadTime[0] = (endTime - localTime)/1e6;
					else threadTime[1] = (endTime - localTime)/1e6;
					return null;
				}
				
			};

			//This is an exact copy of the worker thread, I was unsure if just executing the SAME instance of it would execute as expected
			SwingWorker<Void, Void> worker2 = new SwingWorker<Void, Void>() {
				
				@Override
				protected Void doInBackground() throws Exception {
					double temp;
					
					long localTime = System.nanoTime();
					
					for(int readIndex = 0; readIndex < 6000; readIndex++) {
						for (int i = 0; i < array.length; i++) {
							temp = array[i];
						}
					}
					
					long endTime = System.nanoTime();
					
					if(threadTime[0] < 0) threadTime[0] = (endTime - localTime)/1e6;
					else threadTime[1] = (endTime - localTime)/1e6;
					return null;
				}
				
			};
			
			
			//Thread pool
			ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
			
			//Execute each thread
			pool.execute(worker);
			pool.execute(worker2);
			
			try {
				//Shutdown and WAIT for our threads, so that we don't SPAM the computer with threads (it still does, anyway.)
				pool.shutdown();
				pool.awaitTermination(10000, TimeUnit.MILLISECONDS);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			//Average the two Thread times.
			multiTime += (threadTime[0] + threadTime[1]) / 2.0;
			
			//Basically, run the same code on the main thread.
			//Could have made another worker to just run by itself, but, meh
			double temp;
			long startTime = System.nanoTime();
			for(int r=0; r<6000; r++) {
				for (int i = 0; i < array.length; i++) {
					temp = array[i];
				}
			}
			
			//Store single time
			singleTime += (System.nanoTime() - startTime)/1e6;
		}
	}
}