The only guide you’ll need on concurrency & multithreading for senior engineers. Pressure test your skills with real-world practice problems from top companies.

Concurrency in Java is one of the most complex and advanced topics brought up during senior engineering interviews. Knowledge of concurrency and multithreading can put interviewees at a considerable advantage. This course lays the foundations of advanced concurrency and multithreading and explains concepts such as Monitors and Deferred Callbacks in depth. It also builds simple and complete solutions to popular concurrency problems that can be asked about in interviews like the Reader-Writer Problem and the Dining Philosopher Problem. While prior knowledge of concurrency is not required to follow through with this course, familiarity with the very basics of concurrency would be helpful.

Java Multithreading for Senior Engineering Interviews

## Thread Pools
Thread pools in Java are implementations of the <code class= "intf">Executor</code> interface or any of its sub-interfaces. Thread pools allow us to decouple task submission and execution. We have the option of exposing an executor's configuration while deploying an application or switching one executor for another seamlessly.

>A thread pool consists of homogenous worker threads that are assigned to execute tasks. Once a worker thread finishes a task, it is returned to the pool. Usually, thread pools are bound to a queue from which tasks are dequeued for execution by worker threads. 

A thread pool can be tuned for the size of the threads it holds. A thread pool may also replace a thread if it dies of an unexpected exception. Using a thread pool immediately alleviates from the ails of manual creation of threads.
<ul>
<li>There's no latency when a request is received and processed by a thread because no time is lost in creating a thread.</li>
<li>The system will not go out of memory because threads are not created without any limits</li>
<li>Fine tuning the thread pool will allow us to control the throughput of the system. We can have enough threads to keep all processors busy but not so many as to overwhelm the system.</li>
<li>The application will degrade gracefully if the system is under load.</li>
</ul>

Below is the updated version of the stock order method using a thread pool. 



```java
 void receiveAndExecuteClientOrdersBest() {

 int expectedConcurrentOrders = 100;
 Executor executor = Executors.newFixedThreadPool(expectedConcurrentOrders);

 while (true) {
 final Order order = waitForNextOrder();

 executor.execute(new Runnable() {

 public void run() {
 order.execute();
 }
 });
 }
 }
```

In the above code we have used the factory method exposed by the <code class="clazz">Executors</code> class to get an instance of a thread pool. We discuss the different type of thread pools available in Java in the next section.

# Thread Pools
Thread pools in Java are implementations of the <code class= "intf">Executor</code> interface or any of its sub-interfaces. Thread pools allow us to decouple task submission and execution. We have the option of exposing an executor's configuration while deploying an application or switching one executor for another seamlessly.

>A thread pool consists of homogenous worker threads that are assigned to execute tasks. Once a worker thread finishes a task, it is returned to the pool. Usually, thread pools are bound to a queue from which tasks are dequeued for execution by worker threads. 

A thread pool can be tuned for the size of the threads it holds. A thread pool may also replace a thread if it dies of an unexpected exception. Using a thread pool immediately alleviates from the ails of manual creation of threads.
<ul>
<li>There's no latency when a request is received and processed by a thread because no time is lost in creating a thread.</li>
<li>The system will not go out of memory because threads are not created without any limits</li>
<li>Fine tuning the thread pool will allow us to control the throughput of the system. We can have enough threads to keep all processors busy but not so many as to overwhelm the system.</li>
<li>The application will degrade gracefully if the system is under load.</li>
</ul>

Below is the updated version of the stock order method using a thread pool. 



```java
 void receiveAndExecuteClientOrdersBest() {

 int expectedConcurrentOrders = 100;
 Executor executor = Executors.newFixedThreadPool(expectedConcurrentOrders);

 while (true) {
 final Order order = waitForNextOrder();

 executor.execute(new Runnable() {

 public void run() {
 order.execute();
 }
 });
 }
 }
```

In the above code we have used the factory method exposed by the <code class="clazz">Executors</code> class to get an instance of a thread pool. We discuss the different type of thread pools available in Java in the next section.

# Thread Pools
Thread pools in Java are implementations of the <code>Executor</code> interface or any of its sub-interfaces. Thread pools allow us to decouple task submission and execution. We have the option of exposing an executor's configuration while deploying an application or switching one executor for another seamlessly.

>A thread pool consists of homogenous worker threads that are assigned to execute tasks. Once a worker thread finishes a task, it is returned to the pool. Usually, thread pools are bound to a queue from which tasks are dequeued for execution by worker threads. 

A thread pool can be tuned for the size of the threads it holds. A thread pool may also replace a thread if it dies of an unexpected exception. Using a thread pool immediately alleviates from the ails of manual creation of threads.
<ul>
<li>There's no latency when a request is received and processed by a thread because no time is lost in creating a thread.</li>
<li>The system will not go out of memory because threads are not created without any limits</li>
<li>Fine tuning the thread pool will allow us to control the throughput of the system. We can have enough threads to keep all processors busy but not so many as to overwhelm the system.</li>
<li>The application will degrade gracefully if the system is under load.</li>
</ul>

Below is the updated version of the stock order method using a thread pool. 



```java
 void receiveAndExecuteClientOrdersBest() {

 int expectedConcurrentOrders = 100;
 Executor executor = Executors.newFixedThreadPool(expectedConcurrentOrders);

 while (true) {
 final Order order = waitForNextOrder();

 executor.execute(new Runnable() {

 public void run() {
 order.execute();
 }
 });
 }
 }
```

In the above code we have used the factory method exposed by the <code>Executors</code> class to get an instance of a thread pool. We discuss the different type of thread pools available in Java in the next section.

This lesson introduces thread pools and their utility in concurrent programming.

The Basics

Multithreading in Java

Java's Memory Model

Interview Practice Problems

Bonus Questions

Beyond the Interview

Java Concurrency Reference

Revision & Quizzes

Thread Pools

Thread Pools