This tutorial is part of Springing into Action: A Spring Boot Journey from Novice to Pro Series, be sure to check it out for more related content!

Java is a powerful and versatile programming language, and one of its most powerful features is its support for multithreading. Multithreading allows a program to run multiple threads in parallel, which can greatly improve the performance and responsiveness of a program. In this article, we will take a comprehensive look at threads in Java 8+ and see how they can be used to improve the performance of a program.

What are Threads?

A thread is a lightweight, independent unit of execution. It is a separate flow of control that runs in parallel with the main program. Each thread has its own stack, program counter, and local variables, which allows it to run independently of other threads. In Java, threads are implemented using the Thread class and the Runnable interface.

A Thread is a class in the Java standard library that represents a single thread of execution. A Thread object can be created and started using the start() method. A Runnable is an interface that defines a single method, run(), which is used to define the code that will be executed by the thread.

public class MyThread implements Runnable {
    public void run() {
        // Code to be executed by the thread
    }
}

Thread thread = new Thread(new MyThread());
thread.start();

Thread States

A thread can be in one of several states, including:

NEW: The thread has been created but has not yet been started.
RUNNABLE: The thread is running or is able to run.
BLOCKED: The thread is blocked and is waiting for a lock or other resource.
WAITING: The thread is waiting for another thread to perform a specific action.
TIMED_WAITING: The thread is waiting for a specific amount of time.
TERMINATED: The thread has completed execution.

A thread's state can be accessed using the getState() method of the Thread class.

Thread Priorities

In Java, threads can be assigned a priority, which determines the order in which they are executed. The Thread class defines several constants for the different priority levels, including MIN_PRIORITY, NORM_PRIORITY, and MAX_PRIORITY. The default priority for a new thread is NORM_PRIORITY.

Thread thread = new Thread(new MyThread());
thread.setPriority(Thread.MIN_PRIORITY);
thread.start();

It's important to note that setting a thread's priority does not guarantee that it will be executed before other threads with lower priorities. The actual order in which threads are executed depends on the underlying operating system and the JVM's thread scheduler.

Synchronization

Synchronization is a mechanism that allows multiple threads to access shared resources in a controlled manner. In Java, synchronization is achieved through the use of the synchronized keyword and the Lock and Condition interfaces.

Synchronized Methods

A synchronized method is a method that can only be executed by one thread at a time. To make a method synchronized, the synchronized keyword is used before the method's return type.

public class MyThread implements Runnable {
    public synchronized void run() {
// Code to be executed by the thread
}
}

When a thread enters a synchronized method, it acquires the lock for the object that the method belongs to. This means that no other thread can enter any synchronized method of that object until the first thread has exited the method and released the lock.

Synchronized Blocks

In addition to synchronized methods, Java also supports synchronized blocks. A synchronized block is a block of code that can only be executed by one thread at a time. To create a synchronized block, the synchronized keyword is used followed by the object that the block will synchronize on.

This can be useful when you only need to synchronize a specific section of code rather than an entire method. For example:

public class MyThread implements Runnable {
    public void run() {
        synchronized(this) {
            // Code to be executed by the thread
        }
    }
}

In the above example, we've created a synchronized block that synchronizes on the this object. This means that only one thread can execute the code inside the block at a time.

Volatile Variables

Another way to control the visibility of variables between threads is by using the volatile keyword. A variable that is declared as volatile will have its value immediately visible to all other threads. This can be useful when multiple threads need to read and write to the same variable.

public class MyThread implements Runnable {
    private volatile boolean running = true;
    public void run() {
        while(running) {
            // Code to be executed by the thread
        }
    }
    public void stop() {
        running = false;
    }
}

In the above example, we've created a volatile variable named running. This variable is used to control the execution of the run() method. When the stop() method is called, it sets the value of running to false, causing the thread to exit the while loop and end execution.

Thread Pools

Creating and managing threads can be a time-consuming and resource-intensive task. To help with this, Java provides a thread pooling mechanism through the Executor framework. A thread pool is a group of pre-initialized, reusable threads that can be used to execute multiple tasks simultaneously.

The Executor interface provides the execute() method for submitting tasks to be executed by a thread in the pool. The Executors class provides several methods for creating and managing thread pools, such as newFixedThreadPool() and newCachedThreadPool().

Executor executor = Executors.newFixedThreadPool(10);
executor.execute(new MyThread());

In the above example, we've created a fixed thread pool with a maximum of 10 threads. We then submit a task (an instance of MyThread) to be executed by a thread in the pool.

Multithreading Issues

As we have seen, threading is a powerful feature that can greatly improve the performance and responsiveness of your applications. However, multithreading can also introduce new challenges, such as race conditions, deadlocks, and thread safety, that must be handled with proper care. In this section, we will delve deeper into these topics and explore solutions, best practices, and code examples for handling these challenges.

Race Conditions

A race condition occurs when multiple threads access shared resources simultaneously and the outcome of the program depends on the order in which the threads execute. This can lead to unexpected and unpredictable behavior, such as data corruption or incorrect results.

One common solution to race conditions is to use synchronization to control access to shared resources. The synchronized keyword can be used to create a critical section of code that can only be executed by one thread at a time. This ensures that only one thread can access the shared resource at a time, eliminating the possibility of a race condition.

public class MyThread implements Runnable {
    private List<Integer> sharedList = new ArrayList<>();

    public void run() {
        synchronized(sharedList) {
            // Access shared resource
            sharedList.add(Thread.currentThread().getId());
        }
    }
}

In the above example, we've created a synchronized block that synchronizes on the sharedList object. This means that only one thread can execute the code inside the block at a time, ensuring that the sharedList is not accessed simultaneously by multiple threads.

Another solution to race conditions is the use of the Atomic classes provided by the java.util.concurrent.atomic package. These classes provide a way to perform atomic operations on variables, such as incrementing or decrementing a value, without the need for explicit synchronization.

AtomicInteger atomicInt = new AtomicInteger();

public void increment() {
    atomicInt.incrementAndGet();
}

In the above example, we've created an AtomicInteger and we can increment it's value using incrementAndGet method which is an atomic operation that is guaranteed to be thread-safe.

Deadlocks

A deadlock occurs when two or more threads are blocked, waiting for each other to release a resource. This results in the threads being unable to proceed, effectively locking the program.

One solution to deadlocks is to use a Lock object instead of the synchronized keyword. A Lock object provides more fine-grained control over thread synchronization and also provides a way to detect and recover from deadlocks.

public class MyThread implements Runnable {
    private Lock lock1 = new ReentrantLock();
    private Lock lock2 = new ReentrantLock();

    public void run() {
        lock1.lock();
        try {
            // Access shared resource
            lock2.lock();
            try {
                // Access shared resource
            } finally {
                lock2.unlock();
            }
        } finally {
            lock1.unlock();
        }
    }
}

In the above example, we've created two Lock objects and used them to control access to the shared resources. By using the try-finally pattern, we ensure that the locks are always released, even if an exception is thrown. This helps to prevent deadlocks caused by threads holding on to resources indefinitely.

Another solution to deadlocks is to use the Lock.tryLock() method, which attempts to acquire a lock and returns immediately with a boolean value indicating whether the lock was acquired or not. This can be used to implement a timeout mechanism for acquiring locks, which can help to avoid deadlocks caused by threads waiting for resources that will never be released.

public class MyThread implements Runnable {
    private Lock lock = new ReentrantLock();

    public void run() {
        if (lock.tryLock(1, TimeUnit.SECONDS)) {
            try {
                // Access shared resource
            } finally {
                lock.unlock();
            }
        } else {
            // Handle failure to acquire lock
        }
    }
}

In the above example, we've used the tryLock method to attempt to acquire the lock with a timeout of 1 second. If the lock is acquired, the thread can access the shared resource. If the lock is not acquired within the timeout period, the thread can handle the failure and take appropriate action, such as retrying later or giving up.

Thread-safety

Thread-safety is the property of an object or a class that can be safely accessed by multiple threads without causing unexpected behavior. To ensure thread-safety, we can use the same solutions as mentioned above: synchronization and atomic variables, as well as using thread-safe collections from java.util.concurrent package.

public class MyThreadSafeClass {
    private AtomicInteger atomicInt = new AtomicInteger();
    private ConcurrentHashMap<String, String> threadSafeMap = new ConcurrentHashMap<>();

    public void increment() {
        atomicInt.incrementAndGet();
    }

    public void put(String key, String value) {
        threadSafeMap.put(key, value);
    }
}

In the above example, we've used an AtomicInteger to ensure that the increment method is thread-safe and a ConcurrentHashMap to ensure that the put method is thread-safe.

Conclusion

Threading can greatly improve the performance and responsiveness of your applications, but it also introduces new challenges such as race conditions, deadlocks, and thread-safety that must be handled with proper care. In this article, we covered the basics of thread creation, synchronization, and thread pools in Java 8+ to create robust and efficient concurrent applications. Additionally, we explored solutions, best practices, and code examples for handling the challenges of multithreading such as using synchronization, atomic variables, and thread-safe collections. By understanding and applying these techniques, you can develop multithreaded applications that are both efficient and safe. I hope this article has provided you with a solid foundation for working with threads in your own Java applications.

Game Of Threads: The Complete Guide

Table of contents