బహుళ థ్రెడ్ నమూనాలు

3.1 సక్రియ వస్తువు

యాక్టివ్ ఆబ్జెక్ట్ అనేది ఒక పద్ధతి యొక్క ఎగ్జిక్యూషన్ థ్రెడ్‌ను అది పిలిచే థ్రెడ్ నుండి వేరు చేసే డిజైన్ నమూనా. ఈ నమూనా యొక్క ఉద్దేశ్యం అసమకాలిక పద్ధతి కాల్‌లు మరియు అభ్యర్థన ప్రాసెసింగ్ షెడ్యూలర్‌ని ఉపయోగించి సమాంతర అమలును అందించడం.

సరళీకృత సంస్కరణ:

క్లాసిక్ వేరియంట్:

ఈ టెంప్లేట్‌లో ఆరు అంశాలు ఉన్నాయి:

• క్లయింట్ యొక్క పబ్లిక్ పద్ధతులకు ఇంటర్‌ఫేస్‌ను అందించే ప్రాక్సీ వస్తువు.
• క్రియాశీల వస్తువు కోసం యాక్సెస్ పద్ధతులను నిర్వచించే ఇంటర్‌ఫేస్.
• క్లయింట్ల నుండి వచ్చే అభ్యర్థనల జాబితా.
• ప్రశ్నలను ఏ క్రమంలో అమలు చేయాలో నిర్ణయించే షెడ్యూలర్.
• క్రియాశీల వస్తువు పద్ధతుల అమలు.
• క్లయింట్ ఫలితాన్ని స్వీకరించడానికి కాల్ బ్యాక్ విధానం లేదా వేరియబుల్.

3.2 లాక్

లాక్ నమూనా అనేది సమకాలీకరణ విధానం, ఇది బహుళ థ్రెడ్‌ల మధ్య భాగస్వామ్య వనరుకు ప్రత్యేక ప్రాప్యతను అనుమతిస్తుంది. కాన్‌కరెన్సీ నియంత్రణ విధానాన్ని అమలు చేయడానికి తాళాలు ఒక మార్గం.

ప్రాథమికంగా, ఒక సాఫ్ట్ లాక్ ఉపయోగించబడుతుంది, ప్రతి థ్రెడ్ సంబంధిత భాగస్వామ్య వనరును యాక్సెస్ చేయడానికి ముందు "లాక్‌ను పొందేందుకు" ప్రయత్నిస్తుంది.

అయినప్పటికీ, కొన్ని సిస్టమ్‌లు తప్పనిసరి లాకింగ్ మెకానిజమ్‌ను అందిస్తాయి, దీని ద్వారా లాక్ చేయబడిన వనరుకి అనధికారిక యాక్సెస్ ప్రయత్నం యాక్సెస్ పొందడానికి ప్రయత్నించిన థ్రెడ్‌పై మినహాయింపును విసిరివేయడం ద్వారా రద్దు చేయబడుతుంది.

సెమాఫోర్ అనేది సరళమైన లాక్ రకం. డేటా యాక్సెస్ పరంగా, యాక్సెస్ మోడ్‌ల మధ్య ఎటువంటి భేదం లేదు: భాగస్వామ్యం (చదవడానికి-మాత్రమే) లేదా ప్రత్యేకమైన (చదవడానికి-వ్రాయడానికి). షేర్డ్ మోడ్‌లో, రీడ్-ఓన్లీ మోడ్‌లో డేటాను యాక్సెస్ చేయడానికి బహుళ థ్రెడ్‌లు లాక్‌ని అభ్యర్థించవచ్చు. అప్‌డేట్ మరియు డిలీట్ అల్గారిథమ్‌లలో కూడా ప్రత్యేకమైన యాక్సెస్ మోడ్ ఉపయోగించబడుతుంది.

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

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

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

3.3 మానిటర్

మానిటర్ నమూనా అనేది భాగస్వామ్య వనరులకు ప్రాప్యతను అందించే ఉన్నత-స్థాయి ప్రక్రియ పరస్పర చర్య మరియు సమకాలీకరణ విధానం. సాధారణ వనరు, సాధారణంగా హార్డ్‌వేర్ లేదా వేరియబుల్స్ సమితిని ఉపయోగించి రెండు లేదా అంతకంటే ఎక్కువ కంప్యూటర్ టాస్క్‌లను సింక్రొనైజ్ చేసే విధానం.

మానిటర్-ఆధారిత మల్టీ టాస్కింగ్‌లో, కంపైలర్ లేదా ఇంటర్‌ప్రెటర్ లాక్-అన్‌లాక్ కోడ్‌ను సముచితంగా ఫార్మాట్ చేసిన రొటీన్‌లలోకి చొప్పించారు, పారదర్శకంగా ప్రోగ్రామర్‌కు, ప్రోగ్రామర్‌ను సింక్రొనైజేషన్ ప్రిమిటివ్‌లను స్పష్టంగా కాల్ చేయకుండా కాపాడుతుంది.

మానిటర్ వీటిని కలిగి ఉంటుంది:

• భాగస్వామ్య వనరుతో పరస్పర చర్య చేసే విధానాల సమితి
• మ్యూటెక్స్
• ఈ వనరుతో అనుబంధించబడిన వేరియబుల్స్
• జాతి పరిస్థితిని నివారించడానికి పరిస్థితులను నిర్వచించే మార్పులేనిది

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

ఈ విధంగా సమకాలీకరించబడినwait() ఆపరేటర్ జావాలో మరియు పద్ధతులతో పని చేస్తుంది notify().

3.4 లాకింగ్‌ను రెండుసార్లు తనిఖీ చేయండి

రెండుసార్లు తనిఖీ చేసిన లాకింగ్ అనేది లాక్‌ని పొందే ఓవర్‌హెడ్‌ను తగ్గించడానికి ఉద్దేశించిన సమాంతర డిజైన్ నమూనా.

మొదట, నిరోధించే పరిస్థితి ఏ సమకాలీకరణ లేకుండా తనిఖీ చేయబడుతుంది. ఒక థ్రెడ్ లాక్‌ని పొందాలని చెక్ యొక్క ఫలితం సూచించినట్లయితే మాత్రమే లాక్‌ని పొందేందుకు ప్రయత్నిస్తుంది.

//Double-Checked Locking
public final class Singleton {
private static Singleton instance; //Don't forget volatile modifier

public static Singleton getInstance() {
     if (instance == null) {                //Read

         synchronized (Singleton.class) {    //
             if (instance == null) {         //Read Write
                 instance = new Singleton(); //
             }
         }
     }
 }

థ్రెడ్-సురక్షిత వాతావరణంలో సింగిల్టన్ వస్తువును ఎలా సృష్టించాలి?

public static Singleton getInstance() {
   if (instance == null)
    instance = new Singleton();
}

మీరు వేర్వేరు థ్రెడ్‌ల నుండి సింగిల్టన్ ఆబ్జెక్ట్‌ను సృష్టిస్తే, అదే సమయంలో అనేక వస్తువులు సృష్టించబడే పరిస్థితి ఉండవచ్చు మరియు ఇది ఆమోదయోగ్యం కాదు. అందువల్ల, ఆబ్జెక్ట్ సృష్టిని సమకాలీకరించబడిన ప్రకటనలో చుట్టడం సహేతుకమైనది.

public static Singleton getInstance() {
    synchronized (Singleton.class) {
        if (instance == null)
        instance = new Singleton();
    }
}

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

public static Singleton getInstance() {
     if (instance != null)
        return instance;

    synchronized (Singleton.class) {
        if (instance == null)
        instance = new Singleton();
    }
}

కొన్ని భాషలు మరియు/లేదా కొన్ని మెషీన్లలో ఈ నమూనాను సురక్షితంగా అమలు చేయడం సాధ్యం కాదు. అందువల్ల, దీనిని కొన్నిసార్లు వ్యతిరేక నమూనా అని పిలుస్తారు. ఇటువంటి లక్షణాలు జావా మెమరీ మోడల్ మరియు C++ మెమరీ మోడల్‌లో "ముందు జరిగేవి" కఠినమైన ఆర్డర్ సంబంధం కనిపించడానికి దారితీశాయి.

సింగిల్టన్ డిజైన్ నమూనా వంటి బహుళ-థ్రెడ్ ప్రోగ్రామ్‌లలో సోమరితనం ప్రారంభించడం యొక్క ఓవర్‌హెడ్‌ను తగ్గించడానికి ఇది సాధారణంగా ఉపయోగించబడుతుంది. వేరియబుల్ యొక్క సోమరితనం ప్రారంభించడంలో, గణనలో వేరియబుల్ విలువ అవసరమయ్యే వరకు ప్రారంభించడం వాయిదా వేయబడుతుంది.

3.5 షెడ్యూలర్

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