Why is synchronization needed in Java? Please give some relevant examples to explain. Examples can be from Java source code or some mainstream Java open source projects.
Synchronization in Java is crucial for managing access to shared resources in a concurrent environment. When multiple threads access shared data or resources simultaneously, it can lead to inconsistent or unpredictable results, often referred to as race conditions. Synchronization helps ensure that only one thread can access a resource at a time, maintaining data integrity and consistency.
Data Consistency: When multiple threads read and write shared data, synchronization ensures that the data remains consistent and valid.
Atomicity: Synchronization allows certain operations to be atomic, meaning they are completed in a single step without interruption.
Visibility: Changes made by one thread to shared data may not be visible to other threads immediately. Synchronization ensures that changes are visible across threads.
Deadlock Prevention: Proper synchronization can help avoid deadlocks, where two or more threads are waiting indefinitely for each other to release resources.
synchronized KeywordThe simplest way to synchronize access to a method or block of code is by using the synchronized keyword.
class Counter {
private int count = 0;
// Synchronized method
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final count: " + counter.getCount()); // Should be 2000
}
}
In this example, the increment method is synchronized, ensuring that only one thread can execute it at a time. This prevents race conditions when both threads try to increment the count variable.
ReentrantLockJava provides more advanced synchronization mechanisms, such as ReentrantLock, which offers more flexibility than the synchronized keyword.
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Counter {
private int count = 0;
private final Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final count: " + counter.getCount()); // Should be 2000
}
}
In this example, ReentrantLock is used to control access to the increment method. This allows for more complex locking strategies, such as trying to acquire a lock without blocking.
In many open-source Java projects, synchronization is used extensively. For instance, in the Apache Commons Collections library, you might find synchronized collections that ensure thread-safe access to data structures.
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.list.SynchronizedList;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
List<String> synchronizedList = SynchronizedList.synchronizedList(list);
synchronizedList.add("Hello");
synchronizedList.add("World");
// Accessing the synchronized list
synchronized (synchronizedList) {
for (String s : synchronizedList) {
System.out.println(s);
}
}
}
}
In this example, SynchronizedList from Apache Commons Collections provides a thread-safe wrapper around a regular list, ensuring that all operations on the list are synchronized.
Synchronization is essential in Java to ensure that shared resources are accessed safely in a multi-threaded environment. By using synchronization mechanisms like the synchronized keyword, ReentrantLock, or synchronized collections, developers can prevent race conditions and maintain data integrity.