– 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ó:"
Kód | Mi történik valójában: | Leírás |
---|---|---|
|
|
1. lépés: A változószám értékét a rendszer a globális memóriából egy processzorregiszterbe másolja. 2. lépés 3. lépés: |
"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:"
1. szál | 2. szál | Eredmény |
---|---|---|
|
|
|
"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."
GO TO FULL VERSION