థ్రెడ్‌లు స్వతంత్రంగా లేవు! సమకాలీకరించబడింది!

"హలో, అమిగో! మన దగ్గర సర్వరోగ నివారిణి ఉంది-అన్ని వ్యాధులకు నివారణ. మనం ఇప్పటికే చూసినట్లుగా, అనియంత్రిత థ్రెడ్ మార్పిడి సమస్య."

"తదుపరి థ్రెడ్‌కు ఎప్పుడు మారాలో థ్రెడ్‌లు స్వయంగా ఎందుకు నిర్ణయించుకోలేవు? వారు చేయాల్సినవన్నీ చేసి, ఆపై «నేను పూర్తి చేసాను!» అని సంకేతం చేయండి?"

"స్విచింగ్‌ను నియంత్రించడానికి థ్రెడ్‌లను అనుమతించడం మరింత పెద్ద సమస్యగా ఉంటుంది. మీ వద్ద కొన్ని పేలవంగా వ్రాసిన కోడ్ ఉంది మరియు థ్రెడ్ ఎప్పుడూ CPUని అప్పగించదు. ఆరోజున, ఇది ఇలాగే పనిచేసింది. మరియు ఇది చాలా పీడకల."

"సరే. ఐతే పరిష్కారం ఏమిటి?"

" ఇతర థ్రెడ్‌లను నిరోధించడం.  ఇది ఈ విధంగా పనిచేస్తుంది."

భాగస్వామ్య వస్తువులు మరియు/లేదా వనరులను ఉపయోగించడానికి ప్రయత్నించినప్పుడు థ్రెడ్‌లు ఒకదానితో ఒకటి జోక్యం చేసుకుంటాయని స్పష్టమైంది . మేము కన్సోల్ అవుట్‌పుట్‌తో ఉదాహరణలో చూసినట్లే: ఒక కన్సోల్ మరియు దానికి అన్ని థ్రెడ్‌లు అవుట్‌పుట్ ఉన్నాయి. గజిబిజిగా ఉంది.

కాబట్టి ఒక ప్రత్యేక వస్తువు కనుగొనబడింది: మ్యూటెక్స్ . ఇది బాత్రూమ్ తలుపుపై ​​«అందుబాటులో ఉంది / ఆక్రమించబడింది» అని చెప్పే సంకేతం లాంటిది . దీనికి రెండు రాష్ట్రాలు ఉన్నాయి: వస్తువు అందుబాటులో ఉంది లేదా ఆక్రమించబడింది . ఈ రాష్ట్రాలను "లాక్డ్" మరియు "అన్‌లాక్డ్" అని కూడా పిలుస్తారు.

థ్రెడ్‌కు ఇతర థ్రెడ్‌లతో భాగస్వామ్యం చేయబడిన వస్తువు అవసరమైనప్పుడు, అది ఆబ్జెక్ట్‌తో అనుబంధించబడిన మ్యూటెక్స్‌ని తనిఖీ చేస్తుంది. మ్యూటెక్స్ అన్‌లాక్ చేయబడితే, థ్రెడ్ దానిని లాక్ చేస్తుంది (దానిని "ఆక్రమిత" అని గుర్తు చేస్తుంది) మరియు షేర్డ్ రిసోర్స్‌ని ఉపయోగించడం ప్రారంభిస్తుంది. థ్రెడ్ దాని వ్యాపారాన్ని పూర్తి చేసిన తర్వాత, మ్యూటెక్స్ అన్‌లాక్ చేయబడుతుంది (“అందుబాటులో ఉంది” అని గుర్తించబడింది).

థ్రెడ్ ఆబ్జెక్ట్‌ను ఉపయోగించాలనుకుంటే మరియు మ్యూటెక్స్ లాక్ చేయబడి ఉంటే, థ్రెడ్ వేచి ఉన్నప్పుడు నిద్రపోతుంది. ఆక్రమిత థ్రెడ్ ద్వారా మ్యూటెక్స్ చివరకు అన్‌లాక్ చేయబడినప్పుడు, మా థ్రెడ్ వెంటనే దాన్ని లాక్ చేసి రన్ చేయడం ప్రారంభిస్తుంది. బాత్రూమ్ తలుపు గుర్తుతో సారూప్యత ఖచ్చితంగా ఉంది.

"కాబట్టి నేను మ్యూటెక్స్‌తో ఎలా పని చేయాలి? నేను ప్రత్యేక వస్తువులను సృష్టించాలా?"

"ఇది దాని కంటే చాలా సరళమైనది. జావా సృష్టికర్తలు ఈ మ్యూటెక్స్‌ని ఆబ్జెక్ట్ క్లాస్‌లో నిర్మించారు. కాబట్టి మీరు దీన్ని సృష్టించాల్సిన అవసరం లేదు. ఇది ప్రతి వస్తువులో భాగం. ఇది ఎలా పని చేస్తుందో ఇక్కడ ఉంది:"

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