In this post, we will learn synchronization in java, and why we need Java synchronization, how to write synchronized code and more important points about synchronization.
Here is the table content of the article will we will cover this topic.
1. Synchronization in java?
2. Why do we use Synchronization in Java?
3. Locks in Java?
4. Types of Synchronization?
5. Multi-threading without Synchronization?
6. Multi-threading with Synchronization?
7. Important points about java synchronized?
8. Java synchronized block
i) synchronized block in non-static method
ii) synchronized block in static method
9. Java synchronized method
i) Java synchronization with non-static method
ii) Java synchronized method
Synchronization in java
In a multithreading environment, multiple threads can try to access the same resources and can produce erroneous and unforeseen results. Java provides a way to control the access of multiple threads to any shared resource. Synchronization in java is a process where we want to allow only one thread to access the shared resource at a time. So that multiple threads can work together without creating any problems. The synchronization process can achieve by synchronized keyword in java. The Synchronization keyword makes the code thread-safe.
Why do we use Synchronization in Java?
Suppose you have two resources and there may be a chance when multiple threads try to attempt the same resource and produce errors. So synchronization is used to handle the following errors:
1. Thread Interference Error: The thread interference error occurs when we have more than one thread and they are running simultaneously. Because they want to access the same piece of data and perform different operations on the same data. The operation of one thread could overlap with another thread and leads to data inconsistency.
2. Memory Consistency Error: The memory Consistency Error occurs when the changes made by one thread may not be visible to the other threads. The other threads have inconsistent views of the same shared data.
Locks in Java
Before moving further in synchronization, we have to understand the concept of lock or monitor. In java, Each and every object has a lock associated with it. When multiple threads access the shared resource, they use the lock. A thread requests a lock to an object and access data from the object meanwhile all other thread waits to release the lock. A thread releases the lock after the completion of work.
Types of Synchronization
There are 2 types of synchronization in java as shown below:
1. Process Synchronization: The simultaneous execution of multiple threads or processes to reach a state such that they commit to a certain sequence of actions.
2. Thread Synchronization: Thread Synchronization allows to access the shared space only one thread at a time.
In this post, we will discuss thread synchronization. The thread synchronization is divided into two parts.
1. Mutual Exclusive: Mutual exclusion is the simplest type of thread synchronization. This synchronization allows only one thread can execute the shared resource at a time. When a thread accesses the shared resource, it takes a lock and all other threads wait to release the lock. Let’s read how we can achieve it. There are two ways
1. Synchronized method.
2. Synchronized block.
2. Cooperation (Inter-thread communication in java): Interthread communication in java is used to avoid polling and is important when you want to develop an application where two or more threads exchange some information. Java provides three methods that are used for inter-thread communication. Those methods are, wait(), notify() and notifyAll() and these methods belong to the object class.
Multi-threading without Synchronization
Let’s discuss an example that prints the count by two different threads.
class Count
{
void printTable(int n)
{
//method not synchronized
for(int i=1;i<=5;i++)
{
System.out.println(n*i);
try
{
Thread.sleep(400);
}
catch(Exception e){System.out.println(e);}
}
}
}
class MyThread1 extends Thread
{
Count c;
MyThread1(Count c)
{
this.c=c;
}
public void run()
{
c.printTable(5);
}
}
class MyThread2 extends Thread
{
Count c;
MyThread2(Count c)
{
this.c=c;
}
public void run()
{
c.printTable(100);
}
}
public class WithoutSynchronization
{
public static void main(String args[])
{
Count obj = new Count();//only one object
MyThread1 t1=new MyThread1(obj);
MyThread2 t2=new MyThread2(obj);
t1.start();
t2.start();
}
}
Output: 5
100
200
10
15
300
400
20
500
25
Multi-threading with Synchronization
class Count
{
synchronized void printTable(int n)
{
//method not synchronized
for(int i=1;i<=5;i++)
{
System.out.println(n*i);
try
{
Thread.sleep(400);
}
catch(Exception e){System.out.println(e);}
}
}
}
class MyThread1 extends Thread
{
Count c;
MyThread1(Count c)
{
this.c=c;
}
public void run()
{
c.printTable(5);
}
}
class MyThread2 extends Thread
{
Count c;
MyThread2(Count c)
{
this.c=c;
}
public void run()
{
c.printTable(100);
}
}
public class WithSynchronization
{
public static void main(String args[])
{
Count obj = new Count();//only one object
MyThread1 t1=new MyThread1(obj);
MyThread2 t2=new MyThread2(obj);
t1.start();
t2.start();
}
}
Output: 5
10
15
20
25
100
200
300
400
500
Important points about java synchronized
1. Synchronized keyword in Java is used to synchronize the shared resource when multiple threads use it. Synchronization in Java is used to remove thread interference and memory inconstancy.
2. Java allows us to use the synchronized keyword with a method or block.
3. The concept of synchronization works based on lock. Whenever a thread enters into a java synchronized method or blocks it acquires a lock and releases the lock after completion of execution.
4. When a thread enters into a non-static synchronized method, it acquires an object-level lock. But when the thread enters into a static synchronized java method it acquires a class-level lock.
5. when a java synchronized method calls another synchronized method then it requires the same lock. But the current thread can enter without a lock because it already holding the lock.
6. Synchronized block throws NullPointerEception, if the object used in the java synchronized block is null.
7. A synchronized method is slow and can degrade performance because threads have to wait for their turn.
8. It is always better to use the Java synchronized block instead of the synchronized method because the using synchronized block only locks critical section of code and avoid locking the whole method.
9. The static synchronized and non-static synchronized method can run simultaneously because they lock on different objects.
Java synchronized method
We have read synchronization in java and Java block synchronization. Multiple threads used the shared resources and access the fields and objects reference fields. But it can create a problem with data inconsistency or thread interference. We prevent these errors by use of synchronized keyword in java. Let’s read the Java synchronized method.
To achieve the synchronization in java we can use the java synchronized keyword with the method. A synchronized method is used to ensure that only one thread can execute it at a time. As we discussed each object has a lock or monitor, so when any thread accesses it, the thread performs certain operations:
1. A thread checks the lock of the synchronized method. If there no other thread is executing it then the lock will be available.
2. If the lock is available, the thread takes the lock and performs the operation as per requirements. Meanwhile, all the other thread waits for the lock.
3. Multiple threads can’t take a lock at the same time.
The synchronized keyword can be used with a static method and a non-static method(instance methods). Here we will see the static and non-static synchronized method in java.
1. Java synchronization with non-static method
A synchronized non-static method is synchronized on the object level. If the method is non-static, the lock is acquired on the current object. Each object has its synchronized methods and only one thread per object can execute inside a synchronized method. It is also known as object-level locking.
Syntax of synchronized Method
access_modifiers synchronized return_type method_name(method_parameters)
{
// method_code
}
Let’s see thread synchronization in java simple example
class Test
{
synchronized public void count()
{
for (int i = 0; i < 3; i++)
{
System.out.println(i);
try
{
Thread.sleep(400);
}
catch (Exception e)
{
System.out.println(e);
}
}
}
}
class MyThread extends Thread {
Test test;
MyThread (Test test) {
this.test = test;
}
@Override
public void run() {
test.count();
}
}
public class SynchronizedMethod
{
public static void main(String[] args)
{
Test obj = new Test(); //Object of Apple class that is shared amoung threads
MyThread thread1 = new MyThread(obj);
MyThread thread2 = new MyThread(obj);
thread1.start();
thread2.start();
}
}
Output: 0
1
2
0
1
2
In the above example, we are creating two threads thread1 and thread2. Both are using the synchronized count() method. As it is synchronized, both are using it one by one. Firstly, thread1 enters the count() method and gets a lock meanwhile thread2 waits until thread1 finishes the execution. and release the lock. After that thread2 gets the lock and completes the execution.
2. Java synchronized static method
As we know static methods belong to a class instead of an object. When we use a synchronized keyword with a static method, the lock is acquired in the class. In synchronized static methods only one thread can execute inside a static synchronized method in the same class. If we have more than one static synchronized method, then only one thread can execute any of these methods at the same time.
Suppose we have two static synchronized methods, method1 and method2, and two threads thread1 and thread2. Here thread1 or thread2 can execute only one static method.
Syntax of static synchronized Method
access_modifiers synchronized static return_type method_name(method_parameters)
{
// method_code
}
class Test
{
synchronized static public void countIncrement()
{
System.out.println("Increment values");
for (int i = 0; i < 3; i++)
{
System.out.println(i);
try
{
Thread.sleep(400);
}
catch (Exception e)
{
System.out.println(e);
}
}
}
synchronized static public void countDecrement()
{
System.out.println("Decrement values");
for (int i = 3; i > 0; i--)
{
System.out.println(i);
try
{
Thread.sleep(400);
}
catch (Exception e)
{
System.out.println(e);
}
}
}
}
class MyThread extends Thread {
Test test;
MyThread (Test test) {
this.test = test;
}
@Override
public void run() {
test.countIncrement();
test.countDecrement();
}
}
public class SynchronizedMethod
{
public static void main(String[] args)
{
Test obj = new Test(); //Object of Apple class that is shared amoung threads
MyThread thread1 = new MyThread(obj);
MyThread thread2 = new MyThread(obj);
thread1.start();
thread2.start();
}
}
Output: Increment values
0
1
2
Increment values
0
1
2
Decrement values
3
2
1
Decrement values
3
2
1
In the above example, we have two static synchronized methods (countIncrement() method and countDecrement() method) and two threads(thread1 and thread2). One thread can access only one static method at a time.
Java synchronized block
We have read synchronization in java and method synchronization with synchronized keyword. In method synchronization, we synchronized the whole code of the method. But sometimes we want to synchronize a portion of a method, not the whole method. For such types of situations, we should use Java synchronized block. In this post, we will read it in detail.
The Java synchronized block is used to synchronize a portion of code or set of statements. Like the synchronized method, synchronized blocks in Java are marked with the synchronized keyword. A synchronized block can be executed by only one thread at a time and all other threads wait for the completion of execution.
synchronized ( lockObject)
{
//synchronized statements
}
A thread can execute the synchronized block only to acquire the lock on lockObject. Only one thread can acquire the monitor of a lock object at a time meanwhile all other threads wait for the lock.
We can have two types of synchronized blocks.
1. synchronized block in non-static method
When you want to synchronize a portion of the method instead of the whole method. We can use a synchronized block of Java code inside an unsynchronized Java method.
access_modifiers return_type method_name(method_parameters)
{
synchronized (objLock)
{
// block of code
}
// method_code
}
You must think about why the synchronized block construct takes an object in parentheses. This object is known as the monitor object. Only one thread can execute inside a Java code block synchronized on the same monitor object.
class Test
{
public void countIncrement()
{
synchronized(this)
{
for (int i = 0; i < 3; i++)
{
System.out.println(i);
try
{
Thread.sleep(400);
}
catch (Exception e)
{
System.out.println(e);
}
}
}
}
}
class MyThread extends Thread {
Test test;
MyThread (Test test) {
this.test = test;
}
@Override
public void run() {
test.countIncrement();
}
}
public class SynchronizedMethod
{
public static void main(String[] args)
{
Test obj = new Test();
MyThread thread1 = new MyThread(obj);
MyThread thread2 = new MyThread(obj);
thread1.start();
thread2.start();
}
}
Output: 0
1
2
0
1
2
2. synchronized block in static method
We can use the Synchronized blocks inside the static method. Suppose if we have two static methods with a synchronized block then only one thread can execute inside any of these two methods at the same time.
class Test
{
synchronized static public void countIncrement()
{
synchronized (Test.class)
{
System.out.println("Increment values");
for (int i = 0; i < 3; i++)
{
System.out.println(i);
try
{
Thread.sleep(400);
}
catch (Exception e)
{
System.out.println(e);
}
}
}
}
synchronized static public void countDecrement()
{
synchronized (Test.class)
{
System.out.println("Decrement values");
for (int i = 3; i > 0; i--)
{
System.out.println(i);
try
{
Thread.sleep(400);
}
catch (Exception e)
{
System.out.println(e);
}
}
}
}
}
class MyThread extends Thread {
Test test;
MyThread (Test test) {
this.test = test;
}
@Override
public void run() {
test.countIncrement();
test.countDecrement();
}
}
public class SynchronizedMethod
{
public static void main(String[] args)
{
Test obj = new Test(); //Object of Apple class that is shared amoung threads
MyThread thread1 = new MyThread(obj);
MyThread thread2 = new MyThread(obj);
thread1.start();
thread2.start();
}
}
Output: Increment values
0
1
2
Increment values
0
1
2
Decrement values
3
2
1
Decrement values
3
2
1
