మల్టీథ్రెడింగ్: థ్రెడ్ క్లాస్ యొక్క పద్ధతులు ఏమి చేస్తాయి

హాయ్! ఈ రోజు మనం మల్టీథ్రెడింగ్ గురించి మాట్లాడటం కొనసాగిస్తాము. థ్రెడ్ క్లాస్ మరియు దానిలోని కొన్ని పద్ధతులు ఏమి చేస్తాయో పరిశీలిద్దాం. మేము ఇంతకు ముందు తరగతి పద్ధతులను అధ్యయనం చేసినప్పుడు, మేము సాధారణంగా ఇలా వ్రాస్తాము: <పద్ధతి పేరు> -> <పద్ధతి ఏమి చేస్తుంది>. ఇది 's మెథడ్స్‌తో పని చేయదు Thread:) కొన్ని ఉదాహరణలు లేకుండా మీరు గుర్తించలేనంత క్లిష్టమైన లాజిక్‌ని కలిగి ఉన్నారు.

Thread.start() పద్ధతి

మనల్ని మనం పునరావృతం చేయడం ద్వారా ప్రారంభిద్దాం. Threadమీరు బహుశా గుర్తుచేసుకున్నట్లుగా, మీ తరగతిని వారసత్వంగా పొందేలా చేయడం ద్వారా మరియు పద్ధతిని భర్తీ చేయడం ద్వారా మీరు థ్రెడ్‌ను సృష్టించవచ్చు run(). కానీ అది స్వయంగా ప్రారంభించదు. దీన్ని చేయడానికి, మేము మా వస్తువు యొక్క start()పద్ధతిని పిలుస్తాము. మునుపటి పాఠం నుండి ఉదాహరణను గుర్తుచేసుకుందాం:

public class MyFirstThread extends Thread {

   @Override
   public void run() {
       System.out.println("Thread executed: " + getName());
   }
}


public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.start();
       }
   }
}

గమనిక: థ్రెడ్‌ను ప్రారంభించడానికి, మీరు తప్పనిసరిగాstart()కంటే ప్రత్యేక పద్ధతినిrun()! ప్రత్యేకించి మీరు మల్టీథ్రెడింగ్‌ని అధ్యయనం చేయడం ప్రారంభించినప్పుడు ఇది చాలా సులభమైన లోపం. మా ఉదాహరణలో, మీరుrun()పద్ధతికి బదులుగా 10 సార్లుstart(), మీరు దీన్ని పొందుతారు:

public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.run();
       }
   }
}

మా ప్రోగ్రామ్ ఫలితాలను చూడండి: థ్రెడ్ అమలు చేయబడింది: థ్రెడ్-0 థ్రెడ్ అమలు చేయబడింది: థ్రెడ్-1 థ్రెడ్ అమలు చేయబడింది: థ్రెడ్-2 థ్రెడ్ అమలు చేయబడింది: థ్రెడ్-3 థ్రెడ్ అమలు చేయబడింది: థ్రెడ్-4 థ్రెడ్ అమలు చేయబడింది: థ్రెడ్-5 థ్రెడ్ అమలు చేయబడింది: థ్రెడ్ థ్రెడ్ అమలు చేయబడింది: థ్రెడ్-7 థ్రెడ్ అమలు చేయబడింది: థ్రెడ్-8 థ్రెడ్ అమలు చేయబడింది: థ్రెడ్-9 అవుట్‌పుట్ క్రమాన్ని చూడండి: ప్రతిదీ ఖచ్చితమైన క్రమంలో జరుగుతోంది. విచిత్రం, అవునా? మేము దీన్ని అలవాటు చేసుకోలేదు, ఎందుకంటే థ్రెడ్‌లు ఏ క్రమంలో ప్రారంభించబడాలి మరియు అమలు చేయబడతాయి అనేది మా ఆపరేటింగ్ సిస్టమ్‌లోని ఉన్నతమైన మేధస్సు ద్వారా నిర్ణయించబడుతుందని మాకు ఇప్పటికే తెలుసు: థ్రెడ్ షెడ్యూలర్. బహుశా మనం అదృష్టవంతులేనా? వాస్తవానికి, ఇది అదృష్టం గురించి కాదు. మీరు ప్రోగ్రామ్‌ను రెండు సార్లు అమలు చేయడం ద్వారా దీన్ని ధృవీకరించవచ్చు. సమస్య ఏమిటంటే కాల్run()ఈ పద్ధతికి నేరుగా మల్టీథ్రెడింగ్‌తో సంబంధం లేదు. ఈ సందర్భంలో, ప్రోగ్రామ్ మెయిన్ థ్రెడ్‌లో అమలు చేయబడుతుంది, అదే థ్రెడ్ పద్ధతిని అమలు చేస్తుంది main(). ఇది కన్సోల్‌లో వరుసగా 10 లైన్‌లను ప్రింట్ చేస్తుంది మరియు అంతే. 10 థ్రెడ్‌లు ప్రారంభించబడలేదు. కాబట్టి, భవిష్యత్తులో దీన్ని గుర్తుంచుకోండి మరియు నిరంతరం మిమ్మల్ని మీరు తనిఖీ చేసుకోండి. మీరు run()పద్ధతిని పిలవాలనుకుంటే, కాల్ చేయండి start(). మరింత ముందుకు వెళ్దాం.

Thread.sleep() పద్ధతి

ప్రస్తుత థ్రెడ్ యొక్క అమలును కొంతకాలం నిలిపివేయడానికి, మేము sleep()పద్ధతిని ఉపయోగిస్తాము. పద్ధతి sleep()ఒక వాదనగా అనేక మిల్లీసెకన్లను తీసుకుంటుంది, ఇది థ్రెడ్‌ను నిద్రించడానికి ఎంత సమయాన్ని సూచిస్తుంది.

public class Main {

   public static void main(String[] args) throws InterruptedException {

       long start = System.currentTimeMillis();

       Thread.sleep(3000);

       System.out.println(" - How long did I sleep? \n - " + ((System.currentTimeMillis()-start)) / 1000 + " seconds");

   }
}

కన్సోల్ అవుట్‌పుట్: - నేను ఎంతసేపు నిద్రపోయాను? - 3 సెకన్లు గమనిక: పద్ధతి sleep()స్టాటిక్: ఇది ప్రస్తుత థ్రెడ్‌ను నిద్రిస్తుంది. అంటే, ప్రస్తుతం అమలులో ఉన్నది. ఇక్కడ మరొక ముఖ్యమైన విషయం ఉంది: స్లీపింగ్ థ్రెడ్ అంతరాయం కలిగించవచ్చు. ఈ సందర్భంలో, ప్రోగ్రామ్ ఒక విసురుతాడు InterruptedException. మేము దిగువ ఉదాహరణను పరిశీలిస్తాము. మార్గం ద్వారా, థ్రెడ్ మేల్కొన్న తర్వాత ఏమి జరుగుతుంది? ఇది ఆపివేసిన చోట నుండి అమలు చేయడం కొనసాగుతుందా? కాదు. ఒక థ్రెడ్ మేల్కొన్న తర్వాత, అనగా ఒక వాదనగా గడిచిన సమయం గడిచిపోయింది , అది రన్ చేయదగినదిగాThread.sleep() మారుతుందిరాష్ట్రం. కానీ, థ్రెడ్ షెడ్యూలర్ దీన్ని అమలు చేస్తుందని దీని అర్థం కాదు. ఇది కొన్ని ఇతర నాన్-స్లీపింగ్ థ్రెడ్‌కు ప్రాధాన్యతనిస్తుంది మరియు మా తాజాగా మేల్కొన్న థ్రెడ్ దాని పనిని కొంచెం తర్వాత కొనసాగించడానికి అనుమతిస్తుంది. దీన్ని గుర్తుంచుకోండి: మేల్కొలపడం అంటే వెంటనే పనిని కొనసాగించడం కాదు!

Thread.join() పద్ధతి

మరొక థ్రెడ్ పూర్తయ్యే వరకు ఈ join()పద్ధతి ప్రస్తుత థ్రెడ్ యొక్క అమలును నిలిపివేస్తుంది. మనకు 2 థ్రెడ్‌లు ఉంటే, t1మరియు t2, మరియు మేము వ్రాస్తాము

t1.join()

దాని పని పూర్తయ్యే వరకు t2ప్రారంభం కాదు . t1థ్రెడ్‌ల అమలు క్రమానికి హామీ ఇవ్వడానికి ఈ join()పద్ధతిని ఉపయోగించవచ్చు. join()కింది ఉదాహరణలో పద్ధతి ఎలా పనిచేస్తుందో చూద్దాం :

public class ThreadExample extends Thread {

   @Override
   public void run() {

       System.out.println("Thread started: " + getName());

       try {
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("Thread " + getName() + " is finished.");
   }
}


public class Main {

   public static void main(String[] args) throws InterruptedException {

       ThreadExample t1 = new ThreadExample();
       ThreadExample t2 = new ThreadExample();

       t1.start();


 /* The second thread (t2) will start running only after the first thread (t1)
       is finished (or an exception is thrown) */
       try {
           t1.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       t2.start();

       // The main thread will continue running only after t1 and t2 have finished
       try {
           t1.join();
           t2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("All threads have finished. The program is finished.");

   }
}

మేము ఒక సాధారణ ThreadExampleతరగతిని సృష్టించాము. థ్రెడ్ ప్రారంభమైందని సందేశాన్ని ప్రదర్శించడం, 5 సెకన్ల పాటు నిద్రపోవడం, ఆపై పని పూర్తయినట్లు చివరకు నివేదించడం దీని పని. కేకు ముక్క. ప్రధాన తర్కం తరగతిలో ఉంది Main. వ్యాఖ్యలను చూడండి: join()థ్రెడ్‌ల అమలు క్రమాన్ని విజయవంతంగా నిర్వహించడానికి మేము పద్ధతిని ఉపయోగిస్తాము. మేము ఈ అంశాన్ని ఎలా ప్రారంభించామో మీకు గుర్తుంటే, ఎగ్జిక్యూషన్ ఆర్డర్ థ్రెడ్ షెడ్యూలర్ ద్వారా నిర్వహించబడుతుంది. ఇది దాని స్వంత అభీష్టానుసారం థ్రెడ్‌లను నడుపుతుంది: ప్రతిసారీ విభిన్న మార్గంలో. t1థ్రెడ్ మొదట ప్రారంభించబడి, మొదట అమలు చేయబడుతుందని హామీ ఇవ్వడానికి ఇక్కడ మేము పద్ధతిని ఉపయోగిస్తున్నాముt2థ్రెడ్, మరియు ఆ తర్వాత మాత్రమే ప్రోగ్రామ్ యొక్క ప్రధాన థ్రెడ్ కొనసాగుతుంది. వెళ్ళేముందు. నిజమైన ప్రోగ్రామ్‌లలో, మీరు థ్రెడ్ అమలుకు అంతరాయం కలిగించాల్సిన సందర్భాలను మీరు తరచుగా కనుగొంటారు. ఉదాహరణకు, మా థ్రెడ్ అమలులో ఉంది, కానీ ఇది ఒక నిర్దిష్ట ఈవెంట్ లేదా షరతు కోసం వేచి ఉంది. ఇది సంభవించినట్లయితే, అప్పుడు థ్రెడ్ ఆగిపోతుంది. ఏదో ఒక పద్ధతి ఉంటే అది బహుశా అర్ధమే stop(). కానీ అది అంత సులభం కాదు. ఒకప్పుడు, జావా వాస్తవానికి ఒక Thread.stop()పద్ధతిని కలిగి ఉంది మరియు థ్రెడ్‌ను అంతరాయం కలిగించడానికి అనుమతించింది. కానీ తరువాత జావా లైబ్రరీ నుండి తొలగించబడింది. మీరు దీన్ని ఒరాకిల్ డాక్యుమెంటేషన్‌లో కనుగొనవచ్చు మరియు ఇది నిలిపివేయబడినట్లు గుర్తించబడిందని చూడవచ్చు. ఎందుకు? ఎందుకంటే అది ఇంకేమీ చేయకుండా థ్రెడ్‌ను ఆపివేసింది. ఉదాహరణకు, థ్రెడ్ డేటాతో పని చేస్తూ, ఏదో మారుస్తూ ఉండవచ్చు. అప్పుడు దాని పని మధ్యలో అది ఆకస్మికంగా మరియు అనాలోచితంగా stop()పద్ధతి ద్వారా కత్తిరించబడింది. సరైన షట్‌డౌన్ లేకుండా, లేదా వనరుల విడుదల లేకుండా, లోపం నిర్వహణ కూడా లేదు - ఇవేవీ లేవు. కొద్దిగా అతిశయోక్తి చేయడానికి, stop()పద్ధతి దాని మార్గంలో ప్రతిదీ నాశనం చేసింది. ఇది కంప్యూటర్‌ను ఆఫ్ చేయడానికి అవుట్‌లెట్ నుండి పవర్ కార్డ్‌ని లాగడం లాంటిది. అవును, మీరు ఆశించిన ఫలితాన్ని పొందవచ్చు. కానీ రెండు వారాల తర్వాత కంప్యూటర్ ఆ విధంగా వ్యవహరించినందుకు మీకు కృతజ్ఞతలు చెప్పదని అందరికీ తెలుసు. అందుకే జావాలో థ్రెడ్‌లను అంతరాయం కలిగించే తర్కం మార్చబడింది మరియు ఇప్పుడు ప్రత్యేక interrupt()పద్ధతిని ఉపయోగిస్తుంది.

Thread.interrupt() పద్ధతి

interrupt()పద్ధతిని థ్రెడ్‌లో పిలిస్తే ఏమి జరుగుతుంది ? 2 అవకాశాలు ఉన్నాయి:

1. వస్తువు వేచి ఉన్న స్థితిలో ఉన్నట్లయితే, ఉదాహరణకు, joinలేదా sleepపద్ధతుల కారణంగా, అప్పుడు నిరీక్షణకు అంతరాయం ఏర్పడుతుంది మరియు ప్రోగ్రామ్ ఒక త్రో చేస్తుంది InterruptedException.
2. థ్రెడ్ పని చేసే స్థితిలో ఉన్నట్లయితే, interruptedఆబ్జెక్ట్‌పై బూలియన్ ఫ్లాగ్ సెట్ చేయబడుతుంది.

కానీ వస్తువుపై ఈ జెండా విలువను సరిచూసుకుని, మన స్వంత పనిని సరిగ్గా పూర్తి చేయాలి! అందుకే Threadక్లాసులో పద్దతి ఉంది boolean isInterrupted(). ప్రాథమిక కోర్సులో పాఠంలో ఉన్న గడియార ఉదాహరణకి తిరిగి వెళ్దాం. సౌలభ్యం కోసం, మేము దీన్ని కొద్దిగా సరళీకృతం చేసాము:

public class Clock extends Thread {

   public static void main(String[] args) throws InterruptedException {
       Clock clock = new Clock();
       clock.start();

       Thread.sleep(10000);
       clock.interrupt();
   }

   public void run() {
       Thread current = Thread.currentThread();

       while (!current.isInterrupted())
       {
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               System.out.println("The thread was interrupted");
               break;
           }
           System.out.println("Tick");
       }
   }
}

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