List.Add () थ्रेड सुरक्षा

Question 1

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

उदाहरण:

List<object> list = new List<object>();
Parallel.ForEach(transactions, tran =>
{
    list.Add(new object());
});

Question 2

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

.NET 4.0 में हमारे पास समवर्ती संग्रह हैं, जो हैंडरली थ्रेडसेफ़ हैं और ताले की आवश्यकता नहीं है।

Question 3

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

List<object> list = transactions.AsParallel()
                                .Select( tran => new object())
                                .ToList();

Question 4

यह कोई अनुचित बात नहीं है। वहाँ रहे हैं मामलों में यदि वे केवल विधि कहा जाता है जहां तरीकों जो अन्य विधियों के संयोजन में धागे की सुरक्षा के मुद्दों पैदा कर सकता है सुरक्षित हैं।

हालाँकि, यह स्पष्ट रूप से इसका कोई मामला नहीं है, जब आप रिफ्लेक्टर में दिखाए गए कोड पर विचार करते हैं:

public void Add(T item)
{
    if (this._size == this._items.Length)
    {
        this.EnsureCapacity(this._size + 1);
    }
    this._items[this._size++] = item;
    this._version++;
}

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

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

Question 5

यदि आप List.addकई थ्रेड्स से उपयोग करना चाहते हैं और ऑर्डर करने की परवाह नहीं करते हैं, तो आपको शायद किसी Listभी तरह से अनुक्रमण क्षमता की आवश्यकता नहीं है, और इसके बजाय उपलब्ध समवर्ती संग्रह में से कुछ का उपयोग करना चाहिए।

यदि आप इस सलाह को अनदेखा करते हैं और केवल करते हैं add, तो आप addथ्रेड को सुरक्षित बना सकते हैं लेकिन इस तरह अप्रत्याशित क्रम में:

private Object someListLock = new Object(); // only once

...

lock (someListLock)
{
    someList.Add(item);
}

यदि आप इस अप्रत्याशित आदेश को स्वीकार करते हैं, तो संभावना है कि जैसा कि आपने पहले उल्लेख किया है कि एक संग्रह की आवश्यकता नहीं है जो कि अनुक्रमण कर सकता है someList[i]।

Question 6

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

कई संभावित समस्याएँ हैं ... बस नहीं। यदि आपको थ्रेड सुरक्षित संग्रह की आवश्यकता है, तो या तो लॉक का उपयोग करें या System.Collections.Concurrent संग्रह में से एक का उपयोग करें।

Question 7

मैंने इस तरह के ConcurrentBag<T>बजाय अपनी समस्या को हल किया List<T>:

ConcurrentBag<object> list = new ConcurrentBag<object>();
Parallel.ForEach(transactions, tran =>
{
    list.Add(new object());
});

Question 8

क्या किसी सूची में आइटम जोड़ने के साथ कुछ भी गलत है अगर धागे कभी सूची पर कोई अन्य संचालन नहीं करते हैं?

संक्षिप्त उत्तर: हाँ।

दीर्घ उत्तर: नीचे दिए गए कार्यक्रम को चलाएं।

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

class Program
{
    readonly List<int> l = new List<int>();
    const int amount = 1000;
    int toFinish = amount;
    readonly AutoResetEvent are = new AutoResetEvent(false);

    static void Main()
    {
        new Program().Run();
    }

    void Run()
    {
        for (int i = 0; i < amount; i++)
            new Thread(AddTol).Start(i);

        are.WaitOne();

        if (l.Count != amount ||
            l.Distinct().Count() != amount ||
            l.Min() < 0 ||
            l.Max() >= amount)
            throw new Exception("omg corrupted data");

        Console.WriteLine("All good");
        Console.ReadKey();
    }

    void AddTol(object o)
    {
        // uncomment to fix
        // lock (l) 
        l.Add((int)o);

        int i = Interlocked.Decrement(ref toFinish);

        if (i == 0)
            are.Set();
    }
}

Question 9

जैसा कि अन्य ने पहले ही कहा था, आप System.Collections.Concurrentनामस्थान से समवर्ती संग्रह का उपयोग कर सकते हैं । यदि आप उनमें से एक का उपयोग कर सकते हैं, तो यह पसंद किया जाता है।

लेकिन अगर आप वास्तव में एक सूची चाहते हैं, जो अभी सिंक्रनाइज़ है, तो आप SynchronizedCollection<T>-Class को देख सकते हैं System.Collections.Generic।

ध्यान दें कि आपको System.ServiceModel असेंबली को शामिल करना था, यही कारण है कि मुझे यह इतना पसंद नहीं है। लेकिन कभी-कभी मैं इसका इस्तेमाल करता हूं।

Question 10

यहां तक कि विभिन्न थ्रेड्स पर तत्व जोड़ना थ्रेड सुरक्षित नहीं है।

C # 4.0 में समवर्ती संग्रह हैं (देखें http://jiezhu0815.blogspot.com/2010/08/c-40-feature-1-concurrent-collections.html )।