नए सूत्र बनाना और शुरू करना

"हैलो, एमिगो! ऐली ने आपको थ्रेड्स के बारे में बताया था, और मैं आपको यह बताने जा रही हूं कि आप उनके साथ कैसे काम करते हैं। एक नया थ्रेड बनाने के लिए, आपको चाहिए:"

1)  थ्रेड ऑब्जेक्ट बनाएं

2) इसे उस विधि से पास करें जिसे आप चलाना चाहते हैं

3)  निर्मित थ्रेड ऑब्जेक्ट पर प्रारंभ विधि को कॉल करें।

इस उदाहरण पर विचार करें:

class Printer implements Runnable
{
public void run()
{
System.out.println("I’m printer");
}
}

public static void main(String[] args)
{
Printer printer = new Printer();
Thread childThread = new Thread(printer);
childThread.start();
}

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

"आह, बहुत सारे धागे का अर्थ है बहुत सारी मुख्य विधियाँ।"

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

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

class Printer implements Runnable
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}

public static void main(String[] args)
{
Printer printer1 = new Printer("Nick");
Thread thread1 = new Thread(printer1);
thread1.start();

Printer printer2 = new Printer("Jack");
Thread thread2 = new Thread(printer2);
thread2.start();
}

public static void main(String[] args)
{
Printer printer = new Printer("Natasha");

Thread thread1 = new Thread(printer);
thread1.start();

Thread thread2 = new Thread(printer);
thread2.start();

Thread thread3 = new Thread(printer);
thread3.start();
}

और तो और, आप इन सभी को एक वर्ग में जोड़ सकते हैं। थ्रेड क्लास को रननेबल इंटरफ़ेस विरासत में मिला है , इसलिए आपको केवल इसकी रन विधि को ओवरराइड करने की आवश्यकता है:

class Printer extends Thread
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}

public static void main(String[] args)
{
Printer printer = new Printer("Jack");
printer.start();

Printer printer2 = new Printer("Jack");
printer2.start();

}

"यह एक अधिक सुरुचिपूर्ण समाधान है।"

"हाँ, लेकिन इसकी कमियाँ हैं:"

1)  नताशा के उदाहरण के अनुसार, आपको एक वस्तु के आधार पर कई सूत्र शुरू करने की आवश्यकता हो सकती है।

2)  यदि आप थ्रेड क्लास से इनहेरिट करते हैं, तो आप अपनी कक्षा में कोई अन्य पैरेंट क्लास नहीं जोड़ सकते हैं।

3)  यदि आपकी कक्षा में मूल वर्ग है, तो आप थ्रेड को दूसरी मूल कक्षा के रूप में नहीं जोड़ सकते हैं।

"दूसरे शब्दों में, स्टार्ट मेथड कहे जाने के बाद, प्रत्येक थ्रेड कंस्ट्रक्टर को पास की गई ऑब्जेक्ट की रन मेथड को निष्पादित करना शुरू कर देता है?"

"हाँ। यदि कंस्ट्रक्टर को कुछ भी नहीं दिया जाता है, तो थ्रेड केवल अपनी आंतरिक रन विधि को निष्पादित करता है।"

"लेकिन हम इस तरह से विधि को क्यों नहीं बुलाते?"

public static void main(String[] args)
{
 Printer printer1 = new Printer("Nick");
 printer1.run();
}

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

"ठीक है। क्या आप किसी अन्य विधि को कॉल कर सकते हैं, रन के अलावा कुछ और?"

"नहीं। यह सब रननेबल इंटरफ़ेस से जुड़ा हुआ है, जो केवल इसके तरीकों में से एक के बारे में" जानता है: रन () ।