नवीन धागे तयार करणे आणि सुरू करणे

"हॅलो, अमिगो! एलीने तुम्हाला थ्रेड्सबद्दल सांगितले आहे आणि मी तुम्हाला सांगणार आहे की तुम्ही त्यांच्यासोबत कसे काम करता. नवीन थ्रेड तयार करण्यासाठी, तुम्हाला हे करणे आवश्यक आहे:"

1)  थ्रेड ऑब्जेक्ट तयार करा

२) तुम्हाला ज्या पद्धतीने चालवायचे आहे ती पास करा

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();
}

लहान जावा प्रोग्राम्समध्ये सामान्यतः एक धागा असतो ज्याला "मुख्य थ्रेड" म्हणतात. परंतु प्रोग्राम अधिक वेळा अतिरिक्त थ्रेड्स लाँच करतात, ज्याला "चाइल्ड थ्रेड्स" म्हणतात. मुख्य धागा मुख्य पद्धत चालवतो आणि संपतो. रननेबलची रन पद्धत ही चाइल्ड थ्रेड्ससाठी समान पद्धत आहे.

"अहो, बरेच धागे म्हणजे अनेक मुख्य पद्धती."

थ्रेड ऑब्जेक्ट कोणत्या विशिष्ट पद्धतीने सुरू व्हायला हवे हे सांगण्यासाठी, आम्हाला त्यामध्ये एक पद्धत पास करणे आवश्यक आहे. Java मध्ये, हे Runnable इंटरफेस वापरून केले जाते . या इंटरफेसमध्ये एकच अमूर्त पद्धत आहे: void run() . थ्रेड क्लासमध्ये थ्रेड (रन करण्यायोग्य रन करण्यायोग्य) कन्स्ट्रक्टर आहे. रन करण्यायोग्य इंटरफेस लागू करणाऱ्या कोणत्याही ऑब्जेक्टमध्ये तुम्ही पास करू शकता .

तुमच्या वर्गाला रन करण्यायोग्य वारसा मिळणे आवश्यक आहे आणि त्याची रन पद्धत ओव्हरराइड करणे आवश्यक आहे. या पद्धतीचा वापर केल्याने नवीन धागा सुरू होतो. रन पद्धतीत तुम्हाला हवे ते लिहू शकता .

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();
}

"जेव्हा मुख्य थ्रेड रन मेथडवर पोहोचतो, तेव्हा त्याचा "छोटा रोबो" फक्त आत जातो आणि त्याच्या आत असलेल्या सर्व कमांड्स कार्यान्वित करतो. ते कार्यान्वित झाल्यानंतरच तो मुख्य पद्धतीकडे परत येतो आणि पुढील आदेशांची अंमलबजावणी सुरू ठेवतो. अशा प्रकारे, दुसरा नाही " छोटा रोबोट" तयार केला जाईल. सर्व काम समांतर (एकाच वेळी) न करता क्रमाने केले जाईल."

"मी बघतो. तुम्ही धावण्याशिवाय दुसरी पद्धत म्हणू शकता का?"

"नाही. हे सर्व रन करण्यायोग्य इंटरफेसशी जोडलेले आहे, जे फक्त त्याच्या एका पद्धतीबद्दल "माहित" आहे: run() ."