Synchronization in Java
James Hartman
What is Synchronization in Java?
In Java, synchronization refers to the ability to control the access of multiple threads to any shared resource. It is an ideal option where we want to allow only one thread to access the shared resource.
This approach of execution is usually referred to as `asynchronous` programming. There are also threads on these processors, which are lightweight processes that can execute instructions simultaneously.
Types of Synchronization
There are two types of synchronization methods in Java:
1) Process synchronization
2) Thread synchronization.
Let’s study Thread and Process synchronization in detail.
Process synchronization: It manages synchronization between programs. For example, programs such as `Microsoft Word` and `Acrobat reader` run as individual processes.
Thread synchronization: The concurrent execution of the critical resource by two or more Threads is termed Thread Synchronization. You can be grouped further to mutually exclusive` and inter-thread communication.
What is Lock in Java?
Lock in Java is built around an internal entity known as a monitor or the lock. All the object has a lock associated with them. So, the thread that needs consistent access to an object’s fields must acquire the object’s lock before accessing them, and it releases the lock when the work is done. This ensures that only one thread access the shared data at a time.
Multithreaded program with synchronization
A multithreaded program is a method or block protected from interference from other threads sharing the same resource indicated using the `synchronized` keyword.
Using the synchronized method
Any method that is declared as synchronized is known as a synchronized Method. It is also used to lock an object for any shared resource. So, when a thread invokes a synchronized method. It automatically takes possession of the lock for that object and releases it when it has finished its task.
Note: The synchronized keyword cannot work with classes and variables. Only methods and blocks can be used with the keyword.
Why use the Synchronized Method?
- It is used for locking an object for any shared resources.
- The object gets the lock whenever the synchronized method is called.
- The lock does not release until the thread completes its function
Syntax:
Acess_modifiers synchronized return_type method_name (Method_Parameters) {
}
class MathService {
synchronized void getSumOfArray(int[] numbers) {
int sum = 0;
for (int number : numbers) {
System.out.println(Thread.currentThread()
.getName()
+ " adds "
+ sum + " to "
+ number + " to get -> "
+ (sum += number));
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Synchronization {
public static void main(String[] args) {
MathService mathService = new MathService();
Thread threadOne = new Thread(() ->
mathService.getSumOfArray(new int[]{10, 11, 12}));
Thread threadTwo = new Thread(() ->
mathService.getSumOfArray(new int[]{20, 21, 22}));
threadOne.start();
threadTwo.start();
}
}
Explanation of Code:
Run this example and observe that thread `0` gets the lock of the `mathService` object first and uses this lock exclusively until it has completed executing. Thread `0` and `1` are not interleaved in this code. The output is as shown below.
Output:
Thread-0 adds 0 to 10 to get -> 10 Thread-0 adds 10 to 11 to get -> 21 Thread-0 adds 21 to 12 to get -> 33 Thread-1 adds 0 to 20 to get -> 20 Thread-1 adds 20 to 21 to get -> 41 Thread-1 adds 41 to 22 to get -> 63
Using a synchronized block
Let’s assume that you don’t want to synchronize the entire method. Instead, you want to synchronize a few lines of code. At that time, the Synchronized block helped to synchronize that selected Java code. Synchronized method locks are accessed on the method, whereas synchronized block locks are accessed on the object.
class MathService {
void getSumOfArray(int[] numbers) {
synchronized (this){
int sum = 0;
for (int number : numbers) {
System.out.println(Thread.currentThread()
.getName()
+ " adds "
+ sum + " to "
+ number + " to get -> "
+ (sum += number));
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}
public class Synchronization {
public static void main(String[] args) {
MathService mathService = new MathService();
Thread threadOne = new Thread(() ->
mathService.getSumOfArray(new int[]{10, 11, 12}));
Thread threadTwo = new Thread(() ->
mathService.getSumOfArray(new int[]{20, 21, 22}));
threadOne.start();
threadTwo.start();
}
}
Code Explanation:
Upon running this code, you will note that it works without any interference. In the synchronized method, the lock is applied by the method, but in the synchronized block, the lock is applied by the object. Ensure the output is as shown below.
Output:
Thread-0 adds 0 to 10 to get -> 10 Thread-0 adds 10 to 11 to get -> 21 Thread-0 adds 21 to 12 to get -> 33 Thread-1 adds 0 to 20 to get -> 20 Thread-1 adds 20 to 21 to get -> 41 Thread-1 adds 41 to 22 to get -> 63
Explanation of code:
When you run this code, you will note that it works without interference, which is what we expected. In the synchronized method, the lock is applied by the method, but in the synchronized block method, the lock is applied by the object.
Using static synchronization
In Java synchronization, if there is more than one object, two threads may acquire the locks and enter a synchronized block or block, with a separate lock for each object. To avoid this, static synchronization can be used. Synchronized keywords will be used before static methods.
Note: In static synchronization, lock access is on the class, not the object and method.
Code to demonstrate the issue of multiple objects locking
class MathService {
synchronized void getSumOfArray(int[] numbers) {
int sum = 0;
for (int number : numbers) {
System.out.println(Thread.currentThread()
.getName()
+ " adds "
+ sum + " to "
+ number + " to get -> "
+ (sum += number));
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Synchronization {
public static void main(String[] args) {
MathService mathService = new MathService();
MathService mathService1 = new MathService();
Thread threadOne = new Thread(() ->
mathService.getSumOfArray(new int[]{10, 11, 12}));
Thread threadTwo = new Thread(() ->
mathService.getSumOfArray(new int[]{20, 21, 22}));
Thread threadThree = new Thread(() ->
mathService1.getSumOfArray(new int[]{10, 11, 12}));
Thread threadFour = new Thread(() ->
mathService1.getSumOfArray(new int[]{20, 21, 22}));
threadOne.start();
threadTwo.start();
threadThree.start();
threadFour.start();
}
}
Explanation of code:
When we create another instance of the `MathService`, we introduce interference in the threads as they will be interleaved with the two objects. Note that thread `0` and thread `2` are interleaved with the two objects, while thread `1` and `3` are interleaved with the two objects.
Output:
Thread-0 adds 0 to 10 to get -> 10 Thread-2 adds 0 to 10 to get -> 10 Thread-0 adds 10 to 11 to get -> 21 Thread-2 adds 10 to 11 to get -> 21 Thread-0 adds 21 to 12 to get -> 33 Thread-2 adds 21 to 12 to get -> 33 Thread-1 adds 0 to 20 to get -> 20 Thread-3 adds 0 to 20 to get -> 20 Thread-1 adds 20 to 21 to get -> 41 Thread-3 adds 20 to 21 to get -> 41 Thread-1 adds 41 to 22 to get -> 63 Thread-3 adds 41 to 22 to get -> 63
Same code using synchronized static method
class MathService {
synchronized static void getSumOfArray(int[] numbers) {
int sum = 0;
for (int number : numbers) {
System.out.println(Thread.currentThread()
.getName()
+ " adds "
+ sum + " to "
+ number + " to get -> "
+ (sum += number));
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Synchronization {
public static void main(String[] args) {
MathService mathService = new MathService();
MathService mathService1 = new MathService();
Thread threadOne = new Thread(() ->
mathService.getSumOfArray(new int[]{10, 11, 12}));
Thread threadTwo = new Thread(() ->
mathService.getSumOfArray(new int[]{20, 21, 22}));
Thread threadThree = new Thread(() ->
mathService1.getSumOfArray(new int[]{10, 11, 12}));
Thread threadFour = new Thread(() ->
mathService1.getSumOfArray(new int[]{20, 21, 22}));
threadOne.start();
threadTwo.start();
threadThree.start();
threadFour.start();
}
}
Run the above code and note that we have now eliminated thread interference. The output of the code is shown below.
Output:
Thread-0 adds 0 to 10 to get -> 10 Thread-0 adds 10 to 11 to get -> 21 Thread-0 adds 21 to 12 to get -> 33 Thread-3 adds 0 to 20 to get -> 20 Thread-3 adds 20 to 21 to get -> 41 Thread-3 adds 41 to 22 to get -> 63 Thread-2 adds 0 to 10 to get -> 10 Thread-2 adds 10 to 11 to get -> 21 Thread-2 adds 21 to 12 to get -> 33 Thread-1 adds 0 to 20 to get -> 20 Thread-1 adds 20 to 21 to get -> 41 Thread-1 adds 41 to 22 to get -> 63
Advantages of using synchronization
Here are the advantages of when working with concurrent applications:
- The main objective of synchronization in Java is to prevent inconsistent data by preventing thread interference.
- The synchronized keyword in Java provides locking, which ensures mutually exclusive access to the shared resource and prevents data race.
- It also prevents the reordering of code statements by the compiler, which can cause a subtle concurrent issue if we don’t use volatile or synchronized keywords.
- Synchronized keyword reads data from main memory than cache and when it releases the lock.
- It also flushes write operations from the main memory, eliminating memory inconsistency errors.
Disadvantages of Synchronization Mechanism
Synchronization Mechanisms have poor performance.
For example
- Assume there are five processes, A1, A2, A3, A4, and A5.
- They are waiting for the shared resources to access one thread at a time.
- All processes are kept waiting, so the last in the queue must wait until all other processes are complete.
Summary
- Synchronization refers to the ability to control the access of multiple threads to any shared resource.
- Java has two types of synchronization methods: 1) Process synchronization and 2) Thread synchronization.
- Lock in Java is built around an internal entity known as a monitor or the lock.
- A Multithreaded program is a method or block protected from interference from other threads sharing the same resource indicated using the `synchronized` keyword.
- Any method that is declared as synchronized is known as a synchronized method.
- In Java, synchronized method locks are accessed on the method, whereas synchronized block locks are accessed on the object.
- In static synchronization, lock access is on the class, not the object and method.
- The main objective of synchronization in Java is to prevent inconsistent data by preventing thread interference.
- The biggest drawback of this method is that all processes are kept in waiting, so the last in the queue must wait until all other processes are complete.
