मल्टीथ्रेडिंग: थ्रेड क्लासच्या पद्धती काय करतात

हाय! आज आपण मल्टीथ्रेडिंगबद्दल बोलू. चला थ्रेड वर्गाचे परीक्षण करूया आणि त्यातील काही पद्धती काय करतात. जेव्हा आम्ही पूर्वी वर्ग पद्धतींचा अभ्यास केला तेव्हा आम्ही सहसा फक्त हे लिहिले: <पद्धतीचे नाव> -> <पद्धत काय करते>. च्या पद्धतींसह हे कार्य करणार नाही 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 थ्रेड कार्यान्वित: थ्रेड-6 थ्रेड निष्पादित: थ्रेड-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()पद्धत असेल तर कदाचित अर्थ प्राप्त होईल. पण ते इतके सोपे नाही. एकेकाळी, Java कडे प्रत्यक्षात एक Thread.stop()पद्धत होती आणि थ्रेडमध्ये व्यत्यय आणण्याची परवानगी होती. पण नंतर ते Java लायब्ररीतून काढून टाकण्यात आले. तुम्ही ते Oracle दस्तऐवजात शोधू शकता आणि ते नापसंत म्हणून चिन्हांकित केले आहे हे पाहू शकता. का? कारण बाकी काही न करता फक्त धागा थांबवला. उदाहरणार्थ, थ्रेड डेटासह कार्य करत असेल आणि काहीतरी बदलत असेल. मग त्याच्या कामाच्या मध्यभागी ते अचानक आणि अनौपचारिकपणे पद्धतीद्वारे कापले गेले 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वर्गाच्या सर्वात महत्त्वाच्या पद्धतींबद्दलचा आमचा परिचय संपतो. शुभेच्छा!