पहचानकर्ता और बंद हो जाता है

Question 1

निम्नलिखित दो स्निपेट में, पहला सुरक्षित है या आपको दूसरा काम करना चाहिए?

सुरक्षित रूप से मेरा मतलब है कि प्रत्येक थ्रेड को उसी लूप चलना से विधि को कॉल करने की गारंटी है जिसमें धागा बनाया गया था?

या क्या आपको लूप के प्रत्येक पुनरावृत्ति के लिए एक नए चर "स्थानीय" के संदर्भ को कॉपी करना चाहिए?

var threads = new List<Thread>();
foreach (Foo f in ListOfFoo)
{      
    Thread thread = new Thread(() => f.DoSomething());
    threads.Add(thread);
    thread.Start();
}

-

var threads = new List<Thread>();
foreach (Foo f in ListOfFoo)
{      
    Foo f2 = f;
    Thread thread = new Thread(() => f2.DoSomething());
    threads.Add(thread);
    thread.Start();
}

अपडेट: जैसा कि जॉन स्कीट के जवाब में बताया गया है, इसका विशेष रूप से थ्रेडिंग से कोई लेना-देना नहीं है।

Question 2

संपादित करें: यह सब C # 5 में बदलता है, जहां परिवर्तन को परिभाषित किया जाता है (कंपाइलर की आंखों में)। से सी # 5 के बाद, वे एक ही हैं ।

C # 5 से पहले

दूसरा सुरक्षित है; पहला नहीं है।

के साथ foreach, चर को लूप के बाहर घोषित किया जाता है - यानी

Foo f;
while(iterator.MoveNext())
{
     f = iterator.Current;
    // do something with f
}

इसका मतलब है कि fबंद होने की गुंजाइश के मामले में केवल 1 है, और थ्रेड्स बहुत उलझन में पड़ सकते हैं - विधि को कई बार कुछ उदाहरणों पर कॉल करना और दूसरों पर बिल्कुल नहीं। आप इसे लूप के अंदर एक दूसरे चर घोषणा के साथ ठीक कर सकते हैं :

foreach(Foo f in ...) {
    Foo tmp = f;
    // do something with tmp
}

यह तब tmpप्रत्येक बंद दायरे में एक अलग होता है, इसलिए इस मुद्दे का कोई जोखिम नहीं है।

यहाँ समस्या का एक सरल प्रमाण है:

    static void Main()
    {
        int[] data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        foreach (int i in data)
        {
            new Thread(() => Console.WriteLine(i)).Start();
        }
        Console.ReadLine();
    }

आउटपुट (यादृच्छिक पर):

एक अस्थायी चर जोड़ें और यह काम करता है:

        foreach (int i in data)
        {
            int j = i;
            new Thread(() => Console.WriteLine(j)).Start();
        }

(प्रत्येक संख्या एक बार, लेकिन निश्चित रूप से आदेश की गारंटी नहीं है)

Question 3

पॉप कैटलिन और मार्क ग्रेवेल के उत्तर सही हैं। सभी जो मैं जोड़ना चाहता हूं, वह क्लोजर के बारे में मेरे लेख की एक कड़ी है (जो जावा और सी # दोनों के बारे में बात करता है)। बस सोचा था कि यह थोड़ा मूल्य जोड़ सकता है।

संपादित करें: मुझे लगता है कि यह एक उदाहरण देने के लायक है, जिसमें थ्रेडिंग की अप्रत्याशितता नहीं है। यहां दोनों दृष्टिकोणों को दर्शाने वाला एक छोटा लेकिन संपूर्ण कार्यक्रम है। "खराब कार्रवाई" सूची 10 दस बार प्रिंट करती है; "अच्छी कार्रवाई" सूची 0 से 9 तक गिना जाती है।

using System;
using System.Collections.Generic;

class Test
{
    static void Main() 
    {
        List<Action> badActions = new List<Action>();
        List<Action> goodActions = new List<Action>();
        for (int i=0; i < 10; i++)
        {
            int copy = i;
            badActions.Add(() => Console.WriteLine(i));
            goodActions.Add(() => Console.WriteLine(copy));
        }
        Console.WriteLine("Bad actions:");
        foreach (Action action in badActions)
        {
            action();
        }
        Console.WriteLine("Good actions:");
        foreach (Action action in goodActions)
        {
            action();
        }
    }
}

Question 4

विकल्प 2 का उपयोग करने की आवश्यकता है, बदलते चर के चारों ओर एक क्लोजर बनाने से चर के मूल्य का उपयोग तब होगा जब चर का उपयोग किया जाता है और समापन समय पर नहीं।

C # और उसके परिणामों में अनाम विधियों का कार्यान्वयन (भाग 1)

C # और उसके परिणामों में अनाम विधियों का कार्यान्वयन (भाग 2)

C # और उसके परिणामों में अनाम विधियों का कार्यान्वयन (भाग 3)

संपादित करें: यह स्पष्ट करने के लिए, C # क्लोजर में " लेक्सिकल क्लोजर " हैं, जिसका अर्थ है कि वे किसी वैरिएबल के मान को नहीं बल्कि वेरिएबल को ही कैप्चर करते हैं। इसका मतलब यह है कि बदलते चर को बंद करते समय वास्तव में बंद चर का संदर्भ है, इसकी कीमत की प्रतिलिपि नहीं है।

Edit2: सभी ब्लॉग पोस्ट के लिए लिंक जोड़ा गया है अगर कोई भी कंपाइलर इंटर्न के बारे में पढ़ने में रुचि रखता है।

Question 5

यह एक दिलचस्प सवाल है और ऐसा लगता है जैसे हमने लोगों को सभी विभिन्न तरीकों से जवाब देते देखा है। मैं इस धारणा के तहत था कि दूसरा रास्ता एकमात्र सुरक्षित रास्ता होगा। मैं एक असली त्वरित सबूत मार पड़ी है:

class Foo
{
    private int _id;
    public Foo(int id)
    {
        _id = id;
    }
    public void DoSomething()
    {
        Console.WriteLine(string.Format("Thread: {0} Id: {1}", Thread.CurrentThread.ManagedThreadId, this._id));
    }
}
class Program
{
    static void Main(string[] args)
    {
        var ListOfFoo = new List<Foo>();
        ListOfFoo.Add(new Foo(1));
        ListOfFoo.Add(new Foo(2));
        ListOfFoo.Add(new Foo(3));
        ListOfFoo.Add(new Foo(4));


        var threads = new List<Thread>();
        foreach (Foo f in ListOfFoo)
        {
            Thread thread = new Thread(() => f.DoSomething());
            threads.Add(thread);
            thread.Start();
        }
    }
}

यदि आप इसे चलाते हैं तो आपको विकल्प 1 दिखाई देगा निश्चित रूप से सुरक्षित नहीं है।

Question 6

आपके मामले में, आप ListOfFooथ्रेड के अनुक्रम में मैपिंग करके कॉपी ट्रिक का उपयोग किए बिना समस्या से बच सकते हैं :

var threads = ListOfFoo.Select(foo => new Thread(() => foo.DoSomething()));
foreach (var t in threads)
{
    t.Start();
}

Question 7

दोनों सी # संस्करण 5 (.NET फ्रेमवर्क 4.5) के रूप में सुरक्षित हैं। विवरण के लिए इस प्रश्न को देखें: क्या चर के उपयोग को चर # 5 में बदल दिया गया है?

Question 8

Foo f2 = f;

के रूप में एक ही संदर्भ के लिए अंक

इसलिए कुछ भी नहीं खोया और कुछ भी हासिल नहीं हुआ ...