java - एक ही समय में "बिल्कुल" पर दो धागे कैसे शुरू करें




multithreading (5)

  1. जैसा कि मैं इसे समझता हूं, जेवीएम ज्यादातर इस सामान को ऑपरेटिंग सिस्टम में भेजता है। तो जवाब ओएस-विशिष्ट होगा।
  2. यह एकल प्रोसेसर मशीनों पर स्पष्ट रूप से असंभव है।
  3. बहु-प्रोसेसर मशीन के संबंध में यह अधिक जटिल है। एक साथ सापेक्षता के अनुसार, "एक पूर्ण अर्थ में कहना असंभव है कि क्या दो घटनाएं एक ही समय में होती हैं यदि उन घटनाओं को अंतरिक्ष में अलग किया जाता है।" कोई फर्क नहीं पड़ता कि आपके प्रोसेसर कितने करीब हैं, वे अंतरिक्ष में अलग हो गए हैं।
    1. यदि आप सापेक्ष एक साथ स्वीकार कर सकते हैं, तो अन्य प्रतिक्रियाओं में चर्चा की गई तकनीकों का उपयोग करके इसे अनुकरण करना संभवतः आसान है।

धागे एक ही विभाजित दूसरे पर शुरू होना चाहिए। मैं समझता हूं, अगर आप thread1.start() करते हैं, तो यह thread1.start() के अगले निष्पादन से पहले कुछ मिलीसेकंड thread2.start()

क्या यह भी संभव या असंभव है?


आप इसके लिए एक countDownLatch का उपयोग कर सकते हैं। कृपया एक नमूना नीचे खोजें। हालांकि टी 1 और टी 2 शुरू हो गए हैं, ये धागे इंतजार करते रहते हैं जब तक कि मुख्य थ्रेड लच के नीचे गिना जाता है। कन्स्ट्रक्टर में आवश्यक उलटी गिनती की संख्या का उल्लेख किया गया है। उलटी गिनती का उपयोग थ्रेड को निष्पादन को समाप्त करने के लिए भी इंतजार करने के लिए किया जा सकता है ताकि मुख्य धागा आगे बढ़ सके (रिवर्स केस)। यह कक्षा जावा 1.5 के बाद शामिल थी।

import java.util.concurrent.CountDownLatch;


public class ThreadExample
{
    public static void main(String[] args) 
    {
        CountDownLatch latch = new CountDownLatch(1);
        MyThread t1 = new MyThread(latch);
        MyThread t2 = new MyThread(latch);
        new Thread(t1).start();
        new Thread(t2).start();
        //Do whatever you want
        latch.countDown();          //This will inform all the threads to start
        //Continue to do whatever
    }
}

class MyThread implements Runnable
{
    CountDownLatch latch;
    public MyThread(CountDownLatch latch) 
    {
        this.latch = latch;
    }
    @Override
    public void run() 
    {
        try 
        {
            latch.await();          //The thread keeps waiting till it is informed
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //Do the actual thing
    }
}

थ्रेड को एक ही समय में शुरू करने के लिए (कम से कम जितना संभव हो उतना अच्छा), आप CyclicBarrier उपयोग कर सकते हैं:

// We want to start just 2 threads at the same time, but let's control that 
// timing from the main thread. That's why we have 3 "parties" instead of 2.
final CyclicBarrier gate = new CyclicBarrier(3);

Thread t1 = new Thread(){
    public void run(){
        gate.await();
        //do stuff    
    }};
Thread t2 = new Thread(){
    public void run(){
        gate.await();
        //do stuff    
    }};

t1.start();
t2.start();

// At this point, t1 and t2 are blocking on the gate. 
// Since we gave "3" as the argument, gate is not opened yet.
// Now if we block on the gate from the main thread, it will open
// and all threads will start to do stuff!

gate.await();
System.out.println("all threads started");

यह एक CyclicBarrier नहीं होना चाहिए, आप एक CyclicBarrier या यहां तक ​​कि लॉक का भी उपयोग कर सकते हैं।

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

अन्य प्लेटफार्मों पर, थ्रेड शुरू करना बिल्कुल एक बहुत ही वैध आवश्यकता बीटीडब्ल्यू हो सकता है।


कम से कम एक कोर कंप्यूटर पर यह संभव नहीं है। लेकिन आप ऐसा क्यों चाहते हैं? भले ही आप एक ही दूसरे पर दो धागे शुरू करने में सक्षम थे, फिर भी वे अलग-अलग प्रगति करेंगे क्योंकि शेड्यूलिंग आपके नियंत्रण में नहीं है।

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


यह अब एक बहु-वर्षीय प्रश्न है, लेकिन बहुत लोकप्रिय होने के कारण, सी ++ 11 मेमोरी मॉडल के बारे में सीखने के लिए एक शानदार संसाधन का उल्लेख करना उचित है। मुझे यह एक और पूर्ण जवाब देने के लिए अपनी बातचीत को संक्षेप में कोई बात नहीं दिखती है, लेकिन यह वह व्यक्ति है जिसने वास्तव में मानक लिखा है, मुझे लगता है कि यह बात देखने के लायक है।

हर्ब सटर में चैनल 9 साइट - भाग 1 और भाग 2 पर उपलब्ध "परमाणु <> हथियार" नामक सी ++ 11 मेमोरी मॉडल के बारे में तीन घंटे की लंबी बात है। बात बहुत तकनीकी है, और निम्नलिखित विषयों को शामिल करती है:

  1. अनुकूलन, दौड़, और मेमोरी मॉडल
  2. ऑर्डरिंग - क्या: प्राप्त करें और रिलीज़ करें
  3. ऑर्डरिंग - कैसे: म्यूटेक्स, परमाणु, और / या बाड़
  4. कंपाइलर्स और हार्डवेयर पर अन्य प्रतिबंध
  5. कोड जनरल और प्रदर्शन: x86 / x64, आईए 64, पावर, एआरएम
  6. आराम से परमाणु

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





java multithreading