मुख्य धागे का आउटपुट C#में पहले क्यों आता है?




multithreading (5)

मैंने यह छोटा सा कार्यक्रम लिखा:

class Program
{
    static void Main(string[] args)
    {
        Thread t = new Thread(WriteX);
        t.Start();

        for (int i = 0; i < 1000; i++)
        {
            Console.Write("O");
        }
    }

    private static void WriteX()
    {
        for (int i = 0; i < 1000; i++)
        {
            Console.Write(".");
        }
    }
}

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

क्या इसका कोई स्पष्टीकरण है?


आपका कोड गैर नियतात्मक है। आपके कोड में कोई भी सूत्र नहीं है, जो एक थ्रेड की प्राथमिकता दूसरे पर या एक थ्रेड के लिए दूसरे की प्रतीक्षा करने के लिए निर्धारित करेगा।


केवल एक कारण है कि मुख्य धागा निर्मित थ्रेड से पहले खत्म हो जाएगा और ऐसा इसलिए है क्योंकि एक थ्रेड को प्रारंभ करने में समय लगता है। किसी प्रोग्राम को गति देने के लिए थ्रेड्स का उपयोग करने का एकमात्र समय है जब 2 कार्य ठीक उसी समय चलाए जा सकते हैं। यदि आप पहले दूसरे लूप को पूरा करना चाहते हैं, तो Par # पर समानांतर Par पर एक नज़र डालें। # इन लूपों को एक ही समय में लूप के लिए चलाएंगे (उनमें से सभी नहीं बल्कि उतना ही जितना आपका पीसी संभाल सकता है )


मुख्य प्रक्रिया थ्रेड को लागू करने के बाद सेट किए गए अपने अगले निर्देशों को जारी रखें, थ्रेड विधि को प्रकाश प्रक्रिया के रूप में शुरू करने में समय लगेगा।


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

यदि आपके पास सब कुछ फिर से शुरू करने (बाहर निकलने के बिना) के लिए आपके ऐप में एक प्रकार का रीसेट बटन है, तो आप पा सकते हैं कि पहला चरित्र "है।" क्योंकि धागा पहले से मौजूद होगा।


एक जवाब नहीं की तुलना में अधिक सलाह :

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

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

व्यवहार में यह इस तरह दिखेगा:

आपको दो ManualResetEvent s घोषित करने चाहिए जो आपके मुख्य और बैकग्राउंड थ्रेड दोनों के लिए दृश्यमान हैं:

private static ManualResetEvent backgroundThreadReady = new ManualResetEvent(false);
private static ManualResetEvent startThreadRace = new ManualResetEvent(false);

फिर अपने मुख्य सूत्र में, आपको अपने सूत्र के आरंभ होने की प्रतीक्षा करनी चाहिए:

static void Main(string[] args)
{
    Thread t = new Thread(WriteX);
    t.Start();
    backgroundThreadReady.WaitOne(); // wait for background thread to be ready

    startThreadRace.Set();           // signal your background thread to start the race
    for (int i = 0; i < 1000; i++)
    {
        Console.Write("O");
    }
}

और आपके धागे में:

    private static void WriteX()
    {
        backgroundThreadReady.Set(); // inform your main thread that this thread is ready for the race

        startThreadRace.WaitOne();   // wait 'till the main thread starts the race
        for (int i = 0; i < 1000; i++)
        {
            Console.Write(".");
        }
    }

कृपया ध्यान दें कि मैं अन्य प्रतीक्षा योग्य सिंक ऑब्जेक्ट्स (म्यूटेक्स, ऑटोरेसेट इवेंट, यहां तक ​​कि कुछ हैक के साथ एक महत्वपूर्ण अनुभाग लॉक का उपयोग कर सकता था, मैंने बस सबसे सरल, सबसे तेज़ समाधान चुना है जिसे आसानी से बढ़ाया जा सकता है)।







multithreading