Threading Exercises

Driver3.java

/*
*Write code to implement a 
*Producer-Consumer model which 
*utilizes the Guarded Block
*paradigm. 
*/
import java.util.concurrent.*;
public class Driver3 {
	public static DropBox dropbox = new DropBox();
	public static void main(String[] args) {
		ExecutorService executor = Executors.newFixedThreadPool(2);
		executor.execute(new Producer(dropbox));
		executor.execute(new Consumer(dropbox));
		executor.shutdown();
		while(!executor.isTerminated()){}
		System.out.println("Complete " + Thread.currentThread().getName());
	}
	
	public static class Producer implements Runnable {
		private DropBox dropbox;
		public Producer(DropBox dropbox) {
			this.dropbox = dropbox;
		}
		public void run() {
			
			Product product = new Product();
			System.out.println(dropbox.put(product));
			System.out.println("Placed1 " + Thread.currentThread().getName() + " Producer");
			try {
				Thread.sleep(2000);
				Product product1 = new Product();
				
				System.out.println(dropbox.put(product1));
				System.out.println("Placed2 " + Thread.currentThread().getName() + " Producer");
			}catch(InterruptedException e){}
			
			
		}
		
	}
	public static class Consumer implements Runnable {
		private DropBox dropbox;
		public Consumer(DropBox dropbox) {
			this.dropbox = dropbox;
		}
		public void run() {
			System.out.println(dropbox.take());
	
			System.out.println("Taken1 " + Thread.currentThread().getName() + " Consumer");
			try {
				Thread.sleep(2000);
				
				System.out.println(dropbox.take());
				System.out.println("Taken2 " + Thread.currentThread().getName() + " Consumer");
			}catch(InterruptedException e){}
		}
	}
	public static class Product{}
	public static class DropBox {
		Product product;
		boolean isFull = false;
		public synchronized String put(Product product) {
			while(isFull) {
				try {
					wait();
				}catch(InterruptedException e){}
			}
			isFull = true;
			this.product = product;
			notifyAll();
			return "putting..";
		}
		
		public synchronized String take() {
			while(!isFull) {
				try {
					wait();
				}catch(InterruptedException e){}
			}
			isFull = false;
			product = null;
			notifyAll();
			return "taking..";
		}
	}
}

p1.png

TenThreads.java

public class TenThreads {
	public static int count = 0;

	public static void main(String[] args) {
		/*
		 * "Write a program that starts 10 jobs of random duration in 10 threads
		 * and prints out the order they finish in. Note that the jobs don't
		 * have to do anything, just sleep. You should probably define an
		 * instance variable to specify the order, which is defined when
		 * created."
		 * 
		 */
		for (int i = 0; i < 10; i++) {
			long sleepTime = (long) (Math.random() * 10000) + 1000;
			Thread t = new Thread(new CustomJob(i, sleepTime));
			t.start();
		}
	}

	private static class CustomJob implements Runnable {
		int jobId;
		long sleepTime;

		public CustomJob(int jobId, long sleepTime) {
			this.jobId = jobId;
			this.sleepTime = sleepTime;
			count += 10;
		}

		public void run() {

			try {
				jobId += 1;
				Thread.sleep(sleepTime);
				System.out.format("Complete. Job %2d of %2s. I slept for %2d seconds.\n", jobId,
						Thread.currentThread().getName(), sleepTime / 1000);

			} catch (Exception e) {
				System.out.println(Thread.currentThread().getName() + " was interrupted.");
				e.printStackTrace();
			}
		}
	}
}

ThreadsExecutorService.java

/*
*Re-write ThreadsGuardedBlock.java 
*utilizing ExecutorService objects.
*/


import java.util.concurrent.*;
public class ThreadsExecutorService {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newFixedThreadPool(10);
		// submit each thread
		for (int i = 0; i < 10; i++) {
			executor.submit(new MyRunnable(i + 1));
		}
		executor.shutdown();
	}

	private static class MyRunnable implements Runnable {
		private int numJobs;

		public MyRunnable(int numJobs) {
			this.numJobs = numJobs;
		}

		public void run() {
			long sleepTime = (long) (Math.random() * 10000) + 1000;
			try {
				Thread.sleep(sleepTime);
				System.out.format("Complete. Job number %2d of %16s. I slept for %2d seconds.\n", numJobs,
						Thread.currentThread().getName(), sleepTime / 1000);
			} catch (InterruptedException e) {
				System.out.println(Thread.currentThread().getName() + " was interrupted.");
				e.printStackTrace();
			}

		}
	}

}

ThreadsGuardedBlock.java

/*
*Re-write the TenThreads.java but only 
*use two threads. Use the guarded block
*paradigm to acheive this.
*/

public class ThreadsGuardedBlock {
	public static void main(String[] args) {
		Thread thread = new Thread(new MyRunnable(0));
		thread.start();
		Thread thread2 = new Thread(new MyRunnable(5));
		thread2.start();

	}

	private static class MyRunnable implements Runnable {
		private int numIterations;
		private int numJobs;

		public MyRunnable(int numJobs) {
			numIterations = 0;
			this.numJobs = numJobs;
		}

		public boolean isCountDone() {
			if (numIterations == Integer.MIN_VALUE) {
				return false;
			}
			return numIterations >= 5;
		}

		public void run() {
			while (!isCountDone()) {
				numIterations += 1;
				numJobs += 1;
				long sleepTime = (long) (Math.random() * 10000) + 1000;
				try {
					Thread.sleep(sleepTime);
					System.out.format("Complete. Job number %2d of %2s. I slept for %2d seconds.\n", numJobs,
							Thread.currentThread().getName(), sleepTime / 1000);
				} catch (InterruptedException e) {
					System.out.println(Thread.currentThread().getName() + " was interrupted.");
					e.printStackTrace();
				}
			}
		}
	}
}