//NOTE: Not recommended to run the below program with online IDE. // You can copy the source code and run it on our local machine. import java.io.IOException; import static java.lang.Thread.MAX_PRIORITY; import static java.lang.Thread.MIN_PRIORITY; import java.util.LinkedList; import java.util.Random; import java.util.Scanner; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.Callable; import java.util.concurrent.CountDownLatch; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.FutureTask; import java.util.concurrent.Semaphore; /** * @author BENJAH * Copyright Nov 16, 2017 */ class NormalExecution{ private String threadName; public NormalExecution(String threadName) { this.threadName= threadName; System.out.println("Creating a Normal Execution of: "+threadName); } //user defined run() method; provides an entry point for the thread public void run() { try { for (int i= 1; i<5; i++) { System.out.println("Running Normal Execution of: " +threadName+", Iteration ->"+i); Thread.sleep(3000); //Causes the currently executing thread to sleep temporarily (3 Seconds) } } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(threadName+" exiting."); } public void start() { System.out.println("Starting Normal Execution of: "+threadName); run(); //Causes this thread to begin execution; call to the run method of this thread. } } //Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. class RunnableExample implements Runnable{ private String threadName; public RunnableExample(String threadName) { this.threadName= threadName; System.out.println("Creating "+threadName); } //implementing a run() method provided by a Runnable interface. This method provides an entry point for the thread @Override public void run() { try { for (int i= 1; i<5; i++) { System.out.println("Running "+threadName+", Iteration ->"+i); Thread.sleep(3000); //Causes the currently executing thread to sleep temporarily (3 Seconds) } } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(threadName+" exiting."); } } //thread is a thread of execution in a program. The JVM allows an application to have multiple threads of execution running concurrently. class ThreadExample extends Thread{ private String threadName; public ThreadExample(String threadName) { this.threadName= threadName; System.out.println("Creating "+threadName); } //implementing a run() method provided by the Thread Class. This method provides an entry point for the thread @Override public void run() { try { for (int i= 1; i<5; i++) { System.out.println("Running "+threadName+", Iteration ->"+i); Thread.sleep(3000); //Causes the currently executing thread to sleep temporarily. For 3 Seconds } } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(threadName+" exiting."); } } class ThreadStatesExample implements Runnable{ @Override public void run() { try { Thread.sleep(2000); //moving thread2 to timed waiting state (2 Seconds) } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("State of thrState1 after calling join() : " +Main.thrState1.getState()); try { Thread.sleep(2000); //moving thread to timed waiting state (2 Seconds) } catch (Exception e) { e.printStackTrace(); } } } class ChildThread implements Runnable{ @Override public void run() { Thread childThread= Thread.currentThread(); System.out.println("Starting childThread"); System.out.println("Child thread defaultName : " +childThread.getName()); //getting name Main thread childThread.setName("childThread"); //changing the name of Main thread System.out.println("Child thread newName : " +childThread.getName()); System.out.println("childThread defaultPriority : " +childThread.getPriority()); childThread.setPriority(MIN_PRIORITY); System.out.println("childThread newPriority : " +childThread.getPriority()); String childName= childThread.getName(); try { //Thread.currentThread().join(); //causes the currentThread to waits for mainThread to finish with its execution. System.out.println(childName+" waiting for 2 seconds"); Thread.currentThread().join(2000); //causes the currentThread to waits for 2 Secs then continues with its execution. for (int i= 0; i<5; i++) { Thread.sleep(1200); System.out.println(childName+" iteration-> "+i); } } catch (Exception e) { e.printStackTrace(); } finally { System.out.println("Exiting "+childName); } } } class ConcurrencyDemo extends Thread{ @Override public void run() { Thread.currentThread().setPriority(MAX_PRIORITY); for (int i= 0; i<5; i++) { System.out.println(Thread.currentThread().getName()+" in Control"); } } } //class used to send a message class SendMessage{ public void sendMsg(String msg) { System.out.println("Sending "+msg); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); System.err.println("Message not sent"); } finally { System.out.println("Message sent successfully"); } } } //class to send a message using synchonized threads class ThreadedSend extends Thread{ private String message; private Thread smsThread; private SendMessage smsObj; //Recieves a string message to be sent and the message object public ThreadedSend(String message, SendMessage smsObj) { this.message= message; this.smsObj= smsObj; } @Override public void run() { //only one thread can send a message at a time synchronized(smsObj){ smsObj.sendMsg(message); //Synchronizing the smsObj } } } //PC class with produce() and consume() methods. class PC{ public void produce() throws InterruptedException { synchronized(this){ //synchronized block ensures only one thread running at a time. System.out.println("Producer thread running"); wait(); //releases the lock on shared resource and waits till some other method invokes notify() System.out.println("Producer thread resumed"); } } public void consume() throws InterruptedException { Thread.sleep(1000); //sleeps to ensure the produce thread to run first. Scanner sc= new Scanner(System.in); synchronized (this) { System.out.println("Waiting for return key"); sc.nextLine(); System.out.println("Return key pressed"); //notify(); //notifies the produce thread that it can wake up. Thread.sleep(2000); } } } class ProducerConsumerSolution{ LinkedList list= new LinkedList(); //list shared by producer(addItems) and consumer(removesItems) int listCapacity= 9; //maximum values this list can hold //method called by producer thread public void produce() throws InterruptedException { Thread.sleep(5000); //sleeps to ensure the produce thread to run first. int value= 0; while (true) { synchronized (this) { if (list.size()== listCapacity) wait(); //ensures producer thread waits if list is full System.out.println("Produced adding -> "+value); list.add(value++); //inserts value then add 1 to value Thread.sleep(800); //helps for easy understanding System.out.println("List is now -> "+list); notify(); //notifies consumer thread that it can start removing now Thread.sleep(1400); //helps for easy understanding } } } //method called by consumer thread public void consume() throws InterruptedException { while (true) { synchronized (this) { if (list.size()== 0) wait(); //ensures producer thread waits if list is full System.err.println("Produced removing -> "+list.pollFirst()); Thread.sleep(700); //helps for easy understanding System.err.println("List is now -> "+list); notify(); //notifies producer thread that it can start adding now Thread.sleep(1100); //helps for easy understanding } } } } class ThreadPoolsExample implements Runnable{ private String threadName; public ThreadPoolsExample(String threadName) { this.threadName= threadName; } @Override public void run() { try { for (int i= 1; i<=5; i++) { if (i==0) System.out.println("Starting "+threadName +", Iteration -> "+i); else System.out.println("Executing "+threadName +", Iteration -> "+i); Thread.sleep(1000); } } catch (Exception e) { e.printStackTrace(); } finally { System.err.println(threadName+" complete"); } } } class SemaphoresExample extends Thread{ private static Semaphore sem= new Semaphore(1); //Allows only one thread to access the shared resource at any one time. private static int count; private String threadName; public SemaphoresExample(String threadName) { this.threadName= threadName; } @Override public void run() { System.out.println("Starting "+threadName); try { Thread.sleep(1000); System.err.println(threadName+" is waiting for permit"); sem.acquire(1); //Thread acquiring lock. NOTE: Other waiting threads will wait, until this thread release the lock Thread.sleep(1000); System.out.println(threadName+" acquired lock on SharedResource"); Thread.sleep(1000); for (int i= 0; i<2; i++) { count++; //Accessing the shared resource. System.out.println(threadName+" writting to file -> "+count); Thread.sleep(1000); } } catch (Exception e) { e.printStackTrace(); } finally { System.err.println(threadName+" releasing lock on SharedResource"); sem.release(); //releasing lock } } } class SemaphoreClass extends Thread{ private Semaphore sem; private String threadName; public SemaphoreClass(String threadName, Semaphore sem) { super(threadName); this.threadName= threadName; this.sem= sem; } @Override public void run() { try { Thread.sleep(1000); System.err.println(threadName+" is waiting for permit"); sem.acquire(); //Thread acquiring lock. NOTE: Other waiting threads will wait, until this thread release the lock Thread.sleep(1000); System.out.println(threadName+" acquired lock on SharedResource"); Thread.sleep(1000); if (sem.hasQueuedThreads()) //Queries whether any threads are waiting to acquire. System.out.println("Number of threads queued = " +sem.getQueueLength()); //Returns an estimate of the number of threads waiting to acquire lock. Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.err.println(threadName+" releasing lock on SharedResource"); sem.release(); //releasing lock } } } //A class to represent threads for which the main thread awaits. class Worker extends Thread{ private static CountDownLatch latch; private String threadName; public Worker(String threadName, CountDownLatch latch) { this.threadName= threadName; this.latch= latch; } @Override public void run() { try { System.out.println(threadName+" started working"); if (threadName.endsWith("1")) Thread.sleep(2000); if (threadName.endsWith("2")) Thread.sleep(6000); if (threadName.endsWith("3")) Thread.sleep(4000); if (threadName.endsWith("4")) Thread.sleep(8000); latch.countDown(); //Decrements the count of the latch, releasing all waiting threads if the count reaches zero. } catch (Exception e) { e.printStackTrace(); } finally { System.err.println(threadName+" finished working"); } } } class CountryBus extends Thread { public static CyclicBarrier barrier= new CyclicBarrier(5); //allows a set of threads to all wait for each other to reach a common barrier point. private String passengerName; private static int seatsTaken= 1; private static int busNumber= 1; public CountryBus(String passengerName) { this.passengerName= passengerName; } @Override public void run() { try { Thread.sleep(1000); System.out.println(passengerName+" is booking ticket"); Thread.sleep(1000); seatsTaken= 1+barrier.getNumberWaiting(); //Returns the number of parties currently waiting at the barrier. System.out.println(passengerName+" assigned seat -> "+seatsTaken); Thread.sleep(1000); if (seatsTaken<5) System.err.println("Bus waiting for " +(5-seatsTaken)+" passengers"); Thread.sleep(1000); barrier.await(); } catch (InterruptedException | BrokenBarrierException e) { e.printStackTrace(); } finally { System.out.println("NOTIFICATION: Hello "+passengerName +", Bus is to leave in 30mins."); barrier.reset(); //Resets the barrier to its initial state. } } } class CallableExample implements Callable{ @Override public Object call() throws Exception { Integer randomNumber= new Random().nextInt(5); //Create random number between 0 and 4 Thread.sleep(randomNumber*1000); return randomNumber; } } class ShutDownMessage extends Thread{ @Override public void run() { try { System.out.println("Shutdown Hook Running now"); Thread.sleep(2000); System.out.println("Closing application resources"); Thread.sleep(2000); System.err.println("Closing application"); } catch (InterruptedException e) { e.printStackTrace(); } } } public class Main implements Runnable { public static Thread thrState1; @Override public void run() { Thread thrState2= new Thread(new ThreadStatesExample()); //thrState2 created and is currently in the NEW state. System.out.println("State of thrState2 after creation : " +thrState2.getState()); thrState2.start(); //Causes this thread to begin execution. The JVM calls the run() method of this thread -> in ThreadStatesExample class //thrState2 moved to Runnable state. System.out.println("State of thrState2 after calling start() : " +thrState2.getState()); try { Thread.sleep(1000); //moving thrState2 to timed waiting state (1 Seconds) } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("State of thrState2 after calling sleep() : " +thrState2.getState()); try { thrState2.join(); //Waiting for this thread to die. } catch (Exception e) { e.printStackTrace(); } System.out.println("State of thrState2 after ending execution: " +thrState2.getState()); } public static void main(String[] args) throws InterruptedException, ExecutionException { //normalThreadExecution(); //implementingRunnable(); //extendingThread(); //threadStates(); //threadMethods(); //concurencyControl(); //threadPriorities(); //threadSynchronization(); //interThreadCommunication(); //producerConsumerDemo(); //threadPools(); //semaphoreDemo(); //semaphoreMethods(); //countDownLacthDemo(); //cyclicBarrierDemo(); //callableFutureDemo(); //shutDownHooksDemo(); runtimeMethods(); } public static void runtimeMethods() { Runtime run= Runtime.getRuntime(); //returns the instance or Runtime object associated with the current Java application. ShutDownMessage hook= new ShutDownMessage(); run.addShutdownHook(hook); //registering a new virtual-machine shutdown hook thread. //run.removeShutdownHook(hook); //deregistering a virtual-machine shutdown hook thread. //run.exit(0); //terminates the currently running Java virtual machine by initiating its shutdown sequence. try { System.out.println("Current runtime instance -> "+run); Thread.sleep(2000); long totalMem= run.totalMemory(); //returns the amount of total memory in the JVM long freeMem= run.freeMemory(); //returns the amount of free memory in the JVM System.out.println("Approx total memory -> " +(totalMem/1024)/1024); //converting to megabites Thread.sleep(2000); System.out.println("Approx available memory -> " +(freeMem/1024)/1024); //converting to megabites Thread.sleep(2000); System.out.println("Available processors -> " +run.availableProcessors()); //returns the number of processors available to the JVM Thread.sleep(2000); System.out.println("Opening notepad in 2 Seconds"); Thread.sleep(2000); Process process= run.exec("notepad.exe"); //create a process and execute notepad.exe Thread.sleep(2000); } catch (IOException|InterruptedException e) { e.printStackTrace(); } } public static void shutDownHooksDemo() throws InterruptedException { Runtime.getRuntime().addShutdownHook(new Thread(){ public void run() { try { System.out.println("Shutdown Hook Running"); Thread.sleep(2000); System.out.println("Closing application resources"); Thread.sleep(2000); System.err.println("Closing application"); } catch (InterruptedException e) { e.printStackTrace(); } } }); for (int i= 0; i<10; i++) { System.out.println("Application Running"); Thread.sleep(2000); } } public static void callableFutureDemo() throws InterruptedException, ExecutionException { FutureTask task[]= new FutureTask[5]; // FutureTask is a concrete class that implements both Runnable and Future for (int i= 0; i<5; i++) { task[i]= new FutureTask(new CallableExample()); //Create a FutureTask with CallableExample Thread futureThread= new Thread(task[i]); // As it implements Runnable, we can create Thread with FutureTask futureThread.start(); } for (int i= 0; i<5; i++) System.out.println(task[i].get()); //As it implements Future, we can call get() //NOTE: This method blocks till the result is obtained // The get method can throw checked exceptions like when it is interrupted. } public static void cyclicBarrierDemo() { System.out.println("Passengers required for depature -> " +CountryBus.barrier.getParties()); //Returns the number of parties required to trip this barrier CountryBus passenger1= new CountryBus("Passenger 1"); CountryBus passenger2= new CountryBus("Passenger 2"); CountryBus passenger3= new CountryBus("Passenger 3"); CountryBus passenger4= new CountryBus("Passenger 4"); CountryBus passenger5= new CountryBus("Passenger 5"); try { passenger1.start(); Thread.sleep(5000); passenger2.start(); Thread.sleep(5000); passenger3.start(); Thread.sleep(5000); passenger4.start(); Thread.sleep(5000); passenger5.start(); } catch (InterruptedException e) { e.printStackTrace(); } } public static void countDownLacthDemo() throws InterruptedException { CountDownLatch latch= new CountDownLatch(4); //A CountDownLatch is initialized with a count: 4. Worker worker1= new Worker("Worker 1", latch); Worker worker2= new Worker("Worker 2", latch); Worker worker3= new Worker("Worker 3", latch); Worker worker4= new Worker("Worker 4", latch); worker1.start(); worker2.start(); worker3.start(); worker4.start(); latch.await(); //Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted. //System.out.println("Starting Main thread"); Worker mainThread= new Worker("Main Thread", latch); mainThread.start(); } public static void semaphoreMethods() { Semaphore sem= new Semaphore(5, true); //Allows only two threads to access the shared resource at any one time. try { System.out.println("Is fairness enabled -> "+sem.isFair()); //Returns true if this semaphore has fairness set true. Thread.sleep(2000); System.out.println("Available permits -> " +sem.availablePermits()); //Returns the current number of permits available in this semaphore. //NOTE: For this sem.tryAcquire() methods, enable one or two at a time as they can acquire lock Thread.sleep(2000); System.out.println("sem.tryAcquire(2) ->"+sem.tryAcquire(2)); Thread.sleep(2000); System.out.println("Available permits -> " +sem.availablePermits()); Thread.sleep(2000); System.err.println("Draining permits -> "+sem.drainPermits()); //acquires and returns all permits that are immediately available. Thread.sleep(2000); System.out.println("Available permits -> " +sem.availablePermits()); sem.release(1); SemaphoreClass thread1= new SemaphoreClass("Thread 1", sem); SemaphoreClass thread2= new SemaphoreClass("Thread 2", sem); SemaphoreClass thread3= new SemaphoreClass("Thread 3", sem); SemaphoreClass thread4= new SemaphoreClass("Thread 4", sem); SemaphoreClass thread5= new SemaphoreClass("Thread 5", sem); SemaphoreClass thread6= new SemaphoreClass("Thread 6", sem); thread1.start(); thread2.start(); thread3.start(); thread4.start(); thread5.start(); thread6.start(); } catch (InterruptedException e) { e.printStackTrace(); } } public static void semaphoreDemo() { SemaphoresExample thread1= new SemaphoresExample("Thread 1"); SemaphoresExample thread2= new SemaphoresExample("Thread 2"); SemaphoresExample thread3= new SemaphoresExample("Thread 3"); SemaphoresExample thread4= new SemaphoresExample("Thread 4"); SemaphoresExample thread5= new SemaphoresExample("Thread 5"); thread1.start(); thread2.start(); thread3.start(); thread4.start(); thread5.start(); } public static void threadPools() throws InterruptedException { //creating 5 runnable tasks Runnable r1= new ThreadPoolsExample("Task 1"); Runnable r2= new ThreadPoolsExample("Task 2"); Runnable r3= new ThreadPoolsExample("Task 3"); Runnable r4= new ThreadPoolsExample("Task 4"); Runnable r5= new ThreadPoolsExample("Task 5"); //Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue. ExecutorService pool= Executors.newFixedThreadPool(2); //At any point, at most 2 threads will be active processing tasks. //passes the task objects to the pool to execute pool.execute(r1); Thread.sleep(3145); pool.execute(r2); Thread.sleep(1678); pool.execute(r3); Thread.sleep(2234); pool.execute(r4); Thread.sleep(1456); pool.execute(r5); //Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. pool.shutdown(); } public static void producerConsumerDemo() { ProducerConsumerSolution pc= new ProducerConsumerSolution(); //Creates a thread object that calls pc.produce() Thread produce= new Thread(new Runnable() { @Override public void run() { try { pc.produce(); } catch (InterruptedException e) { e.printStackTrace(); } } }); //Creates a thread object that calls pc.consume() Thread consume= new Thread(new Runnable() { @Override public void run() { try { pc.consume(); } catch (InterruptedException e) { e.printStackTrace(); } } }); produce.start(); consume.start(); } public static void interThreadCommunication() throws InterruptedException{ PC pc= new PC(); //Creates a thread object that calls pc.produce() Thread thread1= new Thread(new Runnable() { @Override public void run() { try { pc.produce(); } catch (InterruptedException e) { e.printStackTrace(); } } }); //Creates a thread object that calls pc.consume() Thread thread2= new Thread(new Runnable() { @Override public void run() { try { pc.consume(); } catch (InterruptedException e) { e.printStackTrace(); } } }); thread1.start(); thread2.start(); } public static void threadSynchronization() { SendMessage sendSMS= new SendMessage(); ThreadedSend teacher= new ThreadedSend("Hello, Student", sendSMS); ThreadedSend student= new ThreadedSend("Hello, Teacher", sendSMS); teacher.start(); student.start(); } public static void threadPriorities() { Thread thread1= new Thread(){ @Override public void run() { for (int i= 0; i<15; i++) System.out.println("Thread 1 Iteration -> "+i); } }; Thread thread2= new Thread(){ @Override public void run() { for (int i= 0; i<15; i++) System.err.println("Thread 2 Iteration -> "+i); } }; thread1.setPriority(3); //the priority of this thread to 3 thread2.setPriority(9); //the priority of this thread to 9 thread1.start(); thread2.start(); //NOTE: Thread2 always gets executed first as it has a higher priority } public static void concurencyControl() { ConcurrencyDemo newThread= new ConcurrencyDemo(); newThread.start(); try { Thread.currentThread().join(2000); //causes the currentThread(main) to wait for 2 Secs after concurency thread starts then continues with its execution. //Thread.sleep(5000); //Causes the currently executing thread to sleep temporarily. //Thread.yield(); //control passed to childThread as it has a higher priority for (int i= 0; i<5; i++) { System.out.println(Thread.currentThread().getName() +" in Control"); } } catch (Exception e) { e.printStackTrace(); } finally { System.out.println(Thread.currentThread().getName()+" in Control"); } } public static void threadMethods() { Thread mainThread= Thread.currentThread(); //getting reference to mainThread Thread childThread= new Thread(new ChildThread()); //mainThread creating a childThread childThread.start(); //starting childThread System.out.println("Starting mainThread"); System.out.println("Current thread defaultName : " +mainThread.getName()); //getting name Main thread mainThread.setName("mainThread"); //changing the name of Main thread System.out.println("Current thread newName : " +mainThread.getName()); System.out.println("mainThread defaultPriority : " +mainThread.getPriority()); //getting priority of Main thread mainThread.setPriority(MAX_PRIORITY); //setting priority of Main thread System.out.println("mainThread newPriority : " +mainThread.getPriority()); String mainName= mainThread.getName(); try { for (int i= 0; i<5; i++) { Thread.sleep(1200); //Causes the currently executing thread to sleep temporarily. //Thread.yield(); //control passed to childThread System.out.println(mainName+" iteration-> "+i); } } catch (Exception e) { e.printStackTrace(); } finally { System.out.println("Exiting "+mainName); } } public static void threadStates() { thrState1= new Thread(new Main()); //thrState1 created and is currently in the NEW state. System.out.println("State of thrState1 after creation : " +thrState1.getState()); thrState1.start(); //Causes this thread to begin execution. The JVM calls the run() method of this thread -> in Main class //thrState1 moved to Runnable state. System.out.println("State of thrState1 after calling start() : " +thrState1.getState()); //OUTPUT: State of thrState1 after creation : NEW // State of thrState1 after calling start() : RUNNABLE // State of thrState2 after creation : NEW // State of thrState2 after calling start() : RUNNABLE // State of thrState2 after calling sleep() : TIMED_WAITING // State of thrState1 after calling join() : WAITING // State of thrState2 after ending execution: TERMINATED } public static void extendingThread() { ThreadExample thread1= new ThreadExample("Thread 1"); ThreadExample thread2= new ThreadExample("Thread 2"); thread1.start(); //Causes this thread to begin execution. The JVM calls the run() method of this thread -> in ThreadedExample class thread2.start(); //The JVM calls the run() method of this thread -> in ThreadedExample class System.err.println("Some other code going on"); } public static void implementingRunnable() { Thread thread1= new Thread(new RunnableExample("Thread 1")); Thread thread2= new Thread(new RunnableExample("Thread 2")); thread1.start(); //Causes this thread to begin execution. The JVM calls the run() method of this thread -> in RunnableExample class thread2.start(); //The JVM calls the run() method of this thread -> in RunnableExample class System.err.println("Some other code going on"); } public static void normalThreadExecution() { NormalExecution norm1= new NormalExecution("Execution 1"); NormalExecution norm2= new NormalExecution("Execution 2"); norm1.start(); norm2.start(); System.err.println("Some other code going on"); } }

Multithreading