Använder flyktigt

"Hej, Amigo!"

"Hej Ellie!"

"Jag vill berätta om den flyktiga modifieraren. Vet du vad det är?"

"Något med trådar att göra. Jag minns inte exakt."

"Lyssna sedan upp. Här är några tekniska detaljer för dig:"

"En dator har två typer av minne: globalt (vanligt) minne och minne inbyggt i processorn. Det inbyggda processorminnet är uppdelat i register, en förstanivåcache (L1), andranivåcache (L2) och tredje nivån (L3)."

"Dessa typer av minne har olika hastigheter. Det snabbaste och minsta minnet är registren, sedan processorcachen (L1, L2, L3) och slutligen det globala minnet (det långsammaste)."

"Globalt minne och processorcache fungerar med väldigt olika hastigheter, så Java-maskinen tillåter varje tråd att lagra de mest använda variablerna i det lokala trådminnet (i processorcachen)."

"Kan den här processen på något sätt kontrolleras?"

"Inte riktigt. Allt arbete görs av Java-maskinen. Den är väldigt intelligent när det gäller att optimera prestanda."

"Men det är därför jag berättar det här. Det finns ett litet problem. När två trådar arbetar med samma variabel kan var och en lagra en kopia i sin egen lokala cache. Och sedan kan en tråd ändra variabeln, men den andra kanske inte ser ändringen, eftersom den fortfarande arbetar med sin egen kopia av variabeln."

"Jaha, vad kan man göra då?"

"Javas skapare tillhandahöll ett speciellt nyckelord för den här situationen: volatil. Om en variabel nås från olika trådar måste du markera den med den flyktiga modifieraren, så att Java-maskinen inte lägger den i cachen. Så här brukar det vara utseende:"

public volatile int count = 0;

"Åh, jag minns. Du har redan nämnt det här. Jag vet redan det här."

"Visst gör du det. Men du kom ihåg det först när jag berättade det."

"Eh, ja, jag har glömt lite."

"Repetition är lärandets moder!"

"Här är några nya fakta om den flyktiga modifieraren. Den flyktiga modifieraren garanterar bara att variabeln kommer att läsas och skrivas säkert. Den garanterar inte att den kommer att ändras säkert."

"Vad är skillnaden?"

"Titta på hur en variabel ändras:"

count++

register = count;

register = register+1;

count = register;

"Wow! Så alla variabler ändras bara i processorn?"

"Japp."

"Och värdena kopieras fram och tillbaka: från minnet till processorn och tillbaka?"

"Japp."

"Den flyktiga modifieraren garanterar att när variabelräkningen nås kommer den att läsas från minnet (steg 1). Och om en tråd vill tilldela ett nytt värde kommer det definitivt att finnas i det globala minnet (steg 3)."

"Men Java-maskinen garanterar inte att det inte blir någon tråd som växlar mellan steg 1 och 3."

"Så, att öka variabeln med 1 är faktiskt tre operationer?"

"Ja."

"Och om två trådar samtidigt vill köra count++, kan de störa varandra?"

"Ja, kolla upp det:"

register1 = count;
register1++;
count = register1;

register2 = count;
register2++;
count = register2;

register1 = count;
register2 = count;
register2++;
count = register2;
register1++;
count = register1;

"Så du kan komma åt variabeln, men det är fortfarande riskabelt att ändra den?"

"Tja, du kan ändra det, var bara försiktig ☺"

"Hur?"

" synkroniserad  är vår bästa vän."

"Jag förstår."