CKTIS / Java
Модел на паметта в Java: happens-before и безопасно публикуване
Научи кои записи могат да видят другите нишки в Java SE 21, какво не гарантира volatile и как работят двойната проверка със заключване и режимите на VarHandle.
Версия: Java SE 21
Синтаксис
private static volatile Payload INSTANCE;
static Payload instance() {
Payload result = INSTANCE;
if (result == null) {
synchronized (Main.class) {
result = INSTANCE;
if (result == null) {
result = new Payload();
INSTANCE = result;
}
}
}
return result;
}Моделът на паметта в Java (JMM) в Java SE 21 определя от кои записи може да идва стойността, прочетена от нишка. Релацията happens-before е транзитивна и произтича от програмния ред в рамките на нишката и от връзките на синхронизация. Освобождаването на монитор предхожда всяко следващо придобиване на същия монитор; запис в поле volatile предхожда всяко следващо четене на същото поле. „Следващо“ означава в реда на синхронизация, а не по часовник. Извикването на start() предхожда действията на стартираната нишка, а те предхождат връщането от join() след завършването ѝ.
Състезание за данни има, когато две нишки достъпват една и съща променлива, поне единият достъп е запис и релацията happens-before не подрежда тези достъпи. Недетерминираното планиране е друго: дори без състезание за данни при различни изпълнения различни нишки могат първи да придобият заключването.
Безопасното публикуване позволява на четящата нишка да види състоянието, записано преди споделянето на обекта. При публикуване чрез volatile запиши референцията след приключването на конструктора, не допускай this да стане достъпно преждевременно и нека получаващата нишка прочете публикуваната референция от същото поле volatile. Други възможности са един и същ монитор за запис и четене или публикуване чрез инициализация на клас. Видимостта не е атомарност: отделните volatile четения и записи са атомарни и за long и double, чиито обикновени достъпи могат да видят половини от различни записи. count++ остава последователност от четене, събиране и запис. Само volatile не защитава инвариант между няколко полета и не прави безопасни по-късните промени в публикувания обект.
При двойна проверка със заключване първо прочети volatile INSTANCE и провери за null извън synchronized: след инициализацията бързият път не придобива монитора. Ако прочетеш null, придобий винаги един и същ монитор Main.class, прочети отново INSTANCE и повтори проверката. Само ако стойността още е null, създай обекта и запиши референцията му в INSTANCE. Заключването предотвратява повторна инициализация; volatile публикува обекта и за бързия път.
В VarHandle режимът plain (get/set) не налага ред между нишките; по подразбиране на 32-битови платформи той не гарантира атомарност за long и double, освен ако документацията на фабричния метод не посочва друго. Opaque (getOpaque/setOpaque) осигурява атомарен и кохерентен достъп до същата променлива, но не публикува други полета. Ако getAcquire наблюдава записа от съответстващия setRelease върху същата променлива, достъпите преди release се подреждат преди достъпите след acquire; изминалото време не е достатъчно. getVolatile/setVolatile добавят пълна наредба между операциите в режим volatile. Избраният режим определя гаранциите: get е plain дори за поле, декларирано като volatile.
Примери
public class Main {
private static volatile Payload INSTANCE;
private static final class Payload {
private int value;
private Payload() {
value = 42;
}
}
static Payload instance() {
Payload result = INSTANCE;
if (result == null) {
synchronized (Main.class) {
result = INSTANCE;
if (result == null) {
result = new Payload();
INSTANCE = result;
}
}
}
return result;
}
public static void main(String[] args) throws InterruptedException {
Payload[] references = new Payload[2];
int[] values = new int[2];
Thread first = new Thread(() -> {
Payload result = instance();
references[0] = result;
values[0] = result.value;
});
Thread second = new Thread(() -> {
Payload result = instance();
references[1] = result;
values[1] = result.value;
});
first.start();
second.start();
first.join();
second.join();
System.out.println("same=" + (references[0] == references[1])
+ ", values=" + values[0] + "/" + values[1]);
}
}Резултат
same=true, values=42/42
Всяка работна нишка сама чете обикновеното поле `value` и записва резултата в отделен елемент на масив. Двете извиквания на `join()` правят резултатите видими за `main`; те не публикуват обекта между работните нишки. Очакваният ред `same=true, values=42/42` не показва коя нишка е инициализирала обекта.
Свързани уроци
- Java · Урок 25 · Напреднало · Версия: 2
- Java · Урок 26 · Напреднало · Версия: 2
- Java · Урок 27 · Напреднало · Версия: 2
- Java · Урок 57 · Напреднало · Версия: 2
Източници
- Java Language Specification, Java SE 21, §17.4 — Memory Model
- Java Language Specification, Java SE 21, §17.4.5 — Happens-before Order
- Java Language Specification, Java SE 21, §17.7 — Non-Atomic Treatment of double and long
- Java Language Specification, Java SE 21, §12.4.2 — Detailed Initialization Procedure
- VarHandle (Java SE 21 & JDK 21)
- Thread (Java SE 21 & JDK 21)