Elenco sicuro dei thread in C#

1. Elenco thread safe con la classe ConcurrentBag in C#
2. Elenco thread safe con la classe ConcurrentQueue in C#
3. Elenco thread-safe con la classe SynchronizedCollection in C#

Questo tutorial introdurrà i metodi per creare una lista thread-safe in C#.

Elenco thread safe con la classe ConcurrentBag in C#

La classe ConcurrentBag viene utilizzata per creare una raccolta di dati non ordinata e thread-safe in C#. La classe ConcurrentBag è molto simile a List in C# e può essere utilizzata come elenco thread-safe in C#. Per utilizzare la classe ConcurrentBag, dobbiamo importare lo spazio dei nomi System.Collections.Concurrent nel nostro progetto. Più thread possono accedere simultaneamente a un oggetto ConcurrentBag, ma il contenuto all’interno dell’oggetto ConcurrentBag può essere modificato solo in modo sincrono. Lo rende utilizzabile con più thread per operazioni simultanee e al sicuro dalla perdita accidentale di dati. Il seguente esempio di codice ci mostra come creare una lista thread-safe con la classe ConcurrentBag in C#.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;

namespace thread_safe_list {
  class Program {
    static void Main(string[] args) {
      ConcurrentBag<int> numbers = new ConcurrentBag<int>();
      numbers.Add(0);
      numbers.Add(1);
      numbers.Add(2);
      numbers.Add(3);
      numbers.Add(4);
      numbers.Add(5);
      Console.WriteLine("ConcurrentBag");
      foreach (var number in numbers) {
        Console.WriteLine(number);
      }
      List<int> nums = new List<int>();
      nums.Add(0);
      nums.Add(1);
      nums.Add(2);
      nums.Add(3);
      nums.Add(4);
      nums.Add(5);
      Console.WriteLine("List");
      foreach (var number in nums) {
        Console.WriteLine(number);
      }
    }
  }
}

Produzione:

ConcurrentBag 5 4 3 2 1 0 List 0 1 2 3 4 5

Nel codice precedente, abbiamo creato una lista thread-safe con la classe ConcurrentBag in C#. La funzione per aggiungere nuovi elementi Add() è la stessa sia nelle strutture dati ConcurrentBag che List. L’unica differenza è che la Lista funziona sul principio del first in first out (FIFO), mentre la ConcurrentBag funziona sul principio dell’ultimo in first out (LIFO). Questo problema viene risolto negli esempi di codice riportati di seguito.

Elenco thread safe con la classe ConcurrentQueue in C#

La classe ConcurrentQueue viene utilizzata per creare una struttura di dati della coda thread-safe in C#. La ConcurrentQueue funziona secondo il principio del first in, first out, proprio come la List in C#. L’oggetto ConcurrentQueue può essere utilizzato al posto dell’oggetto List per creare una struttura di dati thread-safe. Vedere il seguente codice di esempio.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;

namespace thread_safe_list {
  class Program {
    static void Main(string[] args) {
      Console.WriteLine("Concurrent Queue");
      ConcurrentQueue<int> numbers = new ConcurrentQueue<int>();
      numbers.Enqueue(0);
      numbers.Enqueue(1);
      numbers.Enqueue(2);
      numbers.Enqueue(3);
      numbers.Enqueue(4);
      numbers.Enqueue(5);
      foreach (var number in numbers) {
        Console.WriteLine(number);
      }
      Console.WriteLine("List");
      List<int> nums = new List<int>();
      nums.Add(0);
      nums.Add(1);
      nums.Add(2);
      nums.Add(3);
      nums.Add(4);
      nums.Add(5);
      foreach (var number in nums) {
        Console.WriteLine(number);
      }
    }
  }
}

Produzione:

Concurrent Queue 0 1 2 3 4 5 List 0 1 2 3 4 5

Nel codice precedente, abbiamo creato una struttura dati List thread-safe con la classe ConcurrentQueue in C#. Ci sono alcune differenze tra i metodi disponibili nelle strutture dati List e ConcurrentQueue. Ad esempio, il metodo per aggiungere un nuovo elemento nella struttura dati List è Add(). Al contrario, il metodo per aggiungere un nuovo elemento nella struttura dati ConcurrentQueue è Enqueue(), che è proprio come una struttura dati Queue convenzionale in C#. Questo inconveniente della struttura dati ConcurrentQueue viene affrontato nel seguente esempio.

Elenco thread-safe con la classe SynchronizedCollection in C#

La classe SynchronizedCollection viene utilizzata per creare una raccolta thread-safe di oggetti di un tipo specificato in C#. La struttura dei dati SynchronizedCollection è molto simile alla struttura dei dati List in C#. Entrambe le strutture dati funzionano secondo il principio del primo entrato, primo uscito. La funzione per aggiungere un nuovo elemento sia nella struttura dati SynchronizedCollection che nella struttura dati List è Add(). Vedi il seguente esempio.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;

namespace thread_safe_list {
  class Program {
    static void Main(string[] args) {
      Console.WriteLine("Synchronized Collection");
      SynchronizedCollection<int> numbers = new SynchronizedCollection<int>();
      numbers.Add(0);
      numbers.Add(1);
      numbers.Add(2);
      numbers.Add(3);
      numbers.Add(4);
      numbers.Add(5);
      foreach (var number in numbers) {
        Console.WriteLine(number);
      }
      Console.WriteLine("List");
      List<int> nums = new List<int>();
      nums.Add(0);
      nums.Add(1);
      nums.Add(2);
      nums.Add(3);
      nums.Add(4);
      nums.Add(5);
      foreach (var number in nums) {
        Console.WriteLine(number);
      }
    }
  }
}

Produzione:

Synchronized Collection 0 1 2 3 4 5 List 0 1 2 3 4 5

Nel codice precedente, abbiamo creato una lista thread-safe con la classe SynchronizedCollection in C#. Finora, questo approccio è il migliore tra gli altri due approcci per implementare la funzionalità di una struttura di dati di elenco in C# perché segue lo stesso principio FIFO e contiene gli stessi metodi.