List.Add () безпека потоку

Я розумію, що загалом Список не є безпечним для потоків, проте чи є щось погане у простому додаванні елементів до списку, якщо потоки ніколи не виконують жодних інших операцій зі списком (наприклад, обхід його)?

Приклад:

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

За лаштунками відбувається багато чого, включаючи перерозподіл буферів та копіювання елементів. Цей код створить небезпеку. Дуже просто, при додаванні до списку не відбувається атомних операцій, принаймні властивість "Length" має бути оновленим, а елемент потрібно розміщувати в потрібному місці, і (якщо є окрема змінна) індекс потребує для оновлення. Кілька ниток можуть топтати один одного. І якщо потрібно вирощувати, то тут відбувається набагато більше. Якщо щось пишеться до списку, ніщо інше не повинно читати або писати до нього.

У .NET 4.0 ми маємо одночасні колекції, які легко безпечні для потоків і не потребують блокування.

Ваш поточний підхід не є безпечним для потоку - я б запропонував цього взагалі уникати - оскільки ви в основному робите перетворення даних PLINQ, можливо, є кращим підходом (я знаю, що це спрощений приклад, але в підсумку ви проектуєте кожну транзакцію в інший "стан" "об'єкт).

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

Запитати це нерозумно. Там є випадки , коли методи , які можуть викликати проблеми безпеки потоків в поєднанні з іншими методами є безпечними , якщо вони є єдиним методом , називається.

Однак це явно не випадок, коли ви розглядаєте код, показаний у рефлекторі:

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

Навіть якщо EnsureCapacityвін сам по собі був threadsafe (а це, безсумнівно, ні), вищезазначений код явно не буде безпечним, враховуючи можливість одночасних викликів оператору збільшення, що спричиняє помилкові записи.

Або заблокуйте, використовуйте ConcurrentList, або, можливо, використовуйте безблокову чергу, як місце, куди записують декілька потоків, і читання з нього - або безпосередньо, або заповнення списку ним - після того, як вони виконають свою роботу (я припускаю, що декілька одночасних записів з подальшим однопотоковим читанням - це ваш шаблон тут, судячи з вашого запитання, оскільки в іншому випадку я не бачу, як умова, де Addє єдиний викликаний метод, може бути корисною).

Якщо ви хочете використовувати List.addз декількох потоків і не піклуєтесь про впорядкування, тоді вам, мабуть, не потрібна можливість індексування Listбудь-якого способу , а замість цього слід використовувати деякі доступні паралельні колекції.

Якщо ви проігноруєте цю пораду і лише зробите add, ви можете зробити addнитку безпечною, але в непередбачуваному порядку, як це:

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

...

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

Якщо ви приймаєте це непередбачуване впорядкування, швидше за все, вам, як згадувалося раніше, не потрібна колекція, яка може виконувати індексацію, як у someList[i].

Це може спричинити проблеми, оскільки Список будується над масивом і не є безпечним для потоку, тому ви можете отримати індекс за межами винятків або деякі значення, що перевизначають інші значення, залежно від того, де знаходяться потоки. В основному, не робіть цього.

Є кілька потенційних проблем ... Просто не робіть. Якщо вам потрібна ниткобезпечна колекція, використовуйте замок або одну з колекцій System.Collections.Concurrent.

Я вирішив свою проблему, використовуючи ConcurrentBag<T>замість List<T>цього:

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

Чи є щось погане в простому додаванні елементів у список, якщо потоки ніколи не виконують жодних інших операцій у списку?

Коротка відповідь: так.

Довга відповідь: запустіть програму нижче.

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

Як вже говорили інші, ви можете використовувати одночасні колекції з System.Collections.Concurrentпростору імен. Якщо ви можете скористатися одним із них, це переважно.

Але якщо вам дійсно потрібен список, який просто синхронізований, ви можете подивитися на SynchronizedCollection<T>-Class в System.Collections.Generic.

Зверніть увагу, що вам довелося включити збірку System.ServiceModel, що також є причиною того, чому мені це не так подобається. Але іноді я цим користуюся.

Навіть додавання елементів у різні потоки не є безпечним для потоків.

У C # 4.0 є паралельні колекції (див. Http://jiezhu0815.blogspot.com/2010/08/c-40-feature-1-concurrent-collections.html ).