Illékony használata

– Szia Amigo!

– Szia, Ellie!

"Az illékony módosítóról szeretnék beszélni. Tudod, mi az?"

– Valami a szálakkal kapcsolatos. Nem emlékszem pontosan.

"Akkor figyeljen. Íme néhány technikai részlet:"

"A számítógépben kétféle memória van: globális (közönséges) memória és a processzorba épített memória. A beépített processzormemória regiszterekre, első szintű gyorsítótárra (L1), második szintű gyorsítótárra (L2), ill. harmadik szint (L3).

"Az ilyen típusú memóriák különböző sebességűek. A leggyorsabb és legkisebb memória a regiszterek, majd a processzor gyorsítótára (L1, L2, L3), végül a globális memória (a leglassabb)."

"A globális memória és a processzor gyorsítótár vadul eltérő sebességgel működik, így a Java gép lehetővé teszi, hogy minden szál a leggyakrabban használt változókat tárolja a helyi szálmemóriában (a processzor gyorsítótárában)."

– Ezt a folyamatot lehet valahogy irányítani?

"Nem igazán. Minden munkát a Java gép végzi. Nagyon intelligens, ha a teljesítmény optimalizálásáról van szó."

"De ezért mondom ezt el. Van egy kis probléma. Amikor két szál ugyanazzal a változóval dolgozik, mindegyik el tudja tárolni a másolatot a saját helyi gyorsítótárában. És akkor az egyik szál megváltoztathatja a változót, de a második Lehet, hogy nem látja a változást, mert továbbra is a változó saját példányával dolgozik."

– Nos, akkor mit lehet tenni?

"A Java készítői erre a helyzetre egy speciális kulcsszót adtak: volatile. Ha egy változót különböző szálakból érnek el, akkor azt a volatile módosítóval kell megjelölni, így a Java gép nem teszi be a gyorsítótárba. Ez általában így történik. úgy néz ki:"

public volatile int count = 0;

"Ó, emlékszem. Ezt már említetted. Ezt már tudom."

– Persze, hogy igen. De csak akkor emlékeztél rá, amikor elmondtam.

– Ööö, hát egy kicsit elfelejtettem.

"Az ismétlés a tanulás anyja!"

"Íme néhány új tény az illékony módosítóról. Az illékony módosító csak azt garantálja, hogy a változó biztonságosan olvasható és írható lesz. Nem garantálja, hogy biztonságosan módosítható lesz."

"Mi a különbség?"

"Nézd meg, hogyan változik a változó:"

count++

register = count;

register = register+1;

count = register;

"Wow! Tehát minden változó csak a processzorban változik?"

"Igen."

"És az értékeket oda-vissza másolják: a memóriából a processzorba és vissza?"

"Igen."

"Az illékony módosító garantálja, hogy a változószám elérésekor a memóriából kerül kiolvasásra (1. lépés). Ha pedig egy szál új értéket akar hozzárendelni, az mindenképpen a globális memóriában lesz (3. lépés)."

"A Java gép azonban nem garantálja, hogy nem lesz szálváltás az 1. és 3. lépés között."

"Tehát a változó 1-gyel történő növelése valójában három művelet?"

"Igen."

"És ha két szál egyszerre akarja végrehajtani a count++-t, akkor zavarhatják egymást?"

"Igen, nézd meg:"

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

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

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

"Szóval, hozzáférhet a változóhoz, de megváltoztatni még mindig kockázatos?"

"Nos, megváltoztathatod, csak óvatosan ☺"

"Hogyan?"

" A szinkronizált  a legjobb barátunk."

"Látom."