जावा में थ्रेड

Question

मुझे आज जावा में थ्रेड अवधारणाओं पर एक साक्षात्कार में पूछा गया था? प्रश्न थे ...

1. धागा क्या है?
2. हम थ्रेडिंग के लिए क्यों जाते हैं?
3. धागे पर एक वास्तविक समय उदाहरण।
4. क्या हम वसंत ढांचे सेवा कक्षा में धागे बना सकते हैं।
5. क्या फ्लेक्स एक थ्रेड कॉल कर सकता है?

मैंने थ्रेड की परिभाषा के अलावा किसी भी प्रश्न का उत्तर नहीं दिया, मैंने भी इंटरनेट से सीखा।

क्या कोई मुझे इस पर स्पष्ट रूप से समझा सकता है।

अद्यतन:

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

Answer 1

थ्रेड बनाने के लिए, थ्रेड क्लास को विस्तारित करने वाली एक नई कक्षा बनाएं, और उस वर्ग को तुरंत चालू करें। विस्तारित वर्ग को थ्रेड के निष्पादन को शुरू करने के लिए रन() विधि को ओवरराइड करना होगा और प्रारंभ() विधि को कॉल करना होगा।

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

public class MyThread extends Thread { 

    String word; 

    public MyThread(String rm){ 
    word = rm; 
    } 

    public void run(){ 

    try { 

     for(;;){ 
     System.out.println(word); 
     Thread.sleep(1000); 
     } 

    } catch(InterruptedException e) { 

     System.out.println("sleep interrupted");  
    } 
    } 

    public static void main(String[] args) { 

    Thread t1=new MyThread("First Thread"); 
    Thread t2=new MyThread("Second Thread"); 
    t1.start(); 
    t2.start(); 
    } 
} 

आउटपुट स्क्रीन:

First Thread 
Second Thread 
First Thread 
Second Thread 
First Thread 

और इस देखें:

http://www.javaworld.com/javaworld/jw-04-1996/jw-04-threads.html

और स्प्रिंग के लिए आप थ्रेड पूल का उपयोग कर सकते हैं:

http://static.springsource.org/spring/docs/2.0.x/reference/scheduling.html

Answer 2

मैं पहले 3 का उत्तर दे सकता हूं क्योंकि मैं वसंत या फ्लेक्स की थ्रेडिंग सुविधाओं से परिचित नहीं हूं।

1. एक धागा एक वस्तु का अपना रजिस्टर, ढेर और कोड खंड है कि एक प्रक्रिया में अन्य धागे के साथ समानांतर चला सकते हैं (एक प्रक्रिया धागे का एक संग्रह है) किया है।

2. आप प्रोग्राम के लिए बहु-थ्रेड कोड उत्तरदायी उपयोगकर्ता इंटरैक्शन के लिए लिखते हैं। इस बारे में सोचें कि अगर आप ब्राउज़िंग जारी रखने से पहले अपने ब्राउज़र को फ़ाइल डाउनलोड करना समाप्त करना चाहते हैं तो यह कितना परेशान होगा।

3. मैंने # 2 में एक उदाहरण दिया। अन्य उदाहरण जीयूआई के साथ कोई भी प्रोग्राम हैं (जीयूआई को हमेशा पृष्ठभूमि कार्यों के दौरान उपयोगकर्ता इनपुट के लिए उत्तरदायी होना चाहिए), या सर्वर प्रकार सॉफ़्टवेयर जैसे वेब सर्वर जहां आपको एक मिनट में 1000 अनुरोधों का जवाब देना पड़ सकता है। उन प्रतिक्रियाओं में से प्रत्येक के लिए अलग धागा होना बेहतर होगा।

Answer 3

जहां तक ​​वसंत का संबंध है, हां आप निश्चित रूप से अपने स्वयं के धागे बना सकते हैं। लेकिन स्प्रिंग फ्रेमवर्क मैनुअल के Chapter 25 में वर्णित थ्रेड पूल समर्थन का उपयोग करना बेहतर विचार है।

हालांकि, होने अनुरोध एक स्प्रिंग-आधारित वेब सेवा (या उस बात के लिए किसी भी वेब सेवा) में धागे संसाधन प्रबंधन के मुद्दों का परिचय है कि आप से बचने के लिए चाहते हो सकता है ...

Answer 4

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

Answer 5

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

Answer 6

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

थ्रेड एक प्रक्रिया के भीतर हल्के वजन वाली प्रक्रियाएं हैं।

धागे दो प्रणालियों का उपयोग करके बनाया जा सकता है: थ्रेड वर्ग

बढ़ा कर

1. थ्रेड वर्ग
2. Runnable इंटरफ़ेस को लागू करने

धागा निर्माण का विस्तार

हम एक वर्ग बनाते हैं जो विस्तारित करता है java.lang.Thread कक्षा। यह वर्ग Thread कक्षा में उपलब्ध run() विधि को ओवरराइड करता है। एक थ्रेड run() विधि के अंदर अपना जीवन शुरू करता है। हम अपनी नई कक्षा का एक ऑब्जेक्ट बनाते हैं और थ्रेड के निष्पादन को शुरू करने के लिए start() विधि पर कॉल करते हैं। Start()Thread ऑब्जेक्ट पर run() विधि को आमंत्रित करता है।

class MultithreadingDemo extends Thread{ 
public void run() { 
    try { // Displaying the thread that is running 
     System.out.println ("Thread " + Thread.currentThread().getId() 
           + " is running"); 
     } 
     catch (Exception e){ // Throwing an exception 
      System.out.println ("Exception is caught"); 
     } 
    } 
} 
public class Multithread{ 
    public static void main(String[] args) { 
     int n = 8; // Number of threads 
     for (int i=0; i<8; i++)  { 
      MultithreadingDemo object = new MultithreadingDemo(); 
      object.start(); 
     } 
    } 
} 

थ्रेड Runnable इंटरफ़ेस

को लागू करने से निर्माण हम एक नया वर्ग जो java.lang.Runnable इंटरफ़ेस लागू करता है और run() विधि ओवरराइड पैदा करते हैं। फिर हम एक थ्रेड ऑब्जेक्ट को तुरंत चालू करते हैं और इस ऑब्जेक्ट पर start() विधि को कॉल करते हैं।

class MultithreadingDemo implements Runnable{ 
public void run() { 
    try {  // Displaying the thread that is running 
     System.out.println ("Thread " + Thread.currentThread().getId() + 
          " is running"); 

    } 
    catch (Exception e) {  // Throwing an exception 
     System.out.println ("Exception is caught"); 
    } 
    } 
} 
class Multithread{ 
    public static void main(String[] args) { 
     int n = 8; // Number of threads 
     for (int i=0; i<8; i++)  { 
      Thread object = new Thread(new MultithreadingDemo()); 
      object.start(); 
     } 
    } 
} 

थ्रेड कक्षा बनाम Runnable इंटरफ़ेस

1. अगर हम थ्रेड वर्ग का विस्तार, हमारी कक्षा क्योंकि जावा एकाधिक वंशानुक्रम का समर्थन नहीं करता किसी अन्य वर्ग का विस्तार नहीं कर सकते हैं। लेकिन, अगर हम रननेबल इंटरफेस को लागू करते हैं, तो हमारी कक्षा अभी भी अन्य बेस क्लास का विस्तार कर सकती है।

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

Answer 7

एक नज़र ओरेकल tutorial

1. एक धागा क्या है है?

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

1. क्यों हम सूत्रण के लिए जाते हैं?

   1. मल्टीथ्रेड निष्पादन जावा प्लेटफ़ॉर्म की एक आवश्यक विशेषता है। धागे एक दूसरे से स्वतंत्र हैं।

   2. आप कई उप कंप्यूटेशंस में तोड़कर अपनी गणना को समानांतर बना सकते हैं।

   3. आप अपने सर्वर के सीपीयू कोर प्रभावी ढंग से उपयोग कर सकते हैं।

   उदा।

   ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime() 
         .availableProcessors()); 
   

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

2. धागे पर एक वास्तविक समय उदाहरण।

   व्हाट्सएप के चैट एप्लिकेशन के बारे में सोचें।

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

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

एक धागा वर्ग Runnable लागू करने या Thread विस्तार कर सकते हैं। ऑरैक ट्यूटोरियल page

पर एक नज़र डालें, आप थ्रेड में व्यावसायिक तर्क निष्पादित कर सकते हैं।

आप थ्रेड में विभिन्न वर्ग विधियों को कॉल कर सकते हैं।

Answer 8

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

अब कैसे एक धागा 1. बनाई गई है धागा वर्ग का विस्तार करने के रूप में: धागा वर्ग का विस्तार करने और start() बारे में अपने एक समारोह वर्तमान वर्ग की एक वस्तु का उपयोग कर इसे कहते हैं और एक समारोह अर्थात् लिखने void run() और इस समारोह में कोड लिखने जो समवर्ती रूप से प्रदर्शन करने की जरूरत है।

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

class MyThreads extends Thread 
{ 
int ch ; 

MyThreads(int p) 
{ 
    ch = p; 
    start();//statement to activate thread and call run 
} 

public void run() 
{ 
    if(ch == 1) 
    functionx() 
    else if(ch == 2) 
    functiony(); 

} 

void fx1() 
{ 
    //parallel running code here 
} 

void fx2() 
{ 
    //parallel running code here 
} 

public static void main(String args[]) 
{ 

    MyThreads obj1 = new MyThreads(1); 
    My3Threads obj2 = new MyThreads(2); 

    //mains next instruction code here 

} 
} 

1. आप भी एक इंटरफेस अर्थात् Runnable लागू कर सकते हैं, लेकिन यह एक इंटरफ़ेस जो वर्तमान वर्ग तो बुला शुरू समारोह run() जो इंटरफेस में लिखा है कॉल करेंगे के साथ संगत है है के रूप में लेकिन जैसा कि हम क्यों थ्रेड के लिए जाते हो करने के लिए अब कॉल करने के लिए हमारे run() समारोह इस Thread t=new thread(this); t.start();

की तरह एक धागा वस्तु के साथ शुरू कहते हैं, यह सिर्फ पूछ की तरह कारण है कि हम मल्टीकोर प्रोसेसर के लिए जाते हो तुम मैं क्या कह रहा हूँ मिल , बहु थ्रेडिंग का उपयोग कार्य को एक साथ निष्पादित करने के लिए किया जाता है

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