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

# Solution using a background thread

The previous solution consisted of manipulating pointers in time, thus avoiding threads altogether. Another solution is to use threads to solve the token bucket filter problem. We instantiate one thread to add a token to the bucket after every one second. The user thread invokes the <code class="mthd">getToken()</code> method and is granted one if available. 

One simplification as a result of using threads is we now only need to remember the current number of tokens held by the token bucket filter object. We'll add an additional method <code class="mthd">daemonThread()</code> that will be executed by the thread that adds a token every second to the bucket. The skeleton of our class looks as follows:

```java
public class MultithreadedTokenBucketFilter {
 private long possibleTokens = 0;
 private final int MAX_TOKENS;
 private final int ONE_SECOND = 1000;

 public MultithreadedTokenBucketFilter(int maxTokens) {

 MAX_TOKENS = maxTokens;
 }

 private void daemonThread() {
 }

 void getToken() throws InterruptedException
 {
 }
}

```
 
The logic of the daemon thread is simple. It sleeps for one second, wakes up, checks if the number of tokens in the bucket is less than the maximum allowed tokens, if yes increments the <code class="mthd">possibleTokens</code> variable and if not goes back to sleep for a second again.

The implementation of the <code class="mthd">getToken()</code> is even simpler. The user thread checks if the number of tokens is greater than zero, if yes it simulates taking away a token by decrementing the variable <code class="mthd">possibleTokens</code>. If the number of available tokens is zero then the user thread must wait and be notified only when the daemon thread has added a token. We can use the current token bucket object <code class="clazz">this</code> to wait and notify. The implementation of the <code class="mthd">getToken()</code> method is shown below:

```java
 void getToken() throws InterruptedException {

 synchronized (this) {
 while (possibleTokens == 0) {
 this.wait();
 }
 possibleTokens--;
 }

 System.out.println(
 "Granting " + Thread.currentThread().getName() + " token at " + System.currentTimeMillis() / 1000);
 }
```

Note that we are manipulating the shared mutable object <code class="mthd">possibleTokens</code> in a synchronized block. Additionally, we <code class="mthd">wait()</code> when the number of tokens is zero. The implementation of the daemon thread is given below. It runs in a perpetual loop.

```java
 private void daemonThread() {

 while (true) {
 synchronized (this) {
 if (possibleTokens < MAX_TOKENS) {
 possibleTokens++;
 }
 this.notify();
 }
 try {
 Thread.sleep(ONE_SECOND);
 } catch (InterruptedException ie) {
 // swallow exception
 }
 }
 }
```

The complete implementation along with a test-case appears in the code widget below:

</div>

# Solution using a background thread

The previous solution consisted of manipulating pointers in time, thus avoiding threads altogether. Another solution is to use threads to solve the token bucket filter problem. We instantiate one thread to add a token to the bucket after every one second. The user thread invokes the <code>getToken()</code> method and is granted one if available. 

One simplification as a result of using threads is we now only need to remember the current number of tokens held by the token bucket filter object. We'll add an additional method <code>daemonThread()</code> that will be executed by the thread that adds a token every second to the bucket. The skeleton of our class looks as follows:

```java
public class MultithreadedTokenBucketFilter {
 private long possibleTokens = 0;
 private final int MAX_TOKENS;
 private final int ONE_SECOND = 1000;

 public MultithreadedTokenBucketFilter(int maxTokens) {

 MAX_TOKENS = maxTokens;
 }

 private void daemonThread() {
 }

 void getToken() throws InterruptedException
 {
 }
}

```
 
The logic of the daemon thread is simple. It sleeps for one second, wakes up, checks if the number of tokens in the bucket is less than the maximum allowed tokens, if yes increments the <code>possibleTokens</code> variable and if not goes back to sleep for a second again.

The implementation of the <code>getToken()</code> is even simpler. The user thread checks if the number of tokens is greater than zero, if yes it simulates taking away a token by decrementing the variable <code>possibleTokens</code>. If the number of available tokens is zero then the user thread must wait and be notified only when the daemon thread has added a token. We can use the current token bucket object <code>this</code> to wait and notify. The implementation of the <code>getToken()</code> method is shown below:

```java
 void getToken() throws InterruptedException {

 synchronized (this) {
 while (possibleTokens == 0) {
 this.wait();
 }
 possibleTokens--;
 }

 System.out.println(
 "Granting " + Thread.currentThread().getName() + " token at " + System.currentTimeMillis() / 1000);
 }
```

Note that we are manipulating the shared mutable object <code>possibleTokens</code> in a synchronized block. Additionally, we <code>wait()</code> when the number of tokens is zero. The implementation of the daemon thread is given below. It runs in a perpetual loop.

```java
 private void daemonThread() {

 while (true) {
 synchronized (this) {
 if (possibleTokens < MAX_TOKENS) {
 possibleTokens++;
 }
 this.notify();
 }
 try {
 Thread.sleep(ONE_SECOND);
 } catch (InterruptedException ie) {
 // swallow exception
 }
 }
 }
```

The complete implementation along with a test-case appears in the code widget below:

</div>

This lesson explains how to solve the token bucket filter problem using threads.

The Basics

Multithreading in Java

Java's Memory Model

Interview Practice Problems

Bonus Questions

Beyond the Interview

Java Concurrency Reference

Revision & Quizzes

... continued

Solution using a background thread