Ang mga thread ay hindi independyente! Naka-synchronize!

"Hello, Amigo! Mayroon tayong panlunas sa lahat—lunas sa lahat ng sakit. Gaya ng nakita na natin, problema ang uncontrolled thread switching."

"Bakit hindi makapagpasya ang mga thread mismo kung kailan lilipat sa susunod na thread? Gawin ang lahat ng kailangan nilang gawin at pagkatapos ay magsenyas, «Tapos na ako!»?"

"Ang pagpayag sa mga thread mismo na kontrolin ang paglipat ay magiging isang mas malaking problema. Ipagpalagay na mayroon kang ilang hindi magandang nakasulat na code, at hindi kailanman isinusuko ng thread ang CPU. Noong araw, ganito ito gumana. At ito ay isang bangungot."

"Okay. So anong solusyon?"

" Bina-block ang ibang mga thread.  Ganito ito gumagana."

Naging malinaw na ang mga thread ay nakakasagabal sa isa't isa kapag sinubukan nilang gumamit ng mga nakabahaging bagay at/o mapagkukunan . Tulad ng nakita natin sa halimbawa na may console output: mayroong isang console at lahat ng thread na output dito. Ang gulo.

Kaya isang espesyal na bagay ang naimbento: ang mutex . Para itong karatula sa pintuan ng banyo na nagsasabing «available / occupied» . Mayroon itong dalawang estado: ang bagay ay magagamit o inookupahan . Ang mga estadong ito ay tinatawag ding «naka-lock» at «naka-unlock».

Kapag ang isang thread ay nangangailangan ng isang bagay na ibinahagi sa iba pang mga thread, sinusuri nito ang mutex na nauugnay sa bagay. Kung ang mutex ay na-unlock, pagkatapos ay i-lock ito ng thread (markahan ito bilang "okupado") at magsisimulang gamitin ang nakabahaging mapagkukunan. Matapos magawa ng thread ang negosyo nito, ma-unlock ang mutex (minarkahan bilang «available»).

Kung gustong gamitin ng thread ang object at naka-lock ang mutex, matutulog ang thread habang naghihintay ito. Kapag ang mutex ay tuluyang na-unlock ng occupying thread, agad itong i-lock ng aming thread at magsisimulang tumakbo. Ang pagkakatulad sa isang sign ng pinto ng banyo ay perpekto.

"Kaya paano ako gagana sa isang mutex? Kailangan ko bang lumikha ng mga espesyal na bagay?"

"Mas simple ito kaysa doon. Binuo ng mga tagalikha ng Java ang mutex na ito sa klase ng Object. Kaya hindi mo na kailangang gawin ito. Bahagi ito ng bawat bagay. Narito kung paano gumagana ang lahat:"

class MyClass
{
private String name1 = "Ally";
private String name2 = "Lena";

public void swap()
{
synchronized (this)
{
String s = name1;
name1 = name2;
name2 = s;
}
}
}

String s1 = name1; //Ally
name1 = name2; //Lena
name2 = s1; //Ally

String s2 = name1; //Lena
name1 = name2; //Ally
name2 = s2; //Lena

String s1 = name1;
name1 = name2;
//other thread is running
name2 = s1;

//the thread waits until the mutex is unlocked

String s2 = name1;
name1 = name2;
//other thread is running
//other thread is running
name2 = s2;

Bigyang-pansin ang keyword  na naka-synchronize .

"Oo, ano ang ibig sabihin nito?"

"Kapag ang isang thread ay pumasok sa isang bloke ng code na minarkahan bilang naka-synchronize, ang Java machine ay agad na nagla-lock sa mutex ng bagay na nakasaad sa mga panaklong pagkatapos ng salitang naka-synchronize. Walang ibang thread ang makakapasok sa block na ito hanggang sa ang aming thread ay umalis dito. Sa sandaling umalis ang aming thread ang block na minarkahan ay naka-synchronize, ang mutex ay kaagad at awtomatikong na-unlock at magiging available para makuha ng isa pang thread."

Kung ang mutex ay okupado, pagkatapos ay ang aming thread ay tatayo at maghintay para sa ito upang malaya.

"So simple and so elegant. That's a beautiful solution."

"Oo. Pero ano sa tingin mo ang mangyayari sa kasong ito?"

class MyClass
{
private String name1 = "Ally";
private String name2 = "Lena";

public void swap()
{
synchronized (this)
{
String s = name1;
name1 = name2;
name2 = s;
}
}

public void swap2()
{
synchronized (this)
{
String s = name1;
name1 = name2;
name2 = s;
}
}
}

Ano ang mangyayari kung ang isang thread ay tumawag sa swap method at isa pang thread ang tumawag sa swap2 method?

"Dahil ang mutex ay pareho, ang pangalawang thread ay kailangang maghintay hanggang ang unang thread ay umalis sa naka-synchronize na bloke. Kaya walang anumang mga problema sa sabay-sabay na pag-access."

"Magaling, Amigo! Iyan ang tamang sagot!"

Ngayon ay nais kong ituro na ang naka-synchronize ay maaaring gamitin upang markahan hindi lamang ang mga bloke ng code, kundi pati na rin ang mga pamamaraan. Narito ang ibig sabihin nito:

class MyClass
{
private static String name1 = "Ally";
private static String name2 = "Lena";

public synchronized void swap()
{
String s = name1;
name1 = name2;
name2 = s;
}

public static synchronized void swap2()
{
String s = name1;
name1 = name2;
name2 = s;
}
}

class MyClass
{
private static String name1 = "Ally";
private static String name2 = "Lena";

public void swap()
{
synchronized (this)
{
String s = name1;
name1 = name2;
name2 = s;
}
}

public static void swap2()
{
synchronized (MyClass.class)
{
String s = name1;
name1 = name2;
name2 = s;
}
}