जावा मल्टीथ्रेडिंग

आपका स्वागत है! इस लेख में, मैं आपको संक्षेप में प्रक्रियाओं, थ्रेड्स और बहु-थ्रेडेड जावा प्रोग्रामिंग की मूल बातें बताऊंगा।
मल्टीथ्रेडिंग के लिए सबसे स्पष्ट अनुप्रयोग इंटरफ़ेस प्रोग्रामिंग है। मल्टीथ्रेडिंग अपरिहार्य है जब यह आवश्यक है कि ग्राफिकल इंटरफ़ेस कुछ सूचना प्रसंस्करण के दौरान उपयोगकर्ता की कार्रवाई का जवाब देना जारी रखे। उदाहरण के लिए, इंटरफ़ेस के लिए जिम्मेदार थ्रेड इंटरनेट से फ़ाइल डाउनलोड करने वाले दूसरे थ्रेड के पूरा होने की प्रतीक्षा कर सकता है, और साथ ही कुछ एनीमेशन आउटपुट करता है या प्रगति बार को अपडेट करता है। इसके अलावा, यदि रद्द बटन दबाया गया है तो यह डाउनलोड फ़ाइल स्ट्रीम को रोक सकता है।

एक और लोकप्रिय और, शायद, मल्टीथ्रेडिंग के लिए सबसे कट्टर अनुप्रयोगों में से एक खेल है। खेलों में, नेटवर्क, एनीमेशन, भौतिकी गणना आदि के साथ काम करने के लिए विभिन्न धाराएँ जिम्मेदार हो सकती हैं।

चलिए शुरू करते हैं। पहले प्रक्रियाओं के बारे में।

प्रक्रियाओं

एक प्रक्रिया कोड और डेटा का एक संयोजन है जो एक सामान्य वर्चुअल एड्रेस स्पेस साझा करता है। सबसे अधिक बार, एक प्रोग्राम में एक प्रक्रिया होती है, लेकिन अपवाद होते हैं (उदाहरण के लिए, क्रोम ब्राउज़र प्रत्येक टैब के लिए एक अलग प्रक्रिया बनाता है, जो इसे कुछ फायदे देता है, जैसे कि एक दूसरे से टैब की स्वतंत्रता)। प्रक्रियाओं को एक दूसरे से अलग किया जाता है, इसलिए किसी अन्य प्रक्रिया की मेमोरी तक सीधी पहुंच असंभव है (विशेष उपकरणों का उपयोग करके प्रक्रियाओं के बीच बातचीत की जाती है)।

प्रत्येक प्रक्रिया के लिए, OS एक तथाकथित "वर्चुअल एड्रेस स्पेस" बनाता है, जिसमें इस प्रक्रिया की सीधी पहुंच होती है। यह स्थान प्रक्रिया से संबंधित है, इसमें केवल इसका डेटा है और यह अपने पूर्ण निपटान में है। ऑपरेटिंग सिस्टम इस बात के लिए ज़िम्मेदार है कि भौतिक मेमोरी पर प्रक्रिया का आभासी स्थान कैसे पेश किया जाता है।

इस इंटरैक्शन की योजना चित्र में प्रस्तुत की गई है। ऑपरेटिंग सिस्टम तथाकथित मेमोरी पन्नों के साथ संचालित होता है, जो केवल एक निश्चित निश्चित आकार का एक क्षेत्र है। यदि प्रक्रिया अपर्याप्त मेमोरी बन जाती है, तो सिस्टम भौतिक मेमोरी से अतिरिक्त पृष्ठ आवंटित करता है। वर्चुअल मेमोरी पेजों को यादृच्छिक क्रम में भौतिक मेमोरी पर पेश किया जा सकता है।



जब कोई प्रोग्राम शुरू होता है, ऑपरेटिंग सिस्टम अपने एड्रेस स्पेस में एक प्रक्रिया, लोडिंग कोड और प्रोग्राम डेटा बनाता है, और फिर बनाई गई प्रक्रिया के मुख्य सूत्र को शुरू करता है।

धाराओं

एक धागा कोड निष्पादन की एक इकाई है। प्रत्येक थ्रेड क्रमिक रूप से इस प्रक्रिया के निर्देशों को निष्पादित करता है, जो इस प्रक्रिया के अन्य थ्रेड्स के साथ समानांतर में है।

वाक्यांश "अन्य धागों के समानांतर" पर अलग से चर्चा की जानी चाहिए। यह ज्ञात है कि एक प्रोसेसर कोर के लिए, समय के प्रत्येक क्षण में, निष्पादन की एक इकाई होती है। यही है, एक सिंगल-कोर प्रोसेसर केवल निर्देशों को क्रमिक रूप से संसाधित कर सकता है, एक समय में (सरलीकृत मामले में)। हालांकि, सिंगल-कोर प्रोसेसर वाले सिस्टम में कई समानांतर थ्रेड का लॉन्च संभव है। इस मामले में, सिस्टम समय-समय पर थ्रेड्स के बीच स्विच करेगा, वैकल्पिक रूप से एक या दूसरे थ्रेड को निष्पादित करेगा। ऐसी योजना को छद्म समानता कहा जाता है। सिस्टम किसी अन्य थ्रेड पर जाने से पहले प्रत्येक थ्रेड की स्थिति (संदर्भ) को याद करता है, और थ्रेड पर लौटने पर इसे पुनर्स्थापित करता है। प्रवाह संदर्भ में एक स्टैक के रूप में ऐसे पैरामीटर शामिल हैं, प्रोसेसर रजिस्टरों का एक सेट, एक निष्पादन योग्य कमांड का पता, और अधिक ...

सीधे शब्दों में, थ्रेड्स के छद्म समानांतर निष्पादन में, प्रोसेसर को कई थ्रेड्स के निष्पादन के बीच लेबल किया जाता है, उनमें से प्रत्येक के बदले भाग में निष्पादित किया जाता है।

यहाँ यह कैसा दिखता है:



आकृति में रंगीन वर्ग प्रोसेसर के निर्देश हैं (हरे - मुख्य धागे के निर्देश, नीले - पक्ष)। निष्पादन बाएं से दाएं जाता है। साइड स्ट्रीम शुरू होने के बाद, इसके निर्देश मुख्य धारा के निर्देशों के साथ मिश्रित होने लगते हैं। प्रत्येक दृष्टिकोण के लिए निष्पादित निर्देशों की संख्या परिभाषित नहीं है।

तथ्य यह है कि समानांतर थ्रेड निर्देश निष्पादित किए जाते हैं, कुछ मामलों में डेटा एक्सेस टकराव को जन्म दे सकते हैं। अगला लेख थ्रेड इंटरैक्शन की समस्याओं के लिए समर्पित होगा, लेकिन अब के लिए, जावा में थ्रेड कैसे लॉन्च किए जाते हैं ...

चल रहे धागे

प्रत्येक प्रक्रिया में कम से कम एक चलने वाला धागा होता है। जिस धागे से कार्यक्रम शुरू होता है उसे मुख्य कहा जाता है। जावा भाषा में, प्रक्रिया बनाने के बाद, मुख्य थ्रेड का निष्पादन मुख्य () विधि से शुरू होता है। फिर, आवश्यकतानुसार, प्रोग्रामर द्वारा निर्दिष्ट स्थानों में, और जब उसके द्वारा निर्दिष्ट शर्तों को पूरा किया जाता है, तो अन्य पक्ष प्रवाह शुरू हो जाते हैं।

जावा में, थ्रेड क्लास के वंशज के रूप में एक थ्रेड का प्रतिनिधित्व किया जाता है। यह वर्ग मानक प्रवाह तंत्रों को कूटबद्ध करता है।

एक नया सूत्र शुरू करने के दो तरीके हैं:

विधि 1

थ्रेड क्लास का एक ऑब्जेक्ट बनाएं, इसे कंस्ट्रक्टर में कुछ पास करना जो कि रननेबल इंटरफेस को लागू करता है। इस इंटरफ़ेस में रन () विधि है, जिसे नए थ्रेड में निष्पादित किया जाएगा। थ्रेड निष्पादित निष्पादित करता है जब इसकी रन () विधि पूरी होती है।

यह इस तरह दिखता है:

class SomeThing //,   Runnable implements Runnable //(  run()) { public void run() //       { System.out.println("   !"); } } public class Program //   main() { static SomeThing mThing; //mThing -  ,   Runnable public static void main(String[] args) { mThing = new SomeThing(); Thread myThready = new Thread(mThing); //  "myThready" myThready.start(); //  System.out.println("  ..."); } } 

कोड को छोटा बनाने के लिए, आप एक अनाम आंतरिक वर्ग का एक ऑब्जेक्ट पास कर सकते हैं जो थ्रेड क्लास के निर्माता के लिए रननेबल इंटरफ़ेस को लागू करता है:

 public class Program //   main(). { public static void main(String[] args) { //  Thread myThready = new Thread(new Runnable() { public void run() //       { System.out.println("   !"); } }); myThready.start(); //  System.out.println("  ..."); } } 

विधि 2

थ्रेड क्लास का एक वंशज बनाएं और इसकी रन () विधि को ओवरराइड करें:

 class AffableThread extends Thread { @Override public void run() //       { System.out.println("   !"); } } public class Program { static AffableThread mSecondThread; public static void main(String[] args) { mSecondThread = new AffableThread(); //  mSecondThread.start(); //  System.out.println("  ..."); } } 

उपरोक्त उदाहरण में, मुख्य () विधि में, एक और धागा बनाया और शुरू किया गया है। यह ध्यान रखना महत्वपूर्ण है कि mSecondThread.start () विधि को कॉल करने के बाद, मुख्य थ्रेड अपने निष्पादन को जारी रखता है, बिना थ्रेड के पूरा होने के इंतजार के बिना। और वे निर्देश जो प्रारंभ () विधि के बाद आते हैं, mSecondThread थ्रेड निर्देशों के साथ समानांतर में निष्पादित किए जाएंगे।

थ्रेड्स के समानांतर संचालन को प्रदर्शित करने के लिए, आइए एक प्रोग्राम देखें जिसमें दो धागे "एक अंडा या एक चिकन?" से पहले के दार्शनिक प्रश्न के बारे में बहस करते हैं। मुख्य धारा यह सुनिश्चित करती है कि चिकन पहले था, जिसे वह हर सेकंड में रिपोर्ट करेगा। दूसरी धारा, एक बार एक बार, आपके प्रतिद्वंद्वी का खंडन करेगी। कुल मिलाकर, विवाद 5 सेकंड तक चलेगा। आखिरी धारा जो इस पर अपना जवाब बोलती है, इसमें कोई संदेह नहीं है, दार्शनिक सवाल जल जाएगा। उदाहरण उन उपकरणों का उपयोग करता है जिनकी अभी तक चर्चा नहीं की गई है (isAlive () स्लीप () और जॉइन ())। टिप्पणियाँ उन्हें दी जाती हैं, और अधिक विस्तार से उनका विश्लेषण किया जाएगा।

 class EggVoice extends Thread { @Override public void run() { for(int i = 0; i < 5; i++) { try{ sleep(1000); //   1  }catch(InterruptedException e){} System.out.println("!"); } // «»  5  } } public class ChickenVoice //   main() { static EggVoice mAnotherOpinion; //  public static void main(String[] args) { mAnotherOpinion = new EggVoice(); //  System.out.println(" ..."); mAnotherOpinion.start(); //  for(int i = 0; i < 5; i++) { try{ Thread.sleep(1000); //   1  }catch(InterruptedException e){} System.out.println("!"); } // «»  5  if(mAnotherOpinion.isAlive()) //       { try{ mAnotherOpinion.join(); //    . }catch(InterruptedException e){} System.out.println("  !"); } else //     { System.out.println("  !"); } System.out.println(" !"); } } :  ... ! ! ! ! ! ! ! ! ! !   !  ! 

उपरोक्त उदाहरण में, कंसोल के लिए 5 सेकंड आउटपुट जानकारी के समानांतर दो धाराएं। यह सटीक रूप से भविष्यवाणी करना असंभव है कि कौन सी धारा अंतिम बोलना समाप्त कर देगी। आप कोशिश कर सकते हैं, और आप अनुमान भी लगा सकते हैं, लेकिन एक उच्च संभावना है कि अगले लॉन्च में एक ही कार्यक्रम में एक और "विजेता" होगा। यह तथाकथित "अतुल्यकालिक कोड निष्पादन" के कारण है। एसिंक्रोनसी का अर्थ है कि यह तर्क नहीं दिया जा सकता है कि एक धागे का कोई भी निर्देश दूसरे अनुदेश से पहले या बाद में निष्पादित होगा। या, दूसरे शब्दों में, समानांतर धागे एक दूसरे से स्वतंत्र होते हैं, उन मामलों को छोड़कर, जहां प्रोग्रामर स्वयं इसके लिए प्रदान की गई भाषा का उपयोग करते हुए धागे के बीच निर्भरता का वर्णन करता है।

अब प्रक्रियाओं के पूरा होने के बारे में थोड़ा ...

प्रक्रिया को पूरा करने और राक्षसों

जावा में, एक प्रक्रिया समाप्त हो जाती है जब इसका अंतिम धागा समाप्त होता है। भले ही मुख्य () विधि पहले ही पूरी हो गई है, लेकिन इससे उत्पन्न थ्रेड अभी भी निष्पादित हो रहे हैं, सिस्टम उनके पूरा होने की प्रतीक्षा करेगा।

हालांकि, यह नियम एक विशेष प्रकार के धागे - डेमोंस पर लागू नहीं होता है। यदि प्रक्रिया का अंतिम नियमित धागा पूरा हो गया है, और केवल डेमन थ्रेड शेष हैं, तो उन्हें जबरन समाप्त कर दिया जाएगा और प्रक्रिया समाप्त हो जाएगी। सबसे अधिक बार, डेमन थ्रेड्स का उपयोग पृष्ठभूमि कार्यों को करने के लिए किया जाता है जो जीवन भर एक प्रक्रिया की सेवा करते हैं।

एक स्ट्रीम को डेमन के रूप में घोषित करना काफी सरल है - स्ट्रीम शुरू करने से पहले आपको इसकी setDaemon(true) विधि को कॉल करने की आवश्यकता है;
आप चेक कर सकते हैं कि क्या स्ट्रीम अपने boolean isDaemon() विधि को बुलाकर एक डेमन है;

धागा पूरा करना

जावा में, एक धारा को समाप्त करने के लिए मजबूर (मौजूद) साधन थे। विशेष रूप से, थ्रेड.स्टॉप () विधि इसके निष्पादन के तुरंत बाद थ्रेड को समाप्त कर देती है। हालांकि, यह विधि, साथ ही थ्रेड.ससपेंड (), जो थ्रेड को निलंबित करता है, और थ्रेड .resume (), जो थ्रेड को निष्पादित करना जारी रखता है, को हटा दिया गया है और उनका उपयोग अब अत्यधिक अवांछनीय है। तथ्य यह है कि ऑपरेशन के दौरान थ्रेड को "मारा" जा सकता है, जिसके आधे रास्ते में रुकावट किसी वस्तु को गलत स्थिति में छोड़ देगी, जिससे एक त्रुटि दिखाई देगी जो कि पकड़ना मुश्किल है और बेतरतीब ढंग से उत्पन्न होती है।

किसी थ्रेड को जबरन समाप्त करने के बजाय, एक योजना लागू की जाती है जिसमें प्रत्येक थ्रेड स्वयं ही इसके समापन के लिए जिम्मेदार होता है। एक धागा या तो बंद हो सकता है जब वह रन (), (मुख्य धागे के लिए मुख्य () विधि) या किसी अन्य धागे से संकेत द्वारा चल रहा है। इसके अलावा, इस तरह के संकेत पर प्रतिक्रिया कैसे करें, फिर से, प्रवाह का मामला है। इसे प्राप्त करने पर, धागा कुछ ऑपरेशन कर सकता है और निष्पादन को पूरा कर सकता है, या यह पूरी तरह से इसे अनदेखा कर सकता है और निष्पादित करना जारी रख सकता है। फ्लो पूरा होने के संकेत की प्रतिक्रिया का वर्णन प्रोग्रामर के पास है।

जावा में अंतर्निर्मित थ्रेड अलर्ट मैकेनिज्म है जिसे इंटरप्रेनियन कहा जाता है, और हम इसे जल्द ही देखेंगे, लेकिन पहले निम्न प्रोग्राम को देखें:

इन्क्रीमेंटर - एक स्ट्रीम जो प्रत्येक सेकंड में स्थिर चर Program.mValue के मूल्य से एक को जोड़ता या घटाता है। इन्क्रीमेंटर में दो निजी क्षेत्र शामिल हैं - mIsIncrement और mFinish। क्या कार्रवाई की जाती है यह बूलियन चर mIsIncrement द्वारा निर्धारित किया जाता है - यदि यह सच है, तो एक जोड़ा जाता है, अन्यथा, घटाव। और थ्रेड समाप्त होता है जब mFinish मान सत्य हो जाता है।

 class Incremenator extends Thread { //   volatile -   private volatile boolean mIsIncrement = true; private volatile boolean mFinish = false; public void changeAction() //    { mIsIncrement = !mIsIncrement; } public void finish() //   { mFinish = true; } @Override public void run() { do { if(!mFinish) //    { if(mIsIncrement) Program.mValue++; // else Program.mValue--; // //    System.out.print(Program.mValue + " "); } else return; //  try{ Thread.sleep(1000); //   1 . }catch(InterruptedException e){} } while(true); } } public class Program { //,    public static int mValue = 0; static Incremenator mInc; //   public static void main(String[] args) { mInc = new Incremenator(); //  System.out.print(" = "); mInc.start(); //  //    //   i*2  for(int i = 1; i <= 3; i++) { try{ Thread.sleep(i*2*1000); //   i*2 . }catch(InterruptedException e){} mInc.changeAction(); //  } mInc.finish(); //    } } :  = 1 2 1 0 -1 -2 -1 0 1 2 3 4 

आप changeAction () मेथड (इसके अलावा और इसके विपरीत में घटाव को बदलने के लिए) और फिनिश () मेथड (स्ट्रीम को पूरा करने के लिए) का उपयोग करके स्ट्रीम के साथ इंटरैक्ट कर सकते हैं।

चर घोषणा mIsIncrement और mFinish में, वाष्पशील कीवर्ड का उपयोग किया गया था (परिवर्तनशील, स्थिर नहीं)। इसका उपयोग उन चर के लिए किया जाना चाहिए जो विभिन्न थ्रेड द्वारा उपयोग किए जाते हैं। ऐसा इसलिए है क्योंकि अस्थिर के बिना घोषित एक चर के मूल्य को प्रत्येक स्ट्रीम के लिए अलग से कैश किया जा सकता है, और इस कैश से मूल्य उनमें से प्रत्येक के लिए अलग हो सकता है। अस्थिर कीवर्ड के साथ एक चर की घोषणा करना इसके लिए इस तरह के कैशिंग को अक्षम करता है और चर के सभी अनुरोधों को सीधे मेमोरी में भेजा जाएगा।

यह उदाहरण दिखाता है कि थ्रेड्स के बीच इंटरैक्शन को कैसे व्यवस्थित किया जाए। हालांकि, धारा को समाप्त करने के लिए इस दृष्टिकोण के साथ एक समस्या है - इनक्रिमिनेटर प्रति सेकंड एक बार mFinish फ़ील्ड के मूल्य की जांच करता है, इसलिए इसे खत्म होने पर () विधि निष्पादित होने और धारा के वास्तविक निर्धारण के बीच एक सेकंड का समय लग सकता है। यह बहुत अच्छा होगा यदि, बाहर से संकेत प्राप्त करते समय, नींद () पद्धति ने निष्पादन वापस कर दिया और थ्रेड तुरंत अपना पूरा करना शुरू कर दिया। इस परिदृश्य को निष्पादित करने के लिए, एक अंतर्निर्मित प्रवाह चेतावनी उपकरण होता है जिसे व्यवधान कहा जाता है।

व्यवधान

थ्रेड क्लास में एक छिपा हुआ बूलियन फ़ील्ड होता है, इंक्रिमिनेटर में mFinish फ़ील्ड के समान, जिसे इंटरप्ट फ्लैग कहा जाता है। आप इस झंडे को स्ट्रीम के इंटरप्ट () तरीके से कॉल करके सेट कर सकते हैं। यह जांचने के दो तरीके हैं कि क्या यह ध्वज सेट है। पहला तरीका यह है कि थ्रेड ऑब्जेक्ट की बूल isInterrupted () पद्धति को कॉल किया जाए, दूसरा स्टैटिक बूल Thread.interrupted () विधि को कॉल करना है। पहला तरीका इंटरप्ट फ्लैग की स्थिति को लौटाता है और इस ध्वज को बरकरार रखता है। दूसरी विधि ध्वज की स्थिति को लौटाती है और इसे छोड़ देती है। ध्यान दें कि Thread.interrupted () थ्रेड क्लास का एक स्थिर तरीका है, और इसे कॉल करना उस थ्रेड के इंटरप्ट फ्लैग का मान लौटाता है जिससे इसे बुलाया गया था। इसलिए, इस विधि को केवल थ्रेड के भीतर से कहा जाता है और थ्रेड को अपनी रुकावट की स्थिति की जांच करने की अनुमति देता है।

तो, हमारे कार्यक्रम पर वापस जाएं। रुकावट तंत्र हमें गिरने की समस्या को हल करने की अनुमति देगा। वे विधियाँ जो किसी थ्रेड को रोकती हैं, जैसे कि नींद (), प्रतीक्षा (), और ज्वाइन (), की एक ख़ासियत है - यदि इस थ्रेड की रुकावट () ​​विधि को उनके निष्पादन के दौरान कहा जाता है, तो वे मध्यांतर की प्रतीक्षा किए बिना एक InterruptedException को फेंक देंगे।

आइए कार्यक्रम इनक्रिमिनेटर का रीमेक करें - अब फिनिश () विधि का उपयोग करके स्ट्रीम को समाप्त करने के बजाय, हम मानक इंटरप्ट () विधि का उपयोग करेंगे। और mFinish ध्वज की जांच करने के बजाय, हम bool Thread.interrupted () विधि को कॉल करेंगे;
यह बीच समर्थन को जोड़ने के बाद इन्क्रीमेंटर वर्ग जैसा दिखेगा:

 class Incremenator extends Thread { private volatile boolean mIsIncrement = true; public void changeAction() //    { mIsIncrement = !mIsIncrement; } @Override public void run() { do { if(!Thread.interrupted()) //  { if(mIsIncrement) Program.mValue++; // else Program.mValue--; // //    System.out.print(Program.mValue + " "); } else return; //  try{ Thread.sleep(1000); //   1 . }catch(InterruptedException e){ return; //    } } while(true); } } class Program { //,    public static int mValue = 0; static Incremenator mInc; //   public static void main(String[] args) { mInc = new Incremenator(); //  System.out.print(" = "); mInc.start(); //  //    //   i*2  for(int i = 1; i <= 3; i++) { try{ Thread.sleep(i*2*1000); //   i*2 . }catch(InterruptedException e){} mInc.changeAction(); //  } mInc.interrupt(); //   } } :  = 1 2 1 0 -1 -2 -1 0 1 2 3 4 

जैसा कि आप देख सकते हैं, हमने फिनिश () विधि से छुटकारा पा लिया और अंतर्निहित थ्रू सिस्टम का उपयोग करके उसी थ्रेड पूरा करने वाले तंत्र को लागू किया। इस कार्यान्वयन में, हमें एक फायदा मिला - थ्रेड बाधित होने के तुरंत बाद नींद () विधि वापस नियंत्रण (एक अपवाद फेंक) करेगी।

ध्यान दें कि स्लीप () और ज्वाइन () विधियाँ एक ट्राइ-कैच कंस्ट्रक्शन में लिपटी हुई हैं। यह इन तरीकों के संचालन के लिए एक शर्त है। उन्हें कॉल करने वाले कोड को InterruptedException को पकड़ना चाहिए, जिसे वे प्रतीक्षा करते समय बाधित करते हैं।

थ्रेड्स के साथ काम करने की शुरुआत और समाप्ति के साथ, फिर मैं थ्रेड्स के साथ काम करते समय उपयोग किए जाने वाले तरीकों के बारे में बात करूंगा।

थ्रेड.स्लीप () विधि

Thread.sleep () थ्रेड क्लास की एक स्थिर विधि है जो उस थ्रेड को रोकती है जिसमें इसे बुलाया गया था। नींद () विधि के निष्पादन के दौरान, सिस्टम थ्रेड को प्रोसेसर समय आवंटित करने के लिए बंद कर देता है, इसे अन्य थ्रेड्स के बीच वितरित करता है। नींद () विधि को या तो एक निर्दिष्ट समय (मिलीसेकंड या नैनोसेकंड) के लिए निष्पादित किया जा सकता है या जब तक कि इसे एक रुकावट से नहीं रोका जाता है (इस मामले में, यह एक इंटरप्टेडएक्ससेप्शन फेंक देगा)।

 Thread.sleep(1500); //   Thread.sleep(2000, 100); // 2   100  

इस तथ्य के बावजूद कि नींद () विधि प्रतीक्षा समय के रूप में नैनोसेकंड ले सकती है, आपको इसे गंभीरता से नहीं लेना चाहिए। कई प्रणालियों में, प्रतीक्षा समय अभी भी मिलीसेकंड, या यहां तक ​​कि उनके दसियों तक ही है।

उपज () विधि

स्टैटिक थ्रेड.लाइड () विधि प्रोसेसर को सिस्टम में अन्य थ्रेड्स को संसाधित करने के लिए स्विच करने के लिए मजबूर करती है। विधि उपयोगी हो सकती है, उदाहरण के लिए, जब कोई थ्रेड किसी घटना की प्रतीक्षा कर रहा होता है और यह आवश्यक है कि इसकी घटना को जितनी बार संभव हो चेक किया जाए। इस स्थिति में, आप ईवेंट चेक और थ्रेड.लाइड () विधि को लूप में रख सकते हैं:

 //   while(!msgQueue.hasMessages()) //     { Thread.yield(); //    } 

सम्मिलित हों () विधि

जावा में एक तंत्र है जो एक धागे को दूसरे धागे के पूरा होने तक इंतजार करने की अनुमति देता है। ऐसा करने के लिए, जॉइन () विधि का उपयोग करें। उदाहरण के लिए, मुख्य धारा के लिए प्रतीक्षा करने के लिए पक्ष धारा myThready को पूरा करने के लिए, आपको मुख्य धागे में myThready.join () कथन निष्पादित करना होगा। एक बार जब मेरा थ्रेड पहले से ही पूरा हो जाता है, तो जॉइन () विधि नियंत्रण वापस कर देगी, और मुख्य थ्रेड निष्पादन को जारी रखने में सक्षम होगा।

सम्मिलित () विधि में एक अतिभारित संस्करण है जो एक पैरामीटर के रूप में एक टाइमआउट प्राप्त करता है। इस स्थिति में, अपेक्षित थ्रेड के समाप्त होने पर, या जब प्रतीक्षा समय समाप्त हो जाता है, तो ज्वाइन () रिटर्न नियंत्रण। थ्रेड.सेलेप () विधि की तरह, मिल विधि मिसेकंड और नैनोसेकंड के लिए इंतजार कर सकती है - तर्क समान हैं।

किसी स्ट्रीम के टाइम-आउट को सेट करके, आप उदाहरण के लिए, एक एनिमेटेड चित्र को अपडेट कर सकते हैं जबकि मुख्य (या कोई अन्य) स्ट्रीम साइड-स्ट्रीम के पूरा होने की प्रतीक्षा करता है जो संसाधन-गहन संचालन करता है:

 Thinker brain = new Thinker(); //Thinker -   Thread. brain.start(); // "". do { mThinkIndicator.refresh(); //mThinkIndicator -  . try{ brain.join(250); //    . }catch(InterruptedException e){} } while(brain.isAlive()); // brain ... //brain   ( ). 

इस उदाहरण में, मस्तिष्क की धारा कुछ के बारे में सोच रही है, और यह माना जाता है कि यह उसे लंबे समय तक ले जाता है। मुख्य सूत्र एक सेकंड के एक चौथाई के लिए इसका इंतजार करता है और, अगर यह समय प्रतिबिंब के लिए पर्याप्त नहीं है, तो यह "विचारों का संकेतक" (कुछ एनिमेटेड चित्र) को अद्यतन करता है। परिणामस्वरूप, विचार करते समय, उपयोगकर्ता स्क्रीन पर विचार प्रक्रिया का एक संकेतक देखता है, जिससे उसे पता चलता है कि इलेक्ट्रॉनिक दिमाग कुछ के लिए व्यस्त है।

सूत्र प्राथमिकताएँ

सिस्टम में प्रत्येक थ्रेड की अपनी प्राथमिकता है। स्ट्रीम ऑब्जेक्ट में प्राथमिकता एक निश्चित संख्या है, जिसका उच्च मूल्य उच्च प्राथमिकता का मतलब है। सिस्टम मुख्य रूप से थ्रेड्स को उच्च प्राथमिकता के साथ निष्पादित करता है, और कम प्राथमिकता वाले थ्रेड्स प्रोसेसर समय केवल तब प्राप्त करते हैं जब उनके अधिक विशेषाधिकार वाले समकक्ष निष्क्रिय होते हैं।

आप दो कार्यों का उपयोग करके स्ट्रीम प्राथमिकताओं के साथ काम कर सकते हैं:

void setPriority(int priority) - धारा की प्राथमिकता निर्धारित करता है।
संभावित प्राथमिकता मान MIN_PRIORITY, NORM_PRIORITY और MAX_PRIORITY हैं।

int getPriority() - स्ट्रीम की प्राथमिकता हो जाती है।

कुछ उपयोगी थ्रेड क्लास के तरीके

यह व्यावहारिक रूप से सभी है। अंत में, मैं आपको धाराओं के साथ काम करने के लिए कुछ उपयोगी तरीके दूंगा।

boolean isAlive() - सही है अगर myThready () निष्पादित और गलत है यदि थ्रेड अभी तक शुरू नहीं हुआ है या पूरा हो गया है।

setName(String threadName) - थ्रेड का नाम सेट करता है।
String getName() - स्ट्रीम का नाम हो जाता है।
धारा का नाम इसके साथ जुड़ा हुआ तार है, जो कुछ मामलों में यह समझने में मदद करता है कि कौन सी धारा एक क्रिया करती है। यह कभी-कभी उपयोगी होता है।

static Thread Thread.currentThread() एक स्थिर विधि है जो उस थ्रेड के ऑब्जेक्ट को लौटाता है जिसमें इसे कहा जाता था।

long getId() - स्ट्रीम के पहचानकर्ता को लौटाता है। पहचानकर्ता - स्ट्रीम को निर्दिष्ट एक अद्वितीय संख्या।

निष्कर्ष

मैं ध्यान देता हूं कि लेख मल्टीथ्रेडेड प्रोग्रामिंग की सभी बारीकियों का वर्णन नहीं करता है। और उदाहरणों में कोड की शुद्धता के लिए, कुछ बारीकियां गायब हैं। विशेष रूप से, उदाहरण सिंक्रनाइज़ेशन का उपयोग नहीं करते हैं। थ्रेड सिंक्रोनाइज़ेशन एक ऐसा विषय है, जिसका अध्ययन किए बिना, सही मल्टीथ्रेडेड अनुप्रयोगों की प्रोग्रामिंग विफल हो जाएगी। आप इसके बारे में पढ़ सकते हैं, उदाहरण के लिए, "Java Concurrency in Practice" या यहाँ (सभी अंग्रेजी में)।

लेख ने जावा में थ्रेड्स के साथ काम करने के मूल साधनों की जांच की। अगर यह लेख उपयोगी है, तो अगले में मैं संसाधनों को साझा करने की समस्याओं और उन्हें हल करने के तरीकों के बारे में बात करूंगा।

ऑल द बेस्ट।