Creating a Thread
There are two different ways to create a thread in Java. We have listed them as
follows:
• By Implementing a Runnable Interface
• By Extending a Thread Class
Method 1:
Create a Thread by Implementing a Runnable Interface
If your class is intended to be executed as a thread then you can achieve this by
implementing a Runnable interface. You will need to follow three basic steps −
Step 1: Implement run() Method
As a first step, you need to implement a run() method provided by
a Runnable interface. This method provides an entry point for the thread and
you will put your complete business logic inside this method. Following is a
simple syntax of the run() method −
public void run( )
Step 2: Instantiate a Thread Object
As a second step, you will instantiate a Thread object using the following
constructor −
Thread(Runnable threadObj, String threadName);
Where, threadObj is an instance of a class that implements
the Runnable interface and threadName is the name given to the new thread.
Step 3: Call Thread using start() Method
Once a Thread object is created, you can start it by calling start() method, which
executes a call to run( ) method. Following is a simple syntax of start() method −
void start();
Example: Create Thread by Implementing Runnable Interface
Here is an example that creates a new thread and starts running it −
Method 2:
Create a Thread by Extending a Thread Class
The second way to create a thread is to create a new class that
extends Thread class using the following two simple steps. This approach
provides more flexibility in handling multiple threads created using available
methods in Thread class.
Step 1: Override run() Method
You will need to override run( ) method available in Thread class. This method
provides an entry point for the thread and you will put your complete business
logic inside this method. Following is a simple syntax of run() method −
public void run( )
Step 2: Call Thread using start() Method
Once Thread object is created, you can start it by calling start() method, which
executes a call to run( ) method. Following is a simple syntax of start() method −
void start( );
Example: Create Thread by Extending Thread Class
Here is the preceding program rewritten to extend the Thread –
Java - Thread Synchronization
Need of Thread Synchronization?
When we start two or more threads within a program, there may be a situation
when multiple threads try to access the same resource and finally they can
produce unforeseen result due to concurrency issues. For example, if multiple
threads try to write within a same file then they may corrupt the data because
one of the threads can override data or while one thread is opening the same
file at the same time another thread might be closing the same file.
So there is a need to synchronize the action of multiple threads and make sure
that only one thread can access the resource at a given point in time. This is
implemented using a concept called monitors. Each object in Java is associated
with a monitor, which a thread can lock or unlock. Only one thread at a time may
hold a lock on a monitor.
Thread Synchronization in Java
Java programming language provides a very handy way of creating threads and
synchronizing their task by using synchronized blocks. You keep shared
resources within this block. Following is the general form of the synchronized
statement –
Syntax
synchronized(objectidentifier) {
// Access shared variables and other shared resources
}
Here, the objectidentifier is a reference to an object whose lock associates with
the monitor that the synchronized statement represents. Now we are going to
see two examples, where we will print a counter using two different threads.
When threads are not synchronized, they print counter value which is not in
sequence, but when we print counter by putting inside synchronized() block,
then it prints counter very much in sequence for both the threads.
Multithreading Example without Thread Synchronization
Here is a simple example which may or may not print counter value in sequence
and every time we run it, it produces a different result based on CPU availability
to a thread.
}
Multithreading Example with Thread Synchronization
Here is the same example which prints counter value in sequence and every time
we run it, it produces the same result.
Inter-thread Communication in Java
Inter-thread communication is important when you develop an application
where two or more threads exchange some information. Inter-thread
communication is achieved by using the wait(), notify(), and notifyAll() methods
of the Object class.
Methods used for Inter-thread Communication
There are three simple methods and a little trick which makes thread
communication possible. All the three methods are listed below –
Example of Inter-thread Communication in Java
This examples shows how two threads can communicate
using wait() and notify() method. You can create a complex system using the
same concept.
Java - Thread Deadlock
Deadlock describes a situation where two or more threads are blocked forever,
waiting for each other. Deadlock occurs when multiple threads need the same
locks but obtain them in different order. A Java multithreaded program may
suffer from the deadlock condition because the synchronized keyword causes
the executing thread to block while waiting for the lock, or monitor, associated
with the specified object. Here is an example.
Example: Demonstrating Deadlock Situation
Deadlock Solution Example
Let's change the order of the lock and run of the same program to see if both
the threads still wait for each other −
Example:
So just changing the order of the locks prevent the program in going into a
deadlock situation and completes with the following result −
Output:
