Threads in Java are lightweight processes that enable concurrent execution of multiple operations within a single program.
Threads allow us to break up a large task into smaller chunks and spread those out across multiple processors or cores for faster execution. For example, a thread can be used to compute the sum of a large array of numbers while another thread handles the display of the results. In this way, threads can improve the overall performance of our Java application.
The implementation of threads and processes differs between operating systems, but in most cases, a thread is a process component.
Multiple threads can exist within the same process and share resources such as memory, while different processes do not share these resources.
There are two types of threads in Java:
User threads are the ones that execute our application code, while daemon threads are responsible for performing background tasks such as garbage collection.
Daemon threads are only active as long as user threads are running. When all user threads have exited, the JVM will exit, even if daemon threads are still running.
In Java, threads can be created by using two mechanisms:
Thread class.public class MyThread extends Thread {public void run() {// some code goes here}}
Runnable interface.public class MyThread implements Runnable {public void run() {// some code goes here}}
Both ways of creating a thread in Java have their advantages and disadvantages. Extending the Thread class gives us access to all of its methods, but it also means that our class is tied to it, which can be inflexible. Implementing the Runnable interface gives us more flexibility, but we must implement the run() method ourselves.
Creating a thread in Java is just the first step. We also need to start running the thread by calling its start()method. This will cause the thread's run() method to execute in a separate process.
The run() method is where we put the code we want to execute in parallel with the rest of our program. Once a thread starts, it will continue to run until it is finished or until it is interrupted.
It's important to note that starting a thread does not guarantee that it will begin running immediately. The order in which threads are started is not necessarily the order in which they will execute. The order in which threads execute is mainly up to the operating system and is often difficult or impossible to predict.
join() methodIf we need to ensure that one thread starts running before another, we can use the join() method. This causes the current thread to wait until the thread that it is joining has completed. For example, if we have a thread that's responsible for loading data from a file and another thread that needs to use that data, we can use join() to make sure that the data is loaded before the second thread tries to use it.
A thread can be interrupted by another thread by calling its interrupt() method. When a thread is interrupted, it will throw an InterruptedException. This exception must be handled, or the thread will terminate. A thread can also be terminated by itself by calling its stop() method, but this is generally considered bad practice, as it can lead to unpredictable results.
When using multiple threads, care must be taken to avoid race conditions, which can occur when two or more threads attempt to access the same data concurrently, and at least one of the threads tries to modify that data.
Race conditions can lead to unpredictable results and are often very difficult to debug.
The Java Virtual Machine (JVM) allows multiple threads to coexist and execute concurrently safely. The JVM uses a thread scheduler to determine when each thread should be given a turn to run.
Threads can also communicate with each other using synchronized methods and blocks. Synchronized methods can only be executed by one thread at a time. It is useful when we need to ensure that two threads are not accessing the same data simultaneously, which could lead to inconsistencies or data corruption.
A synchronized block is a block of code that can only be executed by one thread at a time. The general form of a synchronized block is:
synchronized (object) {// code that can only be executed by one thread at a time}
The object that's passed to the synchronized block is called a monitor. Only one thread can own a monitor at a given time. When a thread enters a synchronized block, it tries to acquire the monitor for the object. If the monitor is available, the thread gets it and can proceed with executing the code in the block. If the monitor is not available, the thread will wait until it is released by the thread that currently owns it.
Synchronized methods are methods that can only be executed by one thread at a time.
synchronized void method() {// code that can only be executed by one thread// at a time}
It is useful when we need to ensure that two threads are not accessing the same data simultaneously, which could lead to inconsistencies or data corruption.
Synchronization can also lead to a deadlock, which is a situation where two or more threads are blocked permanently, waiting for each other to release a monitor. It can happen if Thread A tries to acquire a monitor that's currently held by Thread B, and Thread B tries to acquire a monitor that's currently held by Thread A. In this situation, both threads will be blocked permanently, and the program will appear to hang.
It's also worth noting that synchronization is not limited to monitors. We can use other objects as well, such as semaphores. Semaphores are objects that allow you to control access to a resource. They can be used to implement things like mutual exclusion or producer/consumer queues.