Ключевое слово synchronized в Java используется для обеспечения синхронизации потоков, чтобы предотвратить состояние гонки (race condition) и обеспечить корректное выполнение многопоточных программ. Давайте разберем, как работает synchronized, и рассмотрим альтернативные механизмы синхронизации.
Ключевое слово synchronized может использоваться для синхронизации методов или блоков кода. Оно гарантирует, что только один поток может выполнять синхронизированный метод или блок кода одновременно.
Когда метод объявлен как synchronized, он блокирует доступ к этому методу для всех потоков, кроме одного. Это достигается за счет использования монитора объекта, на котором вызывается метод.
Пример:
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
В этом примере методы increment и getCount синхронизированы, что гарантирует, что только один поток может выполнять их одновременно.
Синхронизация блока кода позволяет более гибко управлять синхронизацией, так как можно указать объект, на котором будет происходить блокировка.
Пример:
public class Counter {
private int count = 0;
private final Object lock = new Object();
public void increment() {
synchronized (lock) {
count++;
}
}
public int getCount() {
synchronized (lock) {
return count;
}
}
}
В этом примере синхронизация происходит на объекте lock, что позволяет более точно управлять блокировками.
ReentrantLock — это класс из пакета java.util.concurrent.locks, который предоставляет более гибкие возможности синхронизации по сравнению с synchronized. Он поддерживает повторный захват блокировки, тайм-ауты, прерываемые блокировки и другие функции.
Пример:
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public 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() {
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
}
В этом примере используется ReentrantLock для синхронизации доступа к полю count.
ReadWriteLock — это интерфейс, который предоставляет разделяемые блокировки для чтения и эксклюзивные блокировки для записи. Это позволяет нескольким потокам одновременно читать данные, но только одному потоку — записывать.
Пример:
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Counter {
private int count = 0;
private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
public void increment() {
rwLock.writeLock().lock();
try {
count++;
} finally {
rwLock.writeLock().unlock();
}
}
public int getCount() {
rwLock.readLock().lock();
try {
return count;
} finally {
rwLock.readLock().unlock();
}
}
}
В этом примере используется ReadWriteLock для оптимизации доступа к полю count: несколько потоков могут одновременно читать данные, но только один поток может изменять их.
StampedLock — это еще один механизм синхронизации, который предоставляет оптимистичные блокировки для чтения и эксклюзивные блокировки для записи. Он может быть более производительным, чем ReadWriteLock, в некоторых сценариях.
Пример:
import java.util.concurrent.locks.StampedLock;
public class Counter {
private int count = 0;
private final StampedLock stampedLock = new StampedLock();
public void increment() {
long stamp = stampedLock.writeLock();
try {
count++;
} finally {
stampedLock.unlockWrite(stamp);
}
}
public int getCount() {
long stamp = stampedLock.tryOptimisticRead();
int currentCount = count;
if (!stampedLock.validate(stamp)) {
stamp = stampedLock.readLock();
try {
currentCount = count;
} finally {
stampedLock.unlockRead(stamp);
}
}
return currentCount;
}
}
В этом примере используется StampedLock для оптимизации доступа к полю count.
Атомарные классы из пакета java.util.concurrent.atomic предоставляют атомарные операции над переменными, что позволяет избежать использования блокировок.
Пример:
import java.util.concurrent.atomic.AtomicInteger;
public class Counter {
private final AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet();
}
public int getCount() {
return count.get();
}
}
В этом примере используется AtomicInteger для атомарного увеличения и получения значения счетчика.
| Механизм | Преимущества | Недостатки |
|---|---|---|
| synchronized | Простота использования. | Меньшая гибкость по сравнению с другими механизмами. |
| ReentrantLock | Гибкость (тайм-ауты, прерываемые блокировки). | Требует явного управления блокировками. |
| ReadWriteLock | Оптимизация для чтения (множество потоков могут читать одновременно). | Меньшая производительность при частых записях. |
| StampedLock | Высокая производительность в некоторых сценариях. | Более сложный API. |
| Атомарные классы | Высокая производительность для простых операций. | Подходит только для простых сценариев. |
synchronized — это базовый механизм синхронизации, который прост в использовании, но менее гибок.ReentrantLock — предоставляет более гибкие возможности синхронизации.ReadWriteLock — оптимизирован для сценариев с частым чтением и редкой записью.StampedLock — предоставляет оптимистичные блокировки и может быть более производительным.Выбор механизма синхронизации зависит от требований вашего приложения. Для простых сценариев достаточно synchronized, но для более сложных случаев лучше использовать альтернативные механизмы, такие как ReentrantLock, ReadWriteLock или атомарные классы.