What occurs when two components of a program attempt to access the identical data concurrently? What if two threads endeavor to modify the same number simultaneously? How can we guarantee that only one thread interacts with the data at any given moment to ensure proper functionality? This is where synchronization becomes relevant. But what does synchronization signify in Java? When is it necessary to implement it to safeguard our program? Let’s explore how Java employs the synchronized keyword to regulate thread access and protect shared data.
In this piece, we will delve deeper into synchronization, illustrating it with real-world scenarios.
Synchronization in Java is a technique to regulate how multiple threads interact with shared resources. It prevents data inconsistency when two or more threads access the same data simultaneously.
The synchronized keyword in Java controls access to a critical section by multiple threads. It permits only one thread to access this critical section at a time.
Note: A critical section refers to a segment of code that utilizes shared data and should only be executed by one thread at a time.
In the image above, we observe four threads attempting to utilize a synchronized method. Initially, thread-1 and thread-4 enter the synchronized method; however, thread-4 must wait while thread-1 is engaged. After thread-1 completes its task, thread-4 will have the opportunity to enter the method and perform its actions.
In Java, when several threads attempt to access and modify the critical section simultaneously, they might interfere with each other. This scenario creates a problem termed a race condition.
For instance, suppose you have a balance of ₹1000 in your bank account. Two threads, t1 and t2, both try to withdraw ₹700 from the account concurrently. Without synchronization:
Both will perceive the balance as ₹1000.
Consequently, both will attempt to withdraw ₹700.
This can result in a total withdrawal of ₹1400 from the account, leading the balance to go negative or incorrect.
The underlying issue in the above example is that:
No waiting: Threads t1 and t2 do not pause for one another.
No order: It is uncertain which thread will execute first.
Shared data becomes jumbled: When both threads access the critical section at once.
Categories of Synchronization
There are two primary categories of synchronization in Java. These are:
1. Process Synchronization
Process Synchronization pertains to independent processes that operate parallelly, ensuring that no two processes interfere when accessing shared system resources.
This is managed by the Operating System and is not directly handled by Java. Java programs typically do not engage with process synchronization directly unless utilizing tools like inter-process communication.
2. Thread Synchronization
Thread Synchronization is utilized to regulate access to shared resources among multiple threads within the same process. Java provides inherent support for this type of synchronization.
It includes two types of thread synchronization:
1. Mutual Exclusion: Ensures that only one thread can access the shared resource at any given time.
2. Cooperation or Inter-thread Communication: Enables threads to converse and coordinate with one another.
Note: Java can utilize java.lang.Process, sockets, RMI, or external libraries for inter-process communication.
Implementing Synchronization in Java
In Java, synchronization can be achieved using the synchronized keyword in the following manners.
1. Synchronized Method
In this approach, you can declare an entire method as a synchronized method, which ensures that only one thread can execute this method on the same object at any given moment.
Example:
Java
“`html
Code Duplicated!
var isMobile = window.innerWidth “);
editor2551.setValue(decodedContent); // Set the default text
editor2551.clearSelection();
editor2551.setOptions({
maxLines: Infinity
});
function decodeHTML2551(input) {
var doc = new DOMParser().parseFromString(input, “text/html”);
return doc.documentElement.textContent;
}
// Function to duplicate code to clipboard
function copyCodeToClipboard2551() {
const code = editor2551.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert(“Code duplicated to clipboard!”);
data: {
language: “java”,
code: code,
cmd_line_args: “”,
variablenames: “”,
action:”compilerajax”
},
success: function(response) {
var myArray = response.split(“~”);
var data = myArray[1];
jQuery(“.output2551”).html(“
"+data+"");
jQuery(".maineditor2551 .code-editor-output").show();
jQuery("#runBtn2551 i.run-code").hide();
}
})
}
function closeOutput2551() {
var code = editor2551.getSession().getValue();
jQuery(".maineditor2551 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn2551").addEventListener("click", copyCodeToClipboard2551);
document.getElementById("runBtn2551").addEventListener("click", executeCode2551);
document.getElementById("closeoutputBtn2551").addEventListener("click", closeOutput2551);
Output:
Clarification:
In the preceding Java code, two threads augment the counter 1000 times. Due to the utilization of the synchronized keyword, they do not disrupt each other, and the final count is 2000. The synchronized void increment() method guarantees that only one thread can access the increment() method concurrently. The join() method instructs the main thread to wait until t1 and t2 complete their execution.
2. Synchronized Block
In this scenario, rather than locking the entire method, only a specific segment of the code is synchronized that interacts with shared data.
Example:
Java
Code Duplicated!
Output:
Explanation:
In the preceding Java code, two threads increment the counter 1000 times. Since we employed the synchronized keyword, they do not conflict with each other, resulting in a final count of 2000. The synchronized(this) locks the current instance, allowing only one thread at a given time to execute the count++ portion, ensuring thread safety and preventing race conditions.
3. Static Synchronized Method
When a method is designated as both static and synchronized, it implies that only one thread can execute that method simultaneously across all class instances. The lock applies not to a specific object but to the class itself.
Example:
Java
Code Copied!
Output:
Explanation:
In the preceding Java code, threads t1, t2, and t3 are instantiated. The static synchronized locks apply to the class itself, not to any specific object. Thus, even with threads originating from different objects, only one thread can access the printMessage() method at once.
4. Thread Synchronization
This represents the most frequent application of the synchronized keyword in Java, ensuring that only one thread interacts with shared data at any given time by acquiring a lock on the object or class.
function closeOutput37055() {
jQuery(".maineditor37055 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn37055").addEventListener("click", copyCodeToClipboard37055);
document.getElementById("runBtn37055").addEventListener("click", runCode37055);
document.getElementById("closeoutputBtn37055").addEventListener("click", closeOutput37055);
Outcome:
Clarification:
In the preceding Java example, the add() function is synchronized, allowing only one thread to execute it at any given time. Without synchronization, both threads could concurrently modify num, leading to erroneous results.
5. Process Synchronization
Process synchronization refers to the coordination of two or more independent processes sharing resources such as files, databases, or memory. In Java, this is often achieved using Inter-Process Communication (IPC) or external methods like files, sockets, or database locks.
function decodeHTML33649(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard33649() {
const code = editor33649.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code successfully copied to clipboard!");
data: {
language: "java",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
jQuery(".output33649").html("
" + data + "");
jQuery(".maineditor33649 .code-editor-output").show();
jQuery("#runBtn33649 i.run-code").hide();
}
});
}
function closeOutput33649() {
var code = editor33649.getSession().getValue();
jQuery(".maineditor33649 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn33649").addEventListener("click", copyCodeToClipboard33649);
document.getElementById("runBtn33649").addEventListener("click", runCode33649);
document.getElementById("closeoutputBtn33649").addEventListener("click", closeOutput33649);
Prior to executing the code, the file “Intellipaat.txt” will be vacant. Upon execution, the file will appear as follows.
Output:
Inter-Thread Communication
Inter-thread communication refers to two or more threads interacting with each other while sharing data. This is often described as Cooperative Synchronization since the threads work together rather than competing.
Three main methods are utilized within the synchronized blocks or methods of the object class. They are:
1. wait(): This instructs the current thread to halt and free the lock. It can solely be invoked from a synchronized context.
2. notify(): This activates one thread that is on hold.
3. notifyAll(): This activates all threads that are waiting.
4. sleep(): This halts the current thread for a predetermined duration (in milliseconds), without relinquishing the lock.
Visualize two threads:
Thread A acts as a Producer that generates data.
Thread B serves as a Consumer that utilizes the data created by A.
We want to ensure Thread B does not consume the data before Thread A has produced it. Thus, Thread B must wait until Thread A completes its task. Subsequent to Thread A producing the data, it will alert Thread B to consume it.
This type of interaction between the threads is referred to as inter-thread communication.
For illustration, consider the following code.
Java
Code Copied!
Outcome:
The preceding Java code illustrates how a thread (producer) places numbers into a buffer, while another thread (consumer) retrieves them. When the buffer reaches capacity, the producer pauses. Conversely, if the buffer is void, the consumer halts. They alternate this process utilizing wait() and notify(). Additionally, the synchronized keyword guarantees that only one thread accesses the buffer at any given moment.
Alternatives to Synchronization in Java
Java offers several other mechanisms that do not rely on the synchronized keyword to ensure thread safety. These alternatives are typically more efficient. A few examples include:
1. Locks (ReentrantLock)
A Lock in Java is a mechanism used to manage access to shared resources such as variables, files, memory, etc., in a multithreaded environment. It belongs to the java.util.concurrent.locks package.
It's akin to using a door lock; only one individual can enter a room, while others must wait outside.
ReentrantLock is part of the java.util.concurrent.locks package, allowing a lock to be acquired multiple times without causing a block. Unlike the synchronized keyword, it provides explicit management over the locking and unlocking process. This feature is particularly beneficial when enhanced control over locking logic timeouts is necessary.
function closeOutput79685() {
var code = editor79685.getSession().getValue();
jQuery(".maineditor79685 .code-editor-output").hide();
}
// Link event listeners to the buttons
document.getElementById("copyBtn79685").addEventListener("click", copyCodeToClipboard79685);
document.getElementById("runBtn79685").addEventListener("click", executeCode79685);
document.getElementById("closeOutputBtn79685").addEventListener("click", closeOutput79685);
Result:
Upon completion of the code execution, the output.txt will appear as shown below.
Clarification:
In the aforementioned Java code, we employ ReentrantLock to regulate a thread's access to the critical section. The lock.lock() function is invoked for a thread to enter this section, whereas lock.unlock() permits other threads to enter once the first one has completed its task.
2. Atomic Variables
Atomic Variable exists within the java.util.concurrent.atomic package, containing classes such as AtomicInteger, AtomicLong, AtomicBoolean, AtomicReference, etc. These utilize CPU-level atomic operations, like CAS (Compare And Swap), for lock-free synchronization.
It operates swiftly and efficiently for small code segments, like counters. They are primarily utilized when one aims to completely bypass locking.
Sample:
Java
Code Copied!
var isMobile = window.innerWidth ");
editor69603.setValue(decodedContent); // Establish the default text
editor69603.clearSelection();
editor69603.setOptions({
maxLines: Infinity
});
function decodeHTML69603(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Method to duplicate code to clipboard
function copyCodeToClipboard69603() {
const code = editor69603.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code copied to clipboard!");
data: {
language: "java",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
jQuery(".output69603").html("
"+data+"");
jQuery(".maineditor69603 .code-editor-output").show();
jQuery("#runBtn69603 i.run-code").hide();
}
})
}
function closeOutput69603() {
var code = editor69603.getSession().getValue();
jQuery(".maineditor69603 .code-editor-output").hide();
}
// Link event listeners to the buttons
document.getElementById("copyBtn69603").addEventListener("click", copyCodeToClipboard69603);
document.getElementById("runBtn69603").addEventListener("click", executeCode69603);
document.getElementById("closeOutputBtn69603").addEventListener("click", closeOutput69603);
Result:
Clarification:
In the above Java code, AtomicInteger is utilized to safely increment a number in a multithreaded context without resorting to any other locking mechanism.
3. Executor Service
Executor Service forms part of the java.util.concurrent package, featuring a thread pool that can efficiently administer and schedule threads. It simplifies the process by eliminating the necessity of creating and managing each thread individually. However, it does not dispense with the requirement for synchronization when accessing shared resources.
It is employed in applications where numerous threads are engaged, as it can effortlessly manage a vast quantity of threads. Additionally, it encourages the execution of tasks in parallel.
Sample:
Java
Code Duplicated!
Result:
Clarification:
Within the above Java code, we utilize ExecutorService to execute a task using a thread pool, which facilitates the structured execution of a task.
4. Semaphores
A semaphore is a value that limits the number of threads capable of accessing a resource simultaneously. It belongs to the java.util.concurrent package.
A semaphore with a value of 1 is referred to as a binary semaphore.
For instance, 3 threads may access a collection of 3 printers, but if a 4th arrives, it must wait.
function dismissOutput9288() {
jQuery(".maineditor9288 .code-editor-output").hide();
}
// Attach event handlers to the buttons
document.getElementById("copyBtn9288").addEventListener("click", duplicateCodeToClipboard9288);
document.getElementById("runBtn9288").addEventListener("click", executeCode9288);
document.getElementById("closeoutputBtn9288").addEventListener("click", dismissOutput9288);
Result:
Clarification:
In the Java code shown above, a Semaphore is utilized to permit only one thread to access the critical section at any given moment.
5. Read-Write Locks (ReadWriteLock)
The Read-Write Lock is found in the java.util.concurrent.locks.ReadWriteLock class and employs the readLock() and writeLock() methods internally to allow multiple threads to read simultaneously. However, it permits only one thread to write, and during the writing process, no other operations, such as reading or writing, can occur.
Illustration: It is commonly employed in memory caches and real-time analytics data.
Illustration:
Java
Code Duplicated!
var isMobile = window.innerWidth {n for (int i = 1; i {n for (int i = 0; i {n for (int i = 0; i ");
editor9288.setValue(decodedContent); // Assign the default text
editor9288.clearSelection();
editor9288.setOptions({
maxLines: Infinity
});
function decodeHTML9288(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to duplicate code to clipboard
function duplicateCodeToClipboard9288() {
const code = editor9288.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code duplicated to clipboard!");
function executeCode9288() {
var code = editor9288.getSession().getValue();
// The rest of the AJAX request and success handling goes here
}
``````javascript
"post",
data: {
language: "java",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
function closeoutput9288() {
var code = editor9288.getSession().getValue();
jQuery(".maineditor9288 .code-editor-output").hide();
}
// Add event listeners to the buttons
document.getElementById("copyBtn9288").addEventListener("click", copyCodeToClipboard9288);
document.getElementById("runBtn9288").addEventListener("click", runCode9288);
document.getElementById("closeoutputBtn9288").addEventListener("click", closeoutput9288);
Output:
Explanation:
The Java snippet above utilizes ReadWriteLock to permit several threads simultaneous access to shared data for reading.
6. Volatile Keyword
The Volatile Keyword in Java is employed to ensure alterations to a variable are visible to all threads. By using this keyword, the most recent value is retrieved from the main memory. It is typically utilized for basic flag variables.
Example:
Java
Code Copied!
var isMobile = window.innerWidth ");
editor47616.setValue(decodedContent); // Set the default text
editor47616.clearSelection();
editor47616.setOptions({
maxLines: Infinity
});
function decodeHTML47616(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard47616() {
const code = editor47616.getValue(); // Get code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code copied to clipboard!");
function closeoutput47616() {
var code = editor47616.getSession().getValue();
jQuery(".maineditor47616 .code-editor-output").hide();
}
// Add event listeners for the buttons
document.getElementById("copyBtn47616").addEventListener("click", copyCodeToClipboard47616);
document.getElementById("runBtn47616").addEventListener("click", runCode47616);
document.getElementById("closeoutputBtn47616").addEventListener("click", closeoutput47616);
Output:
Explanation:
The Java snippet mentioned above, volatile boolean running = true; ensures that modifications made by one thread are immediately visible to other threads.
Benefits of Synchronization
1. It is protected against errors, as only one thread is permitted to interact with shared data at a time.
2. It maintains data integrity, even when multiple threads are operating concurrently.
3. It is easy to implement, since Java provides the synchronized keyword, which simplifies synchronization.
4. No additional tools required, as synchronization can be managed directly in Java code without relying on external libraries.
Drawbacks of Synchronization
1. It slows down the program, as only one thread can access the block at any given moment.
2. Occasionally, it results in a deadlock issue, if two threads are in a waiting state for one another.
``````html
for one another to unlock locks.
3. It makes it difficult to identify the errors in the software, since issues concerning synchronization are complex to troubleshoot.
4. You need to craft the code meticulously because a minor error in applying synchronization, such as overlooking a lock, can create significant issues like a race condition.
Practical Scenarios of Synchronization
1. In digital banking applications, two individuals may attempt to withdraw funds at the same moment. Without any monitoring, both could take out more than the available balance. This results in incorrect account updates.
2. In workplaces, several people might send documents to the same printer simultaneously. If all pages are printed at once, they can become jumbled, wasting paper and causing confusion for users. Synchronization manages print tasks sequentially.
3. On platforms like YouTube or Instagram, numerous users can like or view content simultaneously. If this happens at the same instant, some likes or views may not be recorded. This could result in an inaccurate total.
4. In food delivery applications, one thread might add items while another completes the order. If both actions occur simultaneously, the cart may reflect incorrect items. This could lead to erroneous or absent orders. Synchronization ensures the cart remains accurate in order.
Optimal Procedures for Implementing Synchronization
1. Apply synchronization only when necessary, specifically when shared data is accessed by multiple threads, as it can reduce performance.
2. Synchronize only the essential section, rather than the entire method, to prevent deadlocks and enhance performance.
3. Use a synchronized block instead of a synchronized method because it allows for greater flexibility and improved performance.
4. Include comments adjacent to the synchronized blocks to clarify their necessity.
5. Aim to minimize the use of shared variables between the threads, which will lower the likelihood of a race condition.
From the aforementioned article, we deduce that synchronization in Java ensures that only a single thread accesses shared data at one time, thus preventing issues like incorrect outcomes or data intermingling. We can utilize synchronized, wait(), notify(), and other tools for this purpose. These tools aid threads in functioning in the correct sequence and prevent errors. However, excessive synchronization can hinder performance. Therefore, it should be utilized only when absolutely necessary.
If you're interested in expanding your knowledge on this subject, you may refer to our Java course.
What is Synchronization in Java – FAQs
Q1. What is synchronization in Java?
Synchronization in Java indicates that only one thread can perform a task at a time to prevent conflicts.
Q2. What is a synchronized class?
synchronized(X.class) is utilized to ensure that only a single thread can execute that section of code at a time.
Q3. What leads to deadlocks?
A deadlock arises when two or more tasks permanently obstruct each other, as each task holds a lock on a resource the others are attempting to lock.
Q4. What differentiates join from synchronization in Java?
The simplest approach to synchronize a static variable is by employing Java’s synchronized keyword, which locks the entire class since the variable is static.
Q5. How can deadlock be avoided in Java?
To prevent deadlocks in Java, you may use strategies such as thread joins.
To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions.
Functional
Always active
The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network.
Preferences
The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user.
Statistics
The technical storage or access that is used exclusively for statistical purposes.The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you.
Marketing
The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes.
