धागे स्वतंत्र नाहीत! समक्रमित!

"हॅलो, अमिगो! आमच्याकडे रामबाण उपाय आहे-सर्व रोगांवर उपचार. जसे आपण आधीच पाहिले आहे की, अनियंत्रित थ्रेड स्विचिंग ही एक समस्या आहे."

"पुढील थ्रेडवर कधी स्विच करायचे हे थ्रेड्स स्वतःच का ठरवू शकत नाहीत? त्यांना जे काही करायचे आहे ते करा आणि मग सिग्नल करा, «मी पूर्ण झाले!»?"

"स्विचिंग नियंत्रित करण्यासाठी थ्रेड्सना स्वत: ला परवानगी देणे ही आणखी मोठी समस्या असेल. समजा तुमच्याकडे काही चुकीचे लिहिलेले कोड आहे, आणि थ्रेड कधीही CPU सरेंडर करत नाही. पूर्वीच्या दिवसात, हे असेच चालले होते. आणि ते एक भयानक स्वप्न होते."

"ठीक आहे. मग उपाय काय?"

" इतर थ्रेड ब्लॉक करत आहे.  हे असेच काम करते."

हे स्पष्ट झाले की जेव्हा ते सामायिक केलेल्या वस्तू आणि/किंवा संसाधने वापरण्याचा प्रयत्न करतात तेव्हा थ्रेड एकमेकांमध्ये हस्तक्षेप करतात . जसे आपण कन्सोल आउटपुटसह उदाहरणात पाहिले: तेथे एक कन्सोल आहे आणि सर्व थ्रेड्स आउटपुट आहेत. तो गोंधळलेला आहे.

म्हणून एका विशेष वस्तूचा शोध लावला गेला: म्यूटेक्स . हे बाथरूमच्या दारावरील चिन्हासारखे आहे जे "उपलब्ध / व्यापलेले" असे म्हणतात . त्याच्या दोन अवस्था आहेत: ऑब्जेक्ट उपलब्ध आहे किंवा व्यापलेला आहे . या राज्यांना "लॉक केलेले" आणि "अनलॉक केलेले" देखील म्हणतात.

जेव्हा थ्रेडला इतर थ्रेडसह सामायिक केलेल्या ऑब्जेक्टची आवश्यकता असते, तेव्हा ते ऑब्जेक्टशी संबंधित म्यूटेक्स तपासते. जर म्यूटेक्स अनलॉक केले असेल, तर थ्रेड लॉक करतो (त्याला «व्याप्त» म्हणून चिन्हांकित करतो) आणि सामायिक संसाधन वापरण्यास प्रारंभ करतो. थ्रेडने त्याचा व्यवसाय केल्यानंतर, म्यूटेक्स अनलॉक केला जातो (“उपलब्ध” म्हणून चिन्हांकित).

जर थ्रेडला ऑब्जेक्ट वापरायचा असेल आणि म्यूटेक्स लॉक केले असेल, तर थ्रेड प्रतीक्षा करत असताना झोपतो. जेव्हा म्युटेक्स शेवटी व्यापलेल्या थ्रेडद्वारे अनलॉक केले जाते, तेव्हा आमचा थ्रेड ताबडतोब लॉक करेल आणि चालू होईल. बाथरूमच्या दरवाजाच्या चिन्हासह साधर्म्य योग्य आहे.

"मग मी म्युटेक्ससह कसे कार्य करू? मला विशेष वस्तू तयार करण्याची आवश्यकता आहे का?"

"हे त्यापेक्षा खूप सोपे आहे. Java च्या निर्मात्यांनी हे म्युटेक्स ऑब्जेक्ट क्लासमध्ये तयार केले आहे. त्यामुळे तुम्हाला ते तयार करण्याचीही गरज नाही. हा प्रत्येक ऑब्जेक्टचा भाग आहे. हे सर्व कसे कार्य करते ते येथे आहे:"

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;

समक्रमित कीवर्डकडे लक्ष द्या  .

"हं, म्हणजे काय?"

"जेव्हा थ्रेड सिंक्रोनाइझ म्हणून चिन्हांकित केलेल्या कोडच्या ब्लॉकमध्ये प्रवेश करतो, तेव्हा जावा मशीन कंसात दर्शविलेल्या ऑब्जेक्टचे म्यूटेक्स शब्द समक्रमित केल्यानंतर ताबडतोब लॉक करते. आमचा थ्रेड सोडत नाही तोपर्यंत दुसरा कोणताही थ्रेड या ब्लॉकमध्ये प्रवेश करू शकत नाही. आमचा धागा निघताच ब्लॉक सिंक्रोनाइझ म्हणून चिन्हांकित केले, म्युटेक्स ताबडतोब आणि आपोआप अनलॉक केले जाते आणि दुसर्या थ्रेडद्वारे प्राप्त करण्यासाठी उपलब्ध असेल."

जर म्युटेक्स व्यापलेला असेल, तर आमचा धागा स्थिर राहील आणि तो मोकळा होण्याची प्रतीक्षा करेल.

"इतकं साधं आणि मोहक. हा एक सुंदर उपाय आहे."

"हो. पण या प्रकरणात काय होईल असे वाटते?"

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;
}
}
}

एका थ्रेडने स्वॅप पद्धत कॉल केल्यास आणि दुसर्‍या थ्रेडने swap2 पद्धत कॉल केल्यास काय होईल?

"म्युटेक्स समान असल्याने, पहिल्या थ्रेडने सिंक्रोनाइझ ब्लॉक सोडेपर्यंत दुसऱ्या थ्रेडला थांबावे लागेल. त्यामुळे एकाचवेळी प्रवेश करताना कोणतीही समस्या येणार नाही."

"शाबास, अमिगो! तेच बरोबर उत्तर आहे!"

आता मी हे निदर्शनास आणू इच्छितो की सिंक्रोनाइझचा वापर केवळ कोडचे ब्लॉकच नव्हे तर पद्धती देखील चिन्हांकित करण्यासाठी केला जाऊ शकतो. याचा अर्थ येथे आहे:

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;
}
}