Paggamit ng volatile

"Hi, Amigo!"

"Hi, Ellie!"

"Gusto kong sabihin sa iyo ang tungkol sa volatile modifier. Alam mo ba kung ano iyon?"

"Something to do with threads. I don't remember exactly."

"Kung gayon, makinig ka. Narito ang ilang teknikal na detalye para sa iyo:"

"Ang isang computer ay may dalawang uri ng memorya: pandaigdigang (ordinaryong) memorya at memorya na binuo sa processor. Ang built-in na memorya ng processor ay nahahati sa mga rehistro, isang first-level na cache (L1), second-level na cache (L2), at ikatlong antas (L3)."

"Ang mga uri ng memorya ay may iba't ibang bilis. Ang pinakamabilis at pinakamaliit na memorya ay ang mga rehistro, pagkatapos ay ang cache ng processor (L1, L2, L3), at panghuli ang pandaigdigang memorya (ang pinakamabagal)."

"Ang pandaigdigang memorya at ang cache ng processor ay gumagana sa ibang bilis, kaya pinapayagan ng Java machine ang bawat thread na mag-imbak ng pinakamadalas na ginagamit na mga variable sa lokal na memorya ng thread (sa cache ng processor)."

"Makokontrol ba ang prosesong ito kahit papaano?"

"Hindi naman. Lahat ng trabaho ay ginagawa ng Java machine. Napakatalino pagdating sa pag-optimize ng performance."

"Ngunit narito kung bakit sinasabi ko ito sa iyo. May isang maliit na problema. Kapag ang dalawang thread ay gumagana sa parehong variable, bawat isa ay maaaring mag-imbak ng isang kopya sa sarili nitong lokal na cache. At pagkatapos ay maaaring baguhin ng isang thread ang variable, ngunit ang pangalawa maaaring hindi makita ang pagbabago, dahil gumagana pa rin ito sa sarili nitong kopya ng variable."

"Well, ano ang maaaring gawin kung gayon?"

"Nagbigay ang mga tagalikha ng Java ng isang espesyal na keyword para sa sitwasyong ito: pabagu-bago ng isip. Kung ang isang variable ay na-access mula sa iba't ibang mga thread, kailangan mong markahan ito ng pabagu-bagong modifier, upang hindi ito ilagay ng Java machine sa cache. Ganito ang karaniwang paraan. mukhang:"

public volatile int count = 0;

"Naku, naalala ko. Nabanggit mo na 'to. Alam ko na 'to."

"Sure you do. Pero naalala mo lang nung sinabi ko sayo."

"Eh, medyo nakalimutan ko."

"Ang pag-uulit ay ang ina ng pag-aaral!"

"Narito ang ilang bagong katotohanan tungkol sa pabagu-bago ng isip. Ginagarantiyahan lamang ng pabagu-bago ng pagbabago na mababasa at masusulat nang ligtas ang variable. Hindi nito ginagarantiyahan na ligtas itong mapapalitan."

"Ano ang pinagkaiba?"

"Tingnan kung paano binago ang variable:"

count++

register = count;

register = register+1;

count = register;

"Wow! So, lahat ng variable ay nababago lang sa processor?"

"Oo."

"At ang mga halaga ay kinopya nang pabalik-balik: mula sa memorya hanggang sa processor at pabalik?"

"Oo."

"Ginagarantiyahan ng pabagu-bagong modifier na kapag na-access ang variable na bilang ay mababasa ito mula sa memorya (hakbang 1). At kung ang isang thread ay gustong magtalaga ng bagong halaga, ito ay tiyak na nasa pandaigdigang memorya (hakbang 3)."

"Ngunit hindi ginagarantiya ng Java machine na hindi magkakaroon ng anumang thread na lilipat sa pagitan ng mga hakbang 1 at 3."

"So, ang pagdaragdag ng variable ng 1 ay talagang tatlong operasyon?"

"Oo."

"At kung ang dalawang thread ay sabay na gustong magsagawa ng count++, kung gayon maaari silang makagambala sa isa't isa?"

"Oo, tingnan mo:"

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

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

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

"Kaya, maaari mong ma-access ang variable, ngunit ang pagbabago nito ay mapanganib pa rin?"

"Well, pwede mo namang palitan, ingat ka lang ☺"

"Paano?"

" synchronized  ang best friend natin."

"Nakita ko."