Creating Threads (extending Thread class vs implementing Runnable interface) Java In Hindi
जावा प्रोग्रामिंग लैंग्वेज में थ्रेड एक लाइटवेट मल्टी-प्रोसेसिंग सब-प्रोसेस टास्क या मेथड है, जो जावा में क्रिएट एक प्रोग्राम को एक साथ मल्टीप्ल थ्रेड टास्क को परफॉर्म करने में हेल्प करता है। जावा में इनबिल्ट, थ्रेड क्लास और Runnable इंटरफ़ेस के माध्यम से जावा डेवलपर को मल्टीथ्रेडिंग थ्रेड टास्क प्रोसेसिंग के लिए बिल्ट-इन सपोर्ट मिलता है।
There are two common ways to create multiple threads in Java.
- Thread क्लास को एक्सटेंड करके इसे किया जाता है.
- Runnable इंटरफ़ेस को इम्प्लीमेंट करके थ्रेड क्लास को इम्प्लीमेंट किया जाता है.
Creating a thread in Java by extending the Thread class.
Basic Thread class concept.
जावा प्रोग्रामिंग लैंग्वेज में थ्रेड क्लास java.lang पैकेज में पहले से मौजूद या इनबिल्ट फीचर्स है। जावा डेवलपर एक थ्रेड क्लास को एक्सटेंड करने वाली क्लास डेवलप कर अपना एक कस्टम सेल्फ थ्रेड क्रिएट कर सकते हैं।
जावा यूजर डेवलप थ्रेड को एक यूजर डिफाइन टास्क को एक्सेक्यूट करना है, उसे जावा के run() फंक्शन मेथड के अंदर क्रिएट या डिफाइन किया जाता है।
जब जावा डेवलपर किसी थ्रेड के लिए एक start() फंक्शन मेथड को कॉल करते हैं, तो जावा एक न्यू थ्रेड क्रिएट करता है, और थ्रेड में मौजूदा run() फंक्शन या मेथड उस थ्रेड के द्वारा एग्जीक्यूट किया जाता है।
Syntax of the basic Thread class concept.
class SampleThread extends Thread {
public void run() {
// Here we create a thread task to be execute
}
}
Example of the basic Thread class concept.
class SampleThread extends Thread {
public void run() {
System.out.println(“Sample Thread is continue”);
}
}
public class Main {
public static void main(String[] args) {
SampleThread th1 = new SampleThread();
th1.start();
}
}
Illustrating the basic Thread class concept with this example.
- यहाँ इस एक्साम्प्ल में SampleThread, एक यूजर डिफाइन Thread क्लास को एक्सटेंड करता है।
- जावा यूजर एक run() फंक्शन मेथड के माध्यम से इसे ओवरराइड करते हैं।
- थ्रेड में डिफाइन run() फंक्शन मेथड में थ्रेड द्वारा किया गया यूजर क्रिएटेड टास्क डिफाइन होता है।
- जहा th1, SampleThread का एक ऑब्जेक्ट डिफाइन है।
- ये एक th1.start() फंक्शन मेथड में एक नया थ्रेड को स्टार्ट करता है।
- जावा में मौजूद JVM फिर run() फंक्शन मेथड को एग्जीक्यूट करता है।
A key point in Java thread development: start() vs. run().
जावा डेवलपर को इसे सामान्य रूप से यूज़ करना चाहिए।
th1.start();
और नहीं.
th1.run();
यहाँ थ्रेड क्लास में start() फंक्शन मेथड एक नया थ्रेड को क्रिएट करता है, जबकि run() फंक्शन मेथड को डायरेक्ट कॉल करने से मौजूदा थ्रेड में मेथड एक नॉर्मल मेथड कॉल की तरह एग्जीक्यूट हो जाती है।
Creating a thread by implementing the Runnable method interface in Java.
Basic Thread Runnable concept.
जावा प्रोग्रामिंग लैंग्वेज में एक नया थ्रेड डिज़ाइन डेवलप करने का एक अन्य मेथड में Runnable इंटरफ़ेस के माध्यम से थ्रेड को इम्प्लीमेंट करना होता है।
यूजर डिफाइन एक थ्रेड क्लास में एक Runnable इंटरफ़ेस में एक सिंगल एब्स्ट्रैक्ट मेथड डिफाइन होता है.
public void run()
इसमें जावा यूजर इस मेथड को इम्प्लीमेंट करके उस टास्क को डिफाइन करते हैं, जिसे मौजूदा थ्रेड में परफॉर्म करने की ज़रूरत होती है।
इसके बाद Runnable मेथड ऑब्जेक्ट को उसके कंस्ट्रक्टर मेथड में पास करके एक थ्रेड ऑब्जेक्ट क्रिएट किया जाता है।
Syntax of the Thread Runnable.
class SimpleTask implements Runnable {
public void run() {
// This defines the task to be created and executed in the current thread.
}
}
Example of the Thread Runnable concept.
class SimpleTask implements Runnable {
public void run() {
System.out.println(“User Define Thread is running”);
}
}
public class Main {
public static void main(String[] args) {
SimpleTask task = new SimpleTask();
Thread th1 = new Thread(task);
th1.start();
}
}
Here’s the Thread Runnable concept in a Java program.
- यहाँ इस प्रोग्राम में SimpleTask, एक न्यू थ्रेड को Runnable इंटरफ़ेस को इम्प्लीमेंट करता है।
- जावा यूजर मौजूदा प्रोग्राम में एक run() फंक्शन मेथड को ओवरराइड करते हैं।
- यूजर डिफाइन टास्क, SimpleTask का एक ऑब्जेक्ट क्रिएट करता है।
- जावा यूजर टास्क को Thread कंस्ट्रक्टर एलिमेंट को पास करते हैं।
- जहा th1.start() फंक्शन मेथड थ्रेड को स्टार्ट करता है।
- जहा थ्रेड run() फंक्शन मेथड को एग्जीक्यूट करता है।
The essential point of the Thread Runnable concept is this.
यहाँ ऊपर दिए गए इस एक्साम्प्ल में ये एक Runnable टास्क को रिप्रेजेंट करता है, जबकि Thread उस थ्रेड को डिस्प्ले करता है, जो उसमे थ्रेड टास्क को एग्जीक्यूट करता है।
Main Difference Between Java Thread and Runnable Method
| # | Extending thread in java | Implementing runnable in java |
| 1. | Here we used class extends thread | In this we use class implements runnable |
| 2. | Example: class employee extends with thread | Example: class company implements runnable thread task |
| 3. | In this the class itself represents a thread and its data | In this the runnable class represents a thread and its task |
| 4. | Thread class cannot extend another class | But runnable thread can be extended with another class |
| 5. | Java thread is less flexible for use | Java runnable method more flexible in term of use |
| 6. | Java class thread object is created directly by user | Where java runnable thread task object is passed to thread element |
| 7. | Java thread stat with new employee().start() | Java runnable thread new thread(new company()).start() |
Why is Runnable generally preferred in Java?
जावा प्रोग्राम क्लास के मल्टीपल इनहेरिटेंस कांसेप्ट को सपोर्ट नहीं करता है।
जैसा की यहाँ हमारे पास पहले से ही यह एक एक्साम्प्ल है.
class Company extends Employee {
}
इसमें जावा यूजर यह नहीं कर सकते है.
class Company extends Employee, Thread { // Display Error
}
लेकिन इसमें जावा यूजर Runnable थ्रेड मेथड को इम्प्लीमेंट कर सकते हैं.
class Company extends Employee implements Runnable {
public void run() {
System.out.println(“Company thread Created”);
}
}
इस वजह से, इस एक्साम्प्ल में Runnable थ्रेड मेथड को अप्लाई करने से जावा यूजर को अधिक फ़्लेक्सिबिलिटी मिलती है।
It also manages two different responsibilities in Java.
- Runnable → यह जावा थ्रेड प्रोग्राम में इंडीकेट करता है कि कौन सा थ्रेड टास्क परफॉर्म किया जाना चाहिए।
- Thread → यह जावा थ्रेड प्रोग्राम में इंडीकेट करता है कि कौन सा थ्रेड टास्क को कम्पलीट करेगा।
A simple example of creating and managing a real-life thread in a Java program.
तो चलिए जावा प्रोग्रामिंग लैंग्वेज में एक थ्रेड टास्क को रेस्टोरेंट के एक्साम्प्ल से समझते है।
- Runnable = यह एक रेस्टोरेंट में कम्पलीट किया जाने वाला टास्क/ऑर्डर है।
- Thread = यह उस रेस्टोरेंट में मल्टीप्ल टास्क करने वाला वर्कर या एम्प्लॉई है।
For a restaurant thread task example.
class ServingTask implements Runnable {
public void run() {
System.out.println(“Perform ServingTask…”);
}
}
The task is to serve guests with different tasks.
After this.
ServingTask task = new ServingTask();
Thread staff = new Thread(task);
staff.start();
यहाँ, ServingTask स्टाफ एम्प्लॉई को एक रेस्टोरेंट में इंडीकेट करता है कि क्या करना है, जबकि Thread उसे करने वाला एम्प्लॉई स्टाफ प्रोवाइड करता है।
The essential methods for implementing a thread in a restaurant.
run() function method.
जावा थ्रेड में रन फंशन मेथड में वह यूजर डिफाइन थ्रेड का सोर्स कोड होता है, जिसे आपका थ्रेड रन होता है।
public void run() {
System.out.println(“This is a Test thread”);
}
start() function method.
यह जावा प्रोग्राम में एक नए थ्रेड को स्टार्ट करता है, और उस नए थ्रेड में run() फंक्शन मेथड को रन करता है।
th1.start();
sleep() function method.
यह फंक्शन मौजूदा प्रोग्राम में अभी चल रहे थ्रेड को कुछ समय के लिए स्लीप या स्टॉप कर देता है।
Thread.sleep(2000);
यह मौजूदा प्रोग्राम में थ्रेड को लगभग 2000 मिलीसेकंड (2 सेकंड) के लिए स्टॉप कर देता है।
Concluson of creating Threads (extending Thread class vs implementing Runnable interface).
जावा प्रोग्रामिंग लैंग्वेज में आपको एक नए थ्रेड क्रिएट करने के दो पुराने पॉपुलर तरीके प्रोवाइड करता है.
Using Thread in Java.
class SampleThread extends Thread {
public void run() {
System.out.println(“User Define Thread Running”);
}
}
Using Runnable in Java Threads.
class SampleTask implements Runnable {
public void run() {
System.out.println(“User Define Thread Task Is Running”);
}
}
ज़्यादातर जावा थ्रेड केस मामलों में, Runnable कांसेप्ट को अप्लाई करना एक बेस्ट चॉइस होता है, क्योंकि यह जावा प्रोग्राम में डिफाइन टास्क और थ्रेड के बीच एक बेस्ट डिस्टेंस को मेन्टेन करता है, और क्लास को दूसरी क्लास को बढ़ाने की परमिशन प्रोवाइड करता है।
An easy way to remember the thread concept in Java.
- Thread → “मैं एक यूजर डिफाइन जावा प्रोग्राम बेस्ड एक थ्रेड हूँ।”
- Runnable → “मैं जावा प्रोग्राम में एक यूजर डिफाइन टास्क हूँ, जिससे जावा यूजर डिफाइन थ्रेड रन हो सकता है।”
