Java Interview Questions For Two To Three Years Sense - Answered

Java Interview Questions 2 to four years experienced

If you lot are a Java programmer amongst 2 to 3 years sense of working inward Java as well as looking for labor alter as well as hence its amend to know what is expected from a 2 to 3 years experienced Java programmer inward a typical core Java or J2EE interview. Since 2 to 3 years is non a huge sense as well as you lot yet autumn nether beginner to intermediate category , its non expected from you lot to convey done profiling, Garbage collection tuning or designing complex Java applications or fifty-fifty creating concurrent Java blueprint pattern. What is expected from a 2 to four years sense guy inward Java programming is audio noesis of Java cardinal including OOPS concepts similar Abstraction, Encapsulation, Polymorphism, Composition as well as Inheritance, skillful noesis of Java collection API as well as familiarity amongst dissimilar kinds of collection e.g. List, Set as well as Map amongst some familiarity amongst pop Collection classes e.g. ArrayList, HashMap, Vector as well as HashSet etc. Fundamental noesis of Java threading API, wait-notify mechanism as well as Exception treatment inward Java is likewise something Interviewer facial expression inward a intermediate Java programmer as well as of-course some basic programming as well as coding exercise e.g. finding length of linked List inward 1 pass or reversing String inward Java etc. If you lot create do to laid upward these topics well, you lot are close probable to do good inward Java interviews on service based companies e.g. Tech Mahindra, CapeGemini, CTS, Wipro, TCS etc.

In this Java interview enquiry as well as response article nosotros volition encounter some pop as well as tricky Java question asked amongst 2 to 3 or four years experienced Java developers inward software developer interviews.

Question 1) What is deviation betwixt Vector as well as ArrayList inward Java?

Answer : One of the close pop Java enquiry at 2 years sense degree which aims to banking concern tally your noesis on Java collection API. key indicate to yell is synchronization as well as speed, since ArrayList is non synchronized its fast compare to Vector. See Vector vs ArrayList inward Java for to a greater extent than deviation betwixt both of them.

Question 2) What is deviation inward LinkedList as well as ArrayList inward Java?

Answer : If you lot don't larn previous Java enquiry as well as hence you lot are probable to larn this enquiry at 2 to 3 years sense degree Java interview. Unlike synchronization, key indicate to yell hither is underlying information structure. See LinkedList vs ArrayList inward Java for exceptional response of this coffee question.

3) What is deviation betwixt fail-fast as well as fail-safe Iterator inward Java?

This is relatively novel Java enquiry compare to previous ones but increasingly getting pop into 2 to 3 years degree Java interviews. key deviation hither is that fail-fast Iterator throw ConcurrentModificationException spell fail-safe doesn't. See fail-safe vs fail-fast Iterator inward Java for to a greater extent than differences betwixt two.

4) Difference betwixt throw as well as throws inward Java?

This Java enquiry belongs to Exception treatment category which is some other pop category for 2 to four years experienced Java programmer. Main deviation betwixt these ii is that 1 declares exception thrown past times a Java method spell other is truly used to throw Exception. See Difference betwixt throw as well as throws inward Java for total response of this Java exception treatment question.

5) What is deviation betwixt checked as well as unchecked Exception inward Java.

Another coffee interview enquiry for 2 to four years experienced Java programmer from Exception handling. key indicate to yell hither is that checked Exception requires mandatory exception treatment code spell unchecked doesn't. See  checked vs unchecked Exception inward Java for to a greater extent than differences.

6) Write code to impress Fibonacci serial inward Java?

You are leap to await some coding interview question inward Java interview for 2 to four years experience. Though Fibonacci serial is 1 of the close classical as well as pop enquiry non every Java programmer is able to do it correctly inward interview, things larn to a greater extent than complicated if interviewer inquire to do this past times using recursion. So amend to laid upward for approach, See how to write Java computer programme for Fibonacci serial using recursion for details as well as code example.

7) Write Java computer programme to opposite String inward Java without using StringBuffer?

Another Java coding interview enquiry asked on 2 ot four years experienced Java developer. Many times interviewer specifically mentioned that you lot tin non role StringBuffer because it has reverse() method which makes this taks trivial. So you lot must know how to do this past times using iteration every bit good every bit recursion to perform well. Look at Java computer programme to opposite String inward Java for total code sample as well as explanation.

8) What is deviation betwixt Runnable as well as Thread inward Java ?

Frequently asked Java interview enquiry on 2 to four years experienced degree from Threading fundamentals. in that place are ii ways to implement Thread inward Java, inward fact iii e..g extending java.lang.Thread class or implementing java.lang.Runnable or Callable interface. See Thread vs Runnable inward Java for exact differences on next each approach.

9) What happens if you lot don't telephone band hold back as well as notify from synchronized block?

Another mutual Java interview enquiry from multi-threding as well as inter thread communication. As I said before you lot must know concept of hold back as well as notify inward Java if you lot convey worked for 2 to 3 years inward Java. Check why hold back as well as notify needs to telephone band from synchronized block for exact argue to response this Java question.

10) Write code to solve producer consumer work inward Java.

A skillful coffee enquiry inward my thought which is mix of threading, synchronization, inter-thread communication as well as coding abilities. This exceptional coffee enquiry tin brand whatever body's listing at whatever day, non simply 2 to four years experienced programmer. despite existence hence mutual it has something on it which confuse average programmer as well as let you lot to differentiate betwixt skillful as well as average programmer. See Producer consumer work solving using BlockingQueue inward Java for total code example.

These were 10 oft asked Core Java interview enquiry for 2 to 3 years experienced Java programmers. If you  want to increase numbers in that place are lot many questions floating to a greater extent than or less spider web for 2 to 3 or 2 to four years experienced Java developers but key things it to recollect topics e.g. Collection, Exception handling, Coding, Threading as well as OOPS principles are the primary areas from which close of 2 to 3 years experienced Java programmer interview enquiry appear. Just larn them right as well as you lot tin cleft whatever Java interview upto 2 to four years experienced Java programmer.

Further Learning
Data Structures as well as Algorithms: Deep Dive Using Java
10 tough Java Interview Questions amongst Answer

10 Java blueprint pattern Interview enquiry amongst Answer

10 Java collection Interview questions amongst Answer

Spring MVC oft asked Question inward Interviews

5 Java Thread Interview Questions amongst Answer

How To Interruption Thread Inwards Coffee Using Sleep() Together With Timeunit Example

There are multiple ways to suspension or halt the execution of currently running thread, but putting the thread into slumber state using Thread.sleep() method is the correct means to innovate pause. Some people would say, why non usage hold back together with notify?. Using those methods only for pausing thread is non good. Those are the tools for a conditional hold back together with they don't depend on upon time. Influenza A virus subtype H5N1 thread blocked using wait() volition stay to hold back until the status on which it is waiting is changed. Yes, you lot tin seat timeout in that location but the operate of wait() method is different, they are designed for inter-thread communication inwards Java. By using sleep() method, you lot suspension the electrical flow for roughly given time. You should never usage sleep() inwards house of wait() together with notify() together with vice-versa. There is roughly other argue why to hold back together with notify should non last used to suspension the thread, a they bespeak lock. You tin solely telephone phone them from a synchronized method or block together with acquire together with unloose a lock is non cheap.

More importantly, why create you lot bespeak to innovate lock only for pausing thread? Also i of the commutation departure betwixt wait() together with sleep() method is that, Thread.sleep() puts the electrical flow thread on hold back but doesn't unloose whatever lock it is holding, but hold back does unloose the lock it holds earlier going into blocking state.

In short, multi-threading is non easy, even a uncomplicated delineate of piece of work similar creating a thread, stopping a thread or pausing a thread require a proficient cognition of Java API. You bespeak to usage the correct method at the correct place. If you lot are serious virtually mastering multi-threading together with concurrency, I would advise to read Java Concurrency inwards Practice twice together with create every illustration given on that book. That majority volition alter how you lot expect a work from multi-threading perspective.

How to suspension Thread using Sleep inwards Java

Here is our sample Java programme to suspension a running thread using Thread.sleep() together with TimeUnit.sleep() method inwards Java. In this uncomplicated program, nosotros accept 2 thread, principal thread which is started past times JVM together with executes your Java programme past times invoking the public static void main(String args[]) method. The minute thread is "T1", which nosotros accept created together with it is used to run our game loop. The Runnable delineate of piece of work nosotros passed to this thread has an infinite piece loop, which runs until stopped. If you lot expect at closely, nosotros accept used a volatile modifier to halt a thread inwards Java.

Main thread showtime starts the thread together with and thence stops it past times using stop() method inwards our Game course of written report which extends Runnable. When T1 starts it goes into a game loop together with and thence pauses for 200 milliseconds. In betwixt nosotros accept also seat the principal thread to slumber past times using TimeUnit.sleep() method. So principal thread tin hold back for roughly fourth dimension together with inwards the meantime, T1 volition resume together with finished. If you lot accept non read already together with thence you lot must read Java Concurrency inwards Practice to hit a comprehensive agreement of multithreading inwards Java.

In i example, nosotros accept learned 2 ways to suspension a thread inwards Java, past times using Thread.sleep() method together with TimeUnit.sleep() method. The declaration you lot move past times to sleep() is fourth dimension to slumber inwards a millisecond but that's non clear from code. This is where TimeUnit course of written report helps.

You acquire TimeUnit illustration for a specific fourth dimension unit of measurement e.g. TimeUnit.SECONDS or TimeUnit.MICROSECOND earlier calling slumber on it. You tin meet its much to a greater extent than clear how long a thread volition hold back now. In short, usage TimeUnit class' sleep() method to suspension a thread because it's to a greater extent than readable. To larn to a greater extent than virtually TimeUnit class, meet my post service why to prefer TimeUnit inwards Java.

Thread.sleep() together with TimeUnit Example

import static java.lang.Thread.currentThread;  import java.util.concurrent.TimeUnit;  /**  * Java Program to demonstrate how to suspension a thread inwards Java.  * There is no suspension method, but in that location are multiple means to suspension  * a thread for curt catamenia of time. Two pop means is either  * past times using Thread.sleep() method or TimeUnit.sleep() method.  *   * @author java67  */  public class ThreadPauseDemo {      public static void main(String args[]) throws InterruptedException {         Game game = new Game();          Thread t1 = new Thread(game, "T1");         t1.start();                  //Now, let's halt our Game thread         System.out.println(currentThread().getName() + " is stopping game thread");         game.stop();                  //Let's hold back to meet game thread stopped          TimeUnit.MILLISECONDS.sleep(200);                  System.out.println(currentThread().getName() + " is finished now");     } }  class Game implements Runnable{     private volatile boolean isStopped = false;          public void run() {                  while(!isStopped){             System.out.println("Game thread is running.....");                         System.out.println("Game thread is forthwith going to pause");                          try {                 Thread.sleep(200);             } catch (InterruptedException e) {                                e.printStackTrace();             }                          System.out.println("Game thread is forthwith resumed ..");         }                  System.out.println("Game thread is stopped....");     }          public void stop(){         isStopped = true;     } }  Output principal is stopping game thread Game thread is running..... Game thread is forthwith going to suspension Game thread is forthwith resumed .. Game thread is stopped.... principal is finished forthwith 

Important points virtually sleep() method :

Now you lot know how to seat a thread on slumber or pause, it's fourth dimension to know roughly technical details virtually Thread.sleep() method inwards Java.

static method together with it ever puts the electrical flow thread to sleep.

2) You tin wake-up a sleeping thread past times calling interrupt() method on the thread which is sleeping.

3) The slumber method doesn't guarantee that the thread volition slumber for precisely that many milliseconds, its accuracy depends on upon organization timers together with it's possible for a thread to woke before.

4) It doesn't unloose the lock it has acquired.


That's all virtually how to seat a thread on suspension past times using Thread.sleep() method together with TimeUnit's sleep() method. It's ameliorate to usage TimeUnit course of written report because it improves readability of code, but its also non hard to recall that declaration passed to sleep() method is inwards millisecond. Two commutation things to recall is that Thread.sleep() is a static method together with ever put the electrical flow thread to sleep, together with it doesn't unloose whatever lock held past times sleeping thread.

Further Learning
Multithreading together with Parallel Computing inwards Java
article)

What is the departure betwixt Thread together with Runnable inwards Java? (answer)

What is the departure betwixt Process together with Thread inwards Java? (answer)

Understanding the departure betwixt wait() together with sleep() inwards Thread? (answer)

What is the departure betwixt Callable together with Runnable inwards Java? (answer)

What is the departure betwixt wait() together with yield() method inwards Java? (answer)

When to usage notify() together with notifyAll() inwards Java? (answer)

What is the departure betwixt CyclicBarrier together with CountDownLatch inwards Java? (answer)

The departure betwixt yield() together with sleep() method inwards Java? (answer)

Thanks for reading this article, if you lot similar this tutorial together with thence delight portion alongside your friends together with colleagues.

10 Points Almost Wait(), Notify() In Addition To Notifyall() Inwards Coffee Thread?

If you lot enquire me i concept inwards Java which is therefore obvious yet most misunderstood, I would tell the wait(), notify() in addition to notifyAll() methods. They are quite obvious because they are the i of the 3 methods of full ix methods from java.lang.Object only if you lot enquire when to purpose the wait(), notify() in addition to notfiyAll() inwards Java, non many Java developer tin respond amongst surety. The number volition buy the farm downwards dramatically if you lot enquire them to solve the producer-consumer work using wait() in addition to notify(). Many volition purpose if block instead of piece loop, many others volition acquire confused on which object they should telephone phone wait() in addition to notify()method? Some of them fifty-fifty succeed inwards creating livelock, deadlock, in addition to other multithreading issues.

That's why it's buy the farm rattling of import to know every bit much every bit possible close these 3 methods. In this article, I am going to portion to a greater extent than or less practical tips in addition to points close wait(), notify() in addition to notifyAll() inwards Java.

Two books, which helped me a lot piece agreement this essence concept are Effective Java in addition to Core Java Volume 1 - Fundamentals past times Cay S. Horstmann. Both of them explains this confusing concept inwards uncomplicated language. The 2 items on Effective Java is the 2 of the best slice to read on this topic.

wait() vs notify() vs notifyAll inwards threading

Let's encounter to a greater extent than or less key points close these key methods inwards Java peculiarly from multi-threading in addition to concurrency perspective.

1) Though wait, notify in addition to notifyAll are related to threads they are non defined inwards java.lang.Thread class, instead they are defined inwards the Object class. If you lot are wondering why? in addition to therefore you lot should read why the wait() in addition to notify() are defined inwards Object aeroplane inwards Java.


2) You must telephone phone the wait(), notify() in addition to notifyAll() methods from a synchronized context inwards Java i.e. within synchronized method or a synchronized block. The thread must agree the lock on the object it is going to telephone phone the wait() or notify() method in addition to that is acquired when it come inwards into a synchronized context.



If you lot telephone phone it without asset a lock in addition to therefore they volition throw IllegalMonitorStateException inwards Java. If you lot are curious why is this restriction inwards house in addition to therefore banking concern stand upward for this article to acquire more.


3) You must telephone phone wait() method from within a loop, don't telephone phone amongst an if block because a thread tin sporadically awake from the expect solid soil without existence notified past times to a greater extent than or less other party. If you lot purpose if block in addition to therefore this could final result inwards a bug. You tin also encounter Item 69 of Effective Java for to a greater extent than details.

Here is the measure idiom to telephone phone the wait() method inwards Java:

synchronized (theSharedObject) {   while (condition) {    theSharedObject.wait();    }  // hit something }

4) When a thread calls the wait() method inwards Java, it goes to the expect solid soil past times releasing the lock, which is later acquired past times the other thread who tin notify this thread. Here is a dainty diagram of how solid soil transition of a thread happens inwards Java:

5) Influenza A virus subtype H5N1 thread waiting due to a telephone phone to wait() method tin wake upward either past times notification e.g. calling notify() or notifyAll() method on the same object or due to interruption.


6) The wait() method throws InterrruptedException inwards Java, which is a checked exception. You must supply a handler for this, only it's your alternative whether you lot actually desire to grip the intermission or not.


7) You must telephone phone wait() method on shared object e.g. in producer-consumer problem, the delineate of piece of work queue is shared betwixt producer in addition to the consumer thread. In lodge to communicate, you lot must purpose that queue on synchronized block in addition to later on called wait() method on queue e.g. queue.wait().

The other thread should also telephone phone the notify() or notifyAll() method on same shared object i.e. queue.notify() or queue.notifyAll(). You tin also encounter my post service how to hit inter-thread communication inwards Java for to a greater extent than details.

notify() method on a shared object in addition to if to a greater extent than than i thread is waiting on that lock in addition to therefore anyone of them volition acquire the notification, which thread volition acquire the notification is non guaranteed. If exclusively i thread is waiting in addition to therefore it volition acquire the notification.


9) When you lot telephone phone the notifyAll() method on shared object in addition to if to a greater extent than than i thread is waiting for notification in addition to therefore all of them volition have the notification only who volition acquire the CPU to starting fourth dimension execution is non guaranteed. It depends on upon thread scheduler. Which agency it's possible for a thread to acquire the notification, only it mightiness buy the farm to the expect solid soil i time to a greater extent than if the status for expect nevertheless holds true, mainly due to other thread's processing.

For example, suppose five people are waiting for nutrient in addition to they all listen the notification that nutrient has arrived, only exclusively of them goes past times the door in addition to eat food. When side past times side people's gamble come upward to buy the farm past times the door nutrient is already finished therefore it goes to the expect solid soil again. See Core Java Volume 1 - Fundamentals by Cay S. Horstmann to acquire to a greater extent than close notify() in addition to notifyAll() inwards Java.

10) Main departure betwixt notify() in addition to notifyAll() is that inwards instance of notify() exclusively i of the waiting thread gets a notification only inwards instance of notifyAll() all thread acquire notification. You tin also read the existent difference betwixt notify() in addition to notifyAll() to acquire more


That's all close wait(), notify() in addition to notifyAll() methods inwards Java. These are 3 of the most of import methods every Java developer should know. It's key to implement inter-thread communication inwards Java. You should endeavor writing code using wait() in addition to notify() method past times mitt or past times using notepad to acquire the concept better.

You an also hit dyad of exercises to acquire the concept of expect in addition to notify meliorate e.g. implementing a bounded buffer inwards Java or solving the famous producer consumer work using expect notify inwards Java, every bit shown here.

Further Learning
Complete Java Masterclass
Multithreading in addition to Parallel Computing inwards Java
Applying Concurrency in addition to Multi-threading to Common Java Patterns
Java Concurrency inwards Practice Bundle past times Heinz Kabutz

What Is Deviation Betwixt Thread Vs Procedure Inwards Java

Thread as well as Process are 2 closely related term inward multi-threading as well as principal departure betwixt Thread as well as Process inward Java is that Threads are business office of process. i.e. i procedure tin spawn multiple Threads. If you lot run a Java plan inward UNIX based organisation e.g. Linux as well as if that plan creates 10 Threads, it nevertheless i procedure as well as you lot tin notice that yesteryear using ps -ef | grep identifier ascendency which is i of most popular purpose of grep ascendency inward UNIX, Where identifier is unix text which tin hold upwardly used equally regular expression to notice that Java process. Another major departure betwixt Process as well as Thread is that, each procedure has its ain dissever retentivity infinite but Threads from same procedure same retentivity space. Some linux ascendency map Java thread alongside light weight process or lwp, e.g. if you lot purpose prstat ascendency inward Solaris, you lot tin teach how many calorie-free weight procedure or Thread a detail Java plan is using.

Process vs Thread inward Java

In this department nosotros volition encounter to a greater extent than or less to a greater extent than differences betwixt Process vs Thread inward Java to teach a clear thought almost What is procedure as well as What is Thread inward Java :

1) Both procedure as well as Thread are independent path of execution but i procedure tin accept multiple Threads.

2) Every procedure has its ain retentivity space, executable code as well as a unique procedure identifier (PID) piece every thread has its ain stack inward Java but it uses procedure principal retentivity as well as percentage it alongside other threads.

3) Threads are equally good refereed equally chore or light weight procedure (LWP) inward operating system

4) Threads from same procedure tin communicate alongside each other yesteryear using Programming linguistic communication laid similar wait as well as notify inward Java as well as much simpler than inter procedure communication.

5) Another departure betwixt Process as well as Thread inward Java is that it's How Thread as well as procedure are created. It's slow to practice Thread equally compared to Process which requires duplication of bring upwardly process.

6) All Threads which is business office of same procedure percentage organisation resources similar file descriptors , Heap Memory as well as other resources but each Thread has its ain Exception handler as well as ain stack inward Java.

There were to a greater extent than or less of the key departure betwixt Process as well as Thread inward Java. Whenever you lot beak almost Process vs Thread, simply give-up the ghost on inward heed that i procedure tin spawn multiple Thread as well as percentage same retentivity inward Java. Each thread has its ain stack.

Further Learning
Multithreading as well as Parallel Computing inward Java
15 tough Thread Interview Question inward Java

What is race status inward Java alongside example

How to forestall deadlock inward Java alongside example

What is thread-safety inward Java ? How to write thread-safe code inward Java

Difference betwixt Runnable as well as Thread inward Java

How to halt Thread inward Java alongside Example

When Together With How To Role The Wait() Together With Notify(), Nofityall() Methods Inwards Java? - Example Tutorial

When should you lot purpose the wait() together with notify method inwards Java is i of the many pop questions close the hold off together with notify methods from Java multithreading interview questions. One of the reasons for its popularity is that yet a lot of Java programmer combat to explicate together with write code using wait-notify methods.  Many Java developer solely knows around facts close the hold off together with notify methods similar that wait() together with notify() are defined inwards the java.lang.Object course of written report or you lot cannot telephone outcry upwards wait() without synchronization, agency without a synchronized block or synchronized method but doesn't actually know when together with how to purpose them.

In this article, nosotros volition endeavour to pair that gap past times going through a elementary event of classical Producer-Consumer Problem together with present you lot how you lot tin purpose them patch writing concurrent Java applications for the existent world.

First together with firstly you lot should know that wait(), notify(), together with notifyAll() are tools for inter-thread communication inwards Java. By using this method, you lot tin say a thread to halt working together with afterwards offset processing.

They are the essential edifice block of Java multi-threading applications. In the existent world, you lot tin purpose the wait() together with notify() method to implement a producer-consumer designing where most of the multi-threaded application falls. If you lot don't know much close them, I propose you lot bring together a key course of written report on Java threads like Threading Essentials Mini-Course past times Java Champion, Heinz Kabutz.

How to purpose the wait() together with notify() methods inwards Java

You tin purpose wait() together with notify() method to communicate betwixt multiple threads, for example, you lot tin say i thread to halt working from around other thread based upon around condition, afterwards you lot tin notify it to offset processing again.

One of the pop event of wait() together with notify() method is to solve the producer-consumer problem, where you lot tin accept either unmarried producer together with unmarried consumer or multiple producers together with unmarried consumer or only i producer together with multiple consumers.

In this example, you lot volition larn how to implement multiple producers together with unmarried consumer solutions using wait() together with notify() inwards Java. If you lot are non familiar alongside notify together with notifyAll method, you lot tin farther see The Complete Java Masterclass to larn more.

Wait-Notify Example To Solve Producer-Consumer Problem 

package tool;   import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.TimeUnit;   /**  * Influenza A virus subtype H5N1 elementary Java Program to demonstrate how to purpose hold off  * together with notify() method ofr inter-thread communciation  * inwards Java.   */   public class Hello {     public static void main(String[] args) {     Queue<String> q = new LinkedList<>();     boolean exit = false;     Producer p = new Producer(q, exit);     p.start();     Consumer c = new Consumer(q, exit);     c.start();     }   }   class Producer extends Thread {   private volatile Queue<String> sharedQueue;   private volatile boolean bExit;     public Producer(Queue<String> myQueue, boolean bExit) {     this.sharedQueue = myQueue;     this.bExit = bExit;   }     public void run() {     while (!bExit) {       synchronized (sharedQueue) {         while (sharedQueue.isEmpty()) {           String detail = String.valueOf(System.nanoTime());           sharedQueue.add(item);           System.out.println("Producer added : " + item);           try {             System.out.println("Producer sleeping past times calling wait: " + item);             sharedQueue.wait();             System.out.println("Producer wake up: ");           } catch (InterruptedException e) {             e.printStackTrace();           }         }       }     }   } }   class Consumer extends Thread {   private volatile Queue<String> sharedQueue;   private volatile boolean bExit;     public Consumer(Queue<String> myQueue, boolean bExit) {     this.sharedQueue = myQueue;     this.bExit = bExit;   }     public void run() {       while (!bExit) {         synchronized (sharedQueue) {         while (!sharedQueue.isEmpty()) {           String detail = sharedQueue.poll();           System.out.println("Consumer removed : " + item);           System.out.println("Consumer notifying Producer: " + item);           sharedQueue.notify();         }       }     }   } }   Output: Producer added : 12275948008616 Producer sleeping past times calling wait: 12275948008616 Consumer removed : 12275948008616 Consumer notifying Producer: 12275948008616 Producer wake up:  Producer added : 12275948047960 Producer sleeping past times calling wait: 12275948047960 Consumer removed : 12275948047960 Consumer notifying Producer: 12275948047960 Producer wake up:  Producer added : 12275948082600 Producer sleeping past times calling wait: 12275948082600 Consumer removed : 12275948082600 Consumer notifying Producer: 12275948082600

What's Happening Here?

Producer thread is producing items, adding them into a queue together with thence going into wait() acre until consumer thread consumes it. When Consumer thread removes the items from the queue, it also notifies the Producer thread to offset producing again. 

That's why you lot meet an ordered output similar Producer added, Producer Sleeping, Consumer Removed, Consumer Notified, together with Producer Wakeup. In short, both Producer together with Consumer Thread are talking alongside each other using hold off together with notify method. 

If you lot take that hold off telephone outcry upwards thence the Producer thread volition expire on checking for the queue to expire waiting together with expire on wasting the CPU cycle. 

Similarly, if you lot take the notify telephone outcry upwards thence waiting Producer thread may never wake up.  Btw, if you lot accept problem agreement Producer-Consumer Problem thence I also propose taking a hold off at  the 

here to larn why

2) Always banking concern check the waiting status inwards a loop instead of if block inwards Java, meet here to larn why.

3) Remember, you lot tin wake upwards a waiting thread past times using interrupt() method but solely if your waiting thread handles the interrupted exception.

4) Prefer notifyAll() over notify() if you lot are inwards doubt, meet here to larn more.

5) Don't forget to telephone outcry upwards the wait() together with notify() method on the same shared object.


That's all close when to purpose the hold off together with notify method inwards Java. It's a perfect together with most native tool for inter-thread communication inwards Java. Influenza A virus subtype H5N1 proficient agreement of wait, notify, together with the notifyAll method goes a long way inwards writing a robust together with condom concurrent Java program. If you lot accept whatever problem agreement this problem, delight drib a Federal Reserve notation together with I'll endeavour to explain.

Further Learning
The Complete Java Masterclass
50+ Java Multithreading Interview Questions inwards Java
How to avoid deadlock inwards Java programs
Top v Courses to Learn Multithreading and Concurrency inwards Java
Multithreading together with Parallel Computing inwards Java


Thanks for reading this article thence far. If you lot similar this article thence delight part alongside your friends together with colleagues. If you lot accept whatever questions or feedback, delight drib a note. 

Java Countdownlatch Representative - Multithreading Together With Concurrency Tutorial For Beginners

The CountDownLatch is an of import concurrency utility degree which was added inwards JDK 1.5 but unfortunately, many Java developers all the same scrap to empathize together with utilisation this powerful tool. You tin dismiss utilisation CountDownLatch if yous are spawning multiple threads to produce dissimilar jobs together with desire to know when just all tasks are finished so that yous tin dismiss motion to the adjacent stage. In other words, yous tin dismiss block a thread until other threads consummate their task. One of the skilful examples where yous tin dismiss utilisation CountDownLatch is an application which downloads information from a database or roughly other application. For example, nosotros are creating a Java plan to download all Udemy courses. Since Udemy has thousands of courses, yous create dissimilar threads to download dissimilar categories e.g. technology, development, etc.

Your application tin dismiss entirely endure started in ane lawsuit all information is loaded together with to know the condition of your loading progress yous tin dismiss create a CountDownLatch.

Suppose, yous conduct maintain created 5 threads to charge v dissimilar categories of information thus yous tin dismiss create a CountDownLatch amongst 5 counts together with thus convey downwards the count past times 1 when loading of ane category is finished. You tin dismiss produce this past times calling the countDown() method.

Since dissimilar thread volition select dissimilar time, your original thread tin dismiss wait until all threads conduct maintain completed together with it tin dismiss produce past times checking the remaining count past times calling getCount() method or simply calling the CountDownLatch.await() method, which causes electrical flow thread to hold off until the latch has counted downwards to zero or the thread is interrupted.

Once the count becomes zero, it tin dismiss denote that the application is started together with create to conduct maintain customer connections. So, yous tin dismiss run into how useful CountDownLatch tin dismiss endure inwards this variety of scenarios.

There are many other concurrency utilities inwards JDK which volition assist yous to write sophisticated Java application but If yous are novel to Java together with scrap agreement multi-threading together with concurrency concepts similar this, yous tin dismiss give-up the ghost through a comprehensive course of report like  Complete Java Masterclass to acquire them better.

1. CountDownLatch Example inwards Java

Here is a simplified version of Java Code for the higher upward scenario which demonstrates downloading information inwards multiple threads together with using CountDownLatch to cheque completion.

package tool;  import java.util.concurrent.CountDownLatch;  /**  *   * Influenza A virus subtype H5N1 uncomplicated instance of CountDownLatch inwards Java  */ public class CountDownLatchDemo {    private static terminal CountDownLatch loadingLatch = new CountDownLatch(3);    public static void main(String args[]) {      Thread pythonCourseLoader = new Thread("PythonCourseLoader") {        @Override       public void run() {         System.out.println("Loading all Python courses from Udemy..");         // loading Python courses ....         // loading completed, fourth dimension to count down         System.out.println("loading completed for Python courses");         loadingLatch.countDown();       }     };      Thread javaCourseLoader = new Thread("JavaCourseLoader") {       @Override       public void run() {         System.out.println("Loading all Java courses from Udemy ..");         // loading Java courses ....         try {           Thread.sleep(1000);         } catch (InterruptedException e) {           // TODO Auto-generated grab block           e.printStackTrace();         }         System.out.println("loading completed for Java courses");         loadingLatch.countDown();       }     };      Thread developmentCourseLoader = new Thread("developmentCourseLoader") {       @Override       public void run() {         System.out.println("Loading all Develoment courses from Udemy ..");         // loading evolution courses ....         try {           Thread.sleep(2000);         } catch (InterruptedException e) {           // TODO Auto-generated grab block           e.printStackTrace();         }          System.out.println("loading completed for evolution courses");         loadingLatch.countDown();       }     };      pythonCourseLoader.start();     javaCourseLoader.start();     developmentCourseLoader.start();      while (loadingLatch.getCount() != 0) {       // wait     }      // loadingLatch.await();      System.out.println("all done.");   } }  Output: Loading all Python courses from Udemy.. loading completed for Python courses Loading all Development courses from Udemy .. Loading all Java courses from Udemy .. loading completed for Java courses loading completed for evolution courses all done. 

In this program, nosotros conduct maintain simply iii threads. One to download all Python courses, minute to download all Java courses together with the 3rd ane to download all Development courses.

I conduct maintain created a CountDownLatch object amongst 3 counts equally a static terminal variable:

CountDownLatch loadingLatch = new CountDownLatch(3);

After that, nosotros conduct maintain iii threads, which downloads data, inwards our instance they don't produce anything simply sleep for 1, 2, together with 3 seconds.

Every fourth dimension a thread completes its execution it calls the countDown() method on the loadingLatch object.

The main() method give-up the ghost along checking for remaining counts using getCount() method together with produce whatever it wants to produce entirely when the count reaches zero. Though I conduct maintain used a spell loop amongst getCount(), yous tin dismiss ameliorate utilisation latch.await() method for waiting.

Influenza A virus subtype H5N1 movie is said to endure worth a chiliad words, thus I tried to brand this diagram to explicate the concept to you. In this diagram yous tin dismiss run into that our original thread is waiting on CoutnDownLatch until all thread calls the countdown together with count reaches zero, after that, it progressed further.

In short, the original thread was blocked waiting for other loader thread to destination their job.

Btw, If yous are non familiar amongst essential threading concepts similar wait, notify, sleep, blocking, etc, I advise yous get-go give-up the ghost through Complete Java Masterclass to acquire them.

2. CountDownLatch - Important Points

Now that yous know what is CountDownLatch inwards Java together with how to utilisation it for inter-thread communication together with synchronization. It's fourth dimension to revise together with hollo back roughly of import points:

1. The CountDownLatch utility or degree is entirely available on JRE 1.5 or afterwards version.

2. You cannot reuse the latch in ane lawsuit the count reaches zero. This is the original deviation betwixt a CyclicBarrier together with CountDownLatch, which tin dismiss endure reused.

3. The getCount() method provide the electrical flow count i.e. remaining threads which conduct maintain non finished yet.

4. Influenza A virus subtype H5N1 thread tin dismiss hold off on latch past times calling latch.await() method to start progress after remaining thread finishes their task. Btw, if yous are novel to threading together with concurrency together with don't empathize what is waiting for way inwards the context of a thread, I advise yous give-up the ghost through Threading Essentials a  Mini-Course past times Java Champion Heinz Kabutz.

5. One of the simplest utilisation of CountDownLatch class is to block a thread until other threads conduct maintain finished their jobs.

In our example, it was the original thread which was blocked past times calling the await() method of CountDownLatch until all loader degree finished their undertaking i.e. downloaded courses from Udemy.


That's all almost how to utilisation CountDownLatch inwards Java. It's a useful concurrency utility which tin dismiss endure used to give-up the ghost along rails of completion of tasks done past times multiple threads. If yous are writing a Java application which loads information from roughly other organisation earlier start performance e.g. accepting customer connections, yous tin dismiss utilisation CountDownLatch to give-up the ghost along rails of download tasks.


Further Learning

1. Complete Java Masterclass
2. Multithreading together with Parallel Computing inwards Java
3. CountDownLatch Java Documentation

Thanks a lot for reading this article thus far. If yous similar this CountDownLatch instance thus delight percentage amongst your friends together with colleagues. If yous conduct maintain whatever questions or feedback thus delight driblet a note.