List.Add () iş parçacığı güvenliği

Genel olarak bir Listenin iş parçacığı için güvenli olmadığını anlıyorum, ancak iş parçacıkları listede başka hiçbir işlem yapmıyorsa (örneğin, gezinmek gibi) bir listeye öğe eklemede yanlış bir şey var mı?

Misal:

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

Tamponların yeniden tahsis edilmesi ve öğelerin kopyalanması gibi perde arkasında pek çok şey olur. Bu kod tehlikeye neden olur. Çok basit bir ifadeyle, bir listeye eklerken atomik işlem yoktur, en azından "Uzunluk" özelliğinin güncellenmesi gerekir ve öğenin doğru konuma yerleştirilmesi gerekir ve (ayrı bir değişken varsa) dizinin güncellenecek. Birden çok iş parçacığı birbirinin üzerinden geçebilir. Ve eğer bir büyüme gerekiyorsa, o zaman çok daha fazlası var. Bir listeye bir şey yazıyorsa, başka hiçbir şey onu okumamalı veya yazmamalıdır.

.NET 4.0'da eşzamanlı koleksiyonlarımız var, bunlar kullanıma hazır evreler için güvenli ve kilit gerektirmeyen.

Şu anki yaklaşımınız iş parçacığı açısından güvenli değil - bundan tamamen kaçınmanızı öneririm - temelde bir veri dönüşümü yapıyorsunuz PLINQ daha iyi bir yaklaşım olabilir (bunun basitleştirilmiş bir örnek olduğunu biliyorum ama sonunda her işlemi başka bir "duruma yansıtıyorsunuz " nesne).

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

Sormak mantıksız bir şey değil. Orada vardır dedikleri tek yöntem ise diğer yöntemlerle birlikte iş parçacığı emniyet sorunlarına neden olabilir yöntemleri güvenlidir davaları.

Ancak, reflektörde gösterilen kodu göz önünde bulundurduğunuzda, bu açıkça bir durum değildir:

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

EnsureCapacityKendi içinde iş parçacığı güvenli olsa bile (ve kesinlikle değildir), yukarıdaki kod, artım operatörüne eşzamanlı çağrıların yanlış yazmalara neden olma olasılığı göz önüne alındığında, açıkça iş parçacığı güvenli olmayacaktır.

Ya kilitleyin, ConcurrentList'i kullanın ya da birden fazla iş parçacığının yazdığı yer için kilitsiz bir kuyruk kullanın ve işlerini bitirdikten sonra - ya doğrudan ya da bir listeyi doldurarak - ondan okuyun (varsayıyorum ki Birden çok eşzamanlı yazma ve ardından tek iş parçacıklı okuma burada sizin kalıbınızdır, sorunuza bakılırsa, aksi takdirde Addçağrılan tek yöntemin nerede olduğu koşulun herhangi bir işe yarayabileceğini göremiyorum ).

Birden List.addçok iş parçacığından kullanmak istiyorsanız ve sıralamayı önemsemiyorsanız, muhtemelen bir Listzaten indeksleme yeteneğine ihtiyacınız yoktur ve bunun yerine mevcut eşzamanlı koleksiyonlardan bazılarını kullanmanız gerekir.

Bu tavsiyeyi görmezden gelirseniz ve yalnızca yaparsanız add, addipliği güvenli hale getirebilirsiniz, ancak bunun gibi öngörülemeyen bir sırayla:

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

...

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

Bu öngörülemeyen sıralamayı kabul ederseniz, daha önce de belirtildiği gibi, indeksleme yapabilen bir koleksiyona ihtiyacınız olmayabilir someList[i].

Liste bir dizi üzerine kurulduğundan ve iş parçacığı güvenli olmadığından, bu sorunlara neden olabilir, iş parçacığının nerede olduğuna bağlı olarak sınırların dışında bir istisna veya diğer değerleri geçersiz kılan bazı değerler elde edebilirsiniz. Temel olarak, bunu yapma.

Birden fazla potansiyel sorun var ... Sadece yapma. İş parçacığı için güvenli bir koleksiyona ihtiyacınız varsa, bir kilit veya System.Collections.Concurrent koleksiyonlarından birini kullanın.

Sorunumu ConcurrentBag<T>bunun yerine kullanarak çözdüm List<T>:

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

İş parçacıkları listede başka hiçbir işlem yapmazsa, bir listeye öğe eklemede yanlış bir şey var mı?

Kısa cevap: evet.

Uzun cevap: aşağıdaki programı çalıştırın.

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();
    }
}

Diğerlerinin daha önce söylediği gibi, System.Collections.Concurrentad alanından eşzamanlı koleksiyonları kullanabilirsiniz . Bunlardan birini kullanabiliyorsanız bu tercih edilir.

Ama gerçekten senkronize edilmiş bir liste istiyorsanız, SynchronizedCollection<T>-Class in'e bakabilirsiniz System.Collections.Generic.

System.ServiceModel derlemesini dahil etmeniz gerektiğine dikkat edin, bu da onu çok sevmememin nedenidir. Ama bazen kullanıyorum.

Farklı dişlere eleman eklemek bile iş parçacığı açısından güvenli değildir.

C # 4.0'da eşzamanlı koleksiyonlar vardır (bkz. Http://jiezhu0815.blogspot.com/2010/08/c-40-feature-1-concurrent-collections.html ).