Lista Segura de Thread em C#

1. Lista segura de threads com a classe ConcurrentBag em C#
2. Lista segura de threads com a classe ConcurrentQueue em C#
3. Lista segura de threads com a classe SynchronizedCollection em C#

Este tutorial irá apresentar os métodos para criar uma lista de thread-safe em C#.

Lista segura de threads com a classe ConcurrentBag em C#

A classe ConcurrentBag é usada para criar uma coleção de dados thread-safe e não ordenada em C#. A classe ConcurrentBag é muito semelhante à List em C# e pode ser usada como uma lista thread-safe em C#. Para usar a classe ConcurrentBag, temos que importar o System.Collections.Concurrent namespace em nosso projeto. Vários threads podem acessar um objeto ConcurrentBag simultaneamente, mas o conteúdo dentro do objeto ConcurrentBag só pode ser modificado de forma síncrona. Isso o torna utilizável com vários threads para operações simultâneas e seguro contra perda acidental de dados. O exemplo de código a seguir nos mostra como criar uma lista de thread-safe com a classe ConcurrentBag em 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);
      }
    }
  }
}

Resultado:

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

No código acima, criamos uma lista de thread-safe com a classe ConcurrentBag em C#. A função para adicionar novos elementos Add() é a mesma nas estruturas de dados ConcurrentBag e List. A única diferença é que a Lista funciona segundo o princípio do primeiro a entrar, primeiro a sair (FIFO), enquanto o ConcurrentBag funciona segundo o princípio do último a entrar, primeiro a sair (UEPS). Esse problema é abordado nos exemplos de código a seguir.

Lista segura de threads com a classe ConcurrentQueue em C#

A classe ConcurrentQueue é usada para criar uma estrutura de dados de fila thread-safe em C#. O ConcurrentQueue funciona segundo o princípio do primeiro a entrar, primeiro a sair, tal como a Lista em C#. O objeto ConcurrentQueue pode ser usado em vez do objeto List para criar uma estrutura de dados thread-safe. Veja o seguinte código de exemplo.

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

Resultado:

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

No código acima, criamos uma estrutura de dados List thread-safe com a classe ConcurrentQueue em C#. Existem algumas diferenças entre os métodos disponíveis nas estruturas de dados List e ConcurrentQueue. Por exemplo, o método para adicionar um novo elemento na estrutura de dados List é Add(). Em contraste, o método para adicionar um novo elemento na estrutura de dados ConcurrentQueue é Enqueue(), que é exatamente como uma estrutura de dados Queue convencional em C#. Esta desvantagem da estrutura de dados ConcurrentQueue é tratada no exemplo a seguir.

Lista segura de threads com a classe SynchronizedCollection em C#

A classe SynchronizedCollection é usada para criar uma coleção thread-safe de objetos de algum tipo especificado em C#. A estrutura de dados SynchronizedCollection é muito semelhante à estrutura de dados List em C#. Ambas as estruturas de dados funcionam com base no princípio do primeiro a entrar, primeiro a sair. A função para adicionar um novo elemento nas estruturas de dados SynchronizedCollection e List é Add(). Veja o seguinte exemplo.

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

Resultado:

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

No código acima, criamos uma lista de thread-safe com a classe SynchronizedCollection em C#. Até agora, essa abordagem é a melhor entre as outras duas abordagens para implementar a funcionalidade de uma estrutura de dados de lista em C# porque segue o mesmo princípio FIFO e possui os mesmos métodos.