థ్రెడ్ సమకాలీకరణ. సమకాలీకరించబడిన ఆపరేటర్

హాయ్! ఈ రోజు మనం మల్టీథ్రెడ్ ప్రోగ్రామింగ్ యొక్క లక్షణాలను పరిగణలోకి తీసుకుంటాము మరియు థ్రెడ్ సింక్రొనైజేషన్ గురించి మాట్లాడుతాము.

జావాలో సింక్రొనైజేషన్ అంటే ఏమిటి?

ప్రోగ్రామింగ్ డొమైన్ వెలుపల, ఇది రెండు పరికరాలు లేదా ప్రోగ్రామ్‌లు కలిసి పనిచేయడానికి అనుమతించే అమరికను సూచిస్తుంది. ఉదాహరణకు, స్మార్ట్‌ఫోన్ మరియు కంప్యూటర్‌ను Google ఖాతాతో సమకాలీకరించవచ్చు మరియు వెబ్‌సైట్ ఖాతాను సోషల్ నెట్‌వర్క్ ఖాతాలతో సమకాలీకరించవచ్చు, తద్వారా మీరు సైన్ ఇన్ చేయడానికి వాటిని ఉపయోగించవచ్చు. థ్రెడ్ సమకాలీకరణకు ఇదే అర్థం ఉంది: ఇది థ్రెడ్‌లు పరస్పర చర్య చేసే ఏర్పాటు ఒకరికొకరు. మునుపటి పాఠాలలో, మా థ్రెడ్‌లు ఒకదానికొకటి విడివిడిగా జీవించాయి మరియు పని చేశాయి. ఒకరు గణన చేసారు, రెండవవారు నిద్రపోయారు మరియు మూడవవాడు కన్సోల్‌లో ఏదో ప్రదర్శించాడు, కానీ అవి పరస్పర చర్య చేయలేదు. నిజమైన కార్యక్రమాలలో, ఇటువంటి పరిస్థితులు చాలా అరుదు. బహుళ థ్రెడ్‌లు ఒకే డేటా సెట్‌తో చురుకుగా పని చేయగలవు మరియు సవరించగలవు. ఇది సమస్యలను సృష్టిస్తుంది. బహుళ థ్రెడ్‌లు ఒకే ప్రదేశానికి వచనాన్ని వ్రాయడాన్ని ఊహించండి, ఉదాహరణకు, టెక్స్ట్ ఫైల్ లేదా కన్సోల్‌కు. ఈ సందర్భంలో, ఫైల్ లేదా కన్సోల్ భాగస్వామ్య వనరు అవుతుంది. థ్రెడ్‌లు ఒకదానికొకటి ఉనికి గురించి తెలియవు, కాబట్టి అవి థ్రెడ్ షెడ్యూలర్ ద్వారా తమకు కేటాయించిన సమయంలో తాము చేయగలిగినదంతా వ్రాస్తాయి. ఇటీవలి పాఠంలో, ఇది ఎక్కడికి దారితీస్తుందో మేము ఒక ఉదాహరణను చూశాము. దాన్ని ఇప్పుడు గుర్తుచేసుకుందాం: థ్రెడ్‌లు తమ చర్యలను ఒకదానితో ఒకటి సమన్వయం చేసుకోకుండా భాగస్వామ్య వనరుతో (కన్సోల్) పని చేస్తున్నాయి అనే వాస్తవం దీనికి కారణం. థ్రెడ్ షెడ్యూలర్ థ్రెడ్-1కి సమయాన్ని కేటాయిస్తే, అది తక్షణమే ప్రతిదీ కన్సోల్‌కు వ్రాస్తుంది. ఇతర థ్రెడ్‌లు ఏవి కలిగి ఉన్నాయి లేదా ఇప్పటికే వ్రాయలేకపోయాయి అనేది పట్టింపు లేదు. ఫలితం, మీరు చూడగలిగినట్లుగా, నిరుత్సాహపరుస్తుంది. అందుకే వారు మల్టీథ్రెడ్ ప్రోగ్రామింగ్‌కు మ్యూటెక్స్ (మ్యూచువల్ ఎక్స్‌క్లూజన్) అనే ప్రత్యేక భావనను ప్రవేశపెట్టారు. మ్యూటెక్స్ యొక్క ఉద్దేశ్యంఒక నిర్దిష్ట సమయంలో ఒక వస్తువుకు ఒక థ్రెడ్ మాత్రమే యాక్సెస్ ఉండేలా యంత్రాంగాన్ని అందించడం. Thread-1 ఆబ్జెక్ట్ A యొక్క మ్యూటెక్స్‌ను పొందినట్లయితే, ఇతర థ్రెడ్‌లు ఆబ్జెక్ట్‌ను యాక్సెస్ చేయలేవు మరియు సవరించలేవు. వస్తువు A యొక్క మ్యూటెక్స్ విడుదలయ్యే వరకు ఇతర థ్రెడ్‌లు తప్పనిసరిగా వేచి ఉండాలి. జీవితం నుండి ఇక్కడ ఒక ఉదాహరణ ఉంది: మీరు మరియు మరో 10 మంది అపరిచితులు ఒక వ్యాయామంలో పాల్గొంటున్నట్లు ఊహించుకోండి. మలుపులు తీసుకొని, మీరు మీ ఆలోచనలను వ్యక్తపరచాలి మరియు ఏదైనా చర్చించాలి. కానీ మీరు ఒకరినొకరు మొదటిసారి చూస్తున్నందున, నిరంతరం పరస్పరం అంతరాయం కలిగించకుండా మరియు కోపంతో ఎగరకుండా ఉండటానికి, మీరు 'మాట్లాడే బంతి'ని ఉపయోగిస్తారు: బంతి ఉన్న వ్యక్తి మాత్రమే మాట్లాడగలడు. ఈ విధంగా మీరు మంచి మరియు ఫలవంతమైన చర్చను ముగించారు. ముఖ్యంగా, బంతి మ్యూటెక్స్. ఒక వస్తువు యొక్క మ్యూటెక్స్ ఒక థ్రెడ్ చేతిలో ఉంటే, ఇతర థ్రెడ్‌లు ఆ వస్తువుతో పని చేయవు.Objectతరగతి, అంటే జావాలోని ప్రతి వస్తువు ఒకటి ఉంటుంది.

సమకాలీకరించబడిన ఆపరేటర్ ఎలా పని చేస్తుంది

కొత్త కీవర్డ్ గురించి తెలుసుకుందాం: సమకాలీకరించబడింది . ఇది నిర్దిష్ట కోడ్ బ్లాక్‌ను గుర్తించడానికి ఉపయోగించబడుతుంది. కోడ్ బ్లాక్‌ను కీవర్డ్‌తో గుర్తు పెట్టినట్లయితే synchronized, ఆ బ్లాక్‌ని ఒకేసారి ఒక థ్రెడ్ ద్వారా మాత్రమే అమలు చేయవచ్చు. సమకాలీకరణను వివిధ మార్గాల్లో అమలు చేయవచ్చు. ఉదాహరణకు, మొత్తం పద్ధతిని సమకాలీకరించబడాలని ప్రకటించడం ద్వారా:

public synchronized void doSomething() {

   // ...Method logic
}

లేదా ఏదైనా వస్తువును ఉపయోగించి సమకాలీకరణ జరిగే కోడ్ బ్లాక్‌ను వ్రాయండి:

public class Main {

   private Object obj = new Object();

   public void doSomething() {

       // ...Some logic available simultaneously to all threads

       synchronized (obj) {

           // Logic available to just one thread at a time
       }
   }
}

అర్థం సులభం. కీవర్డ్‌తో గుర్తించబడిన కోడ్ బ్లాక్‌లోకి ఒక థ్రెడ్ వెళితే synchronized, అది తక్షణమే ఆబ్జెక్ట్ యొక్క మ్యూటెక్స్‌ను క్యాప్చర్ చేస్తుంది మరియు అదే బ్లాక్ లేదా పద్ధతిని నమోదు చేయడానికి ప్రయత్నిస్తున్న అన్ని ఇతర థ్రెడ్‌లు మునుపటి థ్రెడ్ దాని పనిని పూర్తి చేసి మానిటర్‌ను విడుదల చేసే వరకు వేచి ఉండవలసి వస్తుంది. మార్గం ద్వారా! కోర్సులో, మీరు ఇప్పటికే ఉదాహరణలు చూసారు synchronized, కానీ అవి భిన్నంగా కనిపించాయి:

public void swap()
{
   synchronized (this)
   {
       // ...Method logic
   }
}

టాపిక్ మీకు కొత్తది. మరియు, వాస్తవానికి, వాక్యనిర్మాణంతో గందరగోళం ఉంటుంది. కాబట్టి, వ్రాసే వివిధ మార్గాల ద్వారా తరువాత గందరగోళానికి గురికాకుండా ఉండటానికి వెంటనే దానిని గుర్తుంచుకోండి. వ్రాయడానికి ఈ రెండు మార్గాలు ఒకే విషయాన్ని సూచిస్తాయి:

public void swap() {

   synchronized (this)
   {
       // ...Method logic
   }
}


public synchronized void swap() {

   }
}

మొదటి సందర్భంలో, మీరు పద్ధతిని నమోదు చేసిన వెంటనే కోడ్ యొక్క సమకాలీకరించబడిన బ్లాక్‌ను సృష్టిస్తారు. ఇది వస్తువు ద్వారా సమకాలీకరించబడుతుంది this, అంటే ప్రస్తుత వస్తువు. మరియు రెండవ ఉదాహరణలో, మీరు synchronizedమొత్తం పద్ధతికి కీవర్డ్‌ని వర్తింపజేస్తారు. ఇది సమకాలీకరణ కోసం ఉపయోగించబడుతున్న వస్తువును స్పష్టంగా సూచించడం అనవసరం. మొత్తం పద్ధతి కీవర్డ్‌తో గుర్తించబడినందున, పద్ధతి స్వయంచాలకంగా తరగతిలోని అన్ని సందర్భాలలో సమకాలీకరించబడుతుంది. ఏ మార్గం మంచిది అనే దాని గురించి మేము చర్చలో మునిగిపోము. ప్రస్తుతానికి, మీకు బాగా నచ్చిన మార్గాన్ని ఎంచుకోండి :) ప్రధాన విషయం గుర్తుంచుకోవాలి: మీరు దాని తర్కం అంతా ఒకేసారి ఒక థ్రెడ్ ద్వారా అమలు చేయబడినప్పుడు మాత్రమే సమకాలీకరించబడిన పద్ధతిని ప్రకటించవచ్చు. ఉదాహరణకు, కింది పద్ధతిని సమకాలీకరించడం తప్పు doSomething():

public class Main {

   private Object obj = new Object();

   public void doSomething() {

       // ...Some logic available simultaneously to all threads

       synchronized (obj) {

           // Logic available to just one thread at a time
       }
   }
}

మీరు చూడగలిగినట్లుగా, పద్ధతిలో కొంత భాగం సమకాలీకరణ అవసరం లేని తర్కాన్ని కలిగి ఉంటుంది. ఆ కోడ్‌ని ఒకే సమయంలో బహుళ థ్రెడ్‌ల ద్వారా అమలు చేయవచ్చు మరియు అన్ని క్లిష్టమైన స్థలాలు ప్రత్యేక synchronizedబ్లాక్‌లో వేరుగా ఉంచబడతాయి. మరియు మరొక విషయం. పేరు మార్పిడితో పాఠం నుండి మన ఉదాహరణను నిశితంగా పరిశీలిద్దాం:

public void swap()
{
   synchronized (this)
   {
       // ...Method logic
   }
}

గమనిక: సమకాలీకరణను ఉపయోగించి నిర్వహిస్తారుthis. అంటే, ఒక నిర్దిష్టMyClassవస్తువును ఉపయోగించడం. మనకు 2 థ్రెడ్‌లు (Thread-1మరియుThread-2) మరియు ఒకMyClass myClassవస్తువు మాత్రమే ఉన్నాయని అనుకుందాం. ఈ సందర్భంలో,Thread-1కాల్ చేస్తేmyClass.swap(), ఆబ్జెక్ట్ యొక్క మ్యూటెక్స్ బిజీగా ఉంటుంది మరియు కాల్ చేయడానికి ప్రయత్నించినప్పుడుమ్యూటెక్స్ విడుదలయ్యే వరకు వేచి ఉన్నప్పుడుmyClass.swap()పద్ధతిమనకు 2 థ్రెడ్‌లు మరియు 2 ఆబ్జెక్ట్‌లు (మరియుThread-2ఉంటే, మన థ్రెడ్‌లు వేర్వేరు వస్తువులపై సమకాలీకరించబడిన పద్ధతులను సులభంగా ఏకకాలంలో అమలు చేయగలవు. మొదటి థ్రెడ్ దీన్ని అమలు చేస్తుంది: MyClassmyClass1myClass2

myClass1.swap();

రెండవది దీన్ని అమలు చేస్తుంది:

myClass2.swap();

ఈ సందర్భంలో, నిర్దిష్ట వస్తువును ఉపయోగించి సమకాలీకరణ జరుగుతుంది కాబట్టి, synchronizedపద్ధతిలోని కీవర్డ్ swap()ప్రోగ్రామ్ యొక్క ఆపరేషన్‌ను ప్రభావితం చేయదు. మరియు తరువాతి సందర్భంలో, మనకు 2 వస్తువులు ఉన్నాయి. అందువలన, థ్రెడ్లు ఒకదానికొకటి సమస్యలను సృష్టించవు. అన్నింటికంటే, రెండు వస్తువులు 2 వేర్వేరు మ్యూటెక్స్‌లను కలిగి ఉంటాయి మరియు ఒకదానిని పొందడం అనేది మరొకదానిని పొందకుండా స్వతంత్రంగా ఉంటుంది .

స్టాటిక్ పద్ధతులలో సమకాలీకరణ యొక్క ప్రత్యేక లక్షణాలు

మీరు స్టాటిక్ పద్ధతిని సమకాలీకరించవలసి వస్తే ఏమి చేయాలి ?

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

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

}

మ్యూటెక్స్ ఇక్కడ ఎలాంటి పాత్ర పోషిస్తుందో స్పష్టంగా లేదు. అన్నింటికంటే, ప్రతి వస్తువుకు మ్యూటెక్స్ ఉందని మేము ఇప్పటికే గుర్తించాము. కానీ సమస్య ఏమిటంటే, పద్ధతిని పిలవడానికి మనకు వస్తువులు అవసరం లేదు MyClass.swap(): పద్ధతి స్థిరమైనది! కాబట్టి తదుపరి ఏమిటి? :/ నిజానికి ఇక్కడ ఎలాంటి సమస్య లేదు. Java సృష్టికర్తలు ప్రతిదీ చూసుకున్నారు :) క్లిష్టమైన ఏకకాలిక తర్కాన్ని కలిగి ఉన్న పద్ధతి స్థిరంగా ఉంటే, అప్పుడు సమకాలీకరణ తరగతి స్థాయిలో నిర్వహించబడుతుంది. మరింత స్పష్టత కోసం, మేము పై కోడ్‌ని ఈ క్రింది విధంగా తిరిగి వ్రాయవచ్చు:

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

   public static void swap() {

       synchronized (MyClass.class) {
           String s = name1;
           name1 = name2;
           name2 = s;
       }
   }

}

సూత్రప్రాయంగా, మీరు దీని గురించి మీరే ఆలోచించవచ్చు: వస్తువులు లేనందున, సమకాలీకరణ విధానం ఏదో ఒకవిధంగా తరగతిలోనే కాల్చాలి. మరియు అది అదే మార్గం: మేము సమకాలీకరించడానికి తరగతులను ఉపయోగించవచ్చు.