C#怎么使用ConcurrentBag线程安全集合 C#如何用ConcurrentBag在多线程中安全地添加和遍历元素

在C#的多线程开发场景中，当多个线程需要同时操作同一个集合时，普通的List、HashSet等集合会因为线程不安全的特性，出现数据覆盖、索引越界、状态异常等问题，即使手动加锁也会增加代码复杂度。ConcurrentBag是System.Collections.Concurrent命名空间下的线程安全集合，内部实现了高效的线程同步机制，无需开发者手动加锁，就能在多线程环境下安全地完成元素的添加、遍历等操作，非常适合高并发场景下的临时数据存储和流转。

ConcurrentBag的核心特性

ConcurrentBag是一个无序的线程安全集合，它的设计目标是为多线程场景下的元素操作提供高效的同步支持，核心特性如下：

• 线程安全：所有公开方法都内置了线程同步逻辑，多个线程同时调用添加、遍历等方法不会出现数据异常。
• 无序存储：元素没有固定的顺序，不同线程获取元素的顺序可能不一致，不适合需要顺序的场景。
• 支持消费式遍历：提供了GetConsumingEnumerable方法，可以遍历集合的同时移除元素，适合生产者-消费者模式。
• 无需手动加锁：内部使用了分段锁、线程本地存储等优化机制，性能比手动加锁的普通集合更高。

多线程中安全添加元素

ConcurrentBag的Add方法是线程安全的，多个线程可以直接调用该方法向集合中添加元素，不需要额外的同步处理。下面通过一个示例演示3个线程同时向ConcurrentBag中添加元素的过程：

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        // 创建ConcurrentBag实例
        ConcurrentBag<int> bag = new ConcurrentBag<int>();

        // 创建3个线程任务，每个任务添加5个元素
        Task task1 = Task.Run(() =>
        {
            for (int i = 1; i <= 5; i++)
            {
                bag.Add(i);
                Console.WriteLine($"线程1添加元素：{i}");
                Thread.Sleep(100); // 模拟操作耗时
            }
        });

        Task task2 = Task.Run(() =>
        {
            for (int i = 6; i <= 10; i++)
            {
                bag.Add(i);
                Console.WriteLine($"线程2添加元素：{i}");
                Thread.Sleep(100);
            }
        });

        Task task3 = Task.Run(() =>
        {
            for (int i = 11; i <= 15; i++)
            {
                bag.Add(i);
                Console.WriteLine($"线程3添加元素：{i}");
                Thread.Sleep(100);
            }
        });

        // 等待所有任务完成
        Task.WaitAll(task1, task2, task3);
        Console.WriteLine($"所有元素添加完成，集合总元素数：{bag.Count}");
    }
}

上述代码中，三个线程同时调用bag.Add方法添加元素，最终集合的元素数量是15，没有出现丢失或者重复的情况，说明Add方法在多线程下是安全的。如果需要判断元素是否添加成功，ConcurrentBag的Add方法没有返回值，但是因为是线程安全的，只要调用就会成功添加，不需要额外判断。

多线程中安全遍历元素

ConcurrentBag提供了两种遍历方式，分别是普通遍历和消费式遍历，两种方式都支持多线程场景下的安全操作。

普通遍历

普通遍历使用foreach循环直接遍历集合，遍历过程中不会移除元素，适合需要读取所有元素但不需要删除的场景。遍历过程中如果其他线程继续添加元素，新添加的元素可能不会出现在本次遍历中，这是ConcurrentBag的设计特性，避免遍历时的阻塞。

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        ConcurrentBag<string> bag = new ConcurrentBag<string>();

        // 先添加3个元素
        bag.Add("元素1");
        bag.Add("元素2");
        bag.Add("元素3");

        // 启动一个线程继续添加元素
        Task addTask = Task.Run(() =>
        {
            Thread.Sleep(500);
            bag.Add("元素4");
            bag.Add("元素5");
        });

        // 主线程遍历集合
        Console.WriteLine("开始遍历集合：");
        foreach (var item in bag)
        {
            Console.WriteLine(item);
            Thread.Sleep(200); // 模拟遍历耗时
        }

        // 等待添加任务完成后再遍历一次
        addTask.Wait();
        Console.WriteLine("再次遍历集合：");
        foreach (var item in bag)
        {
            Console.WriteLine(item);
        }
    }
}

消费式遍历

消费式遍历通过GetConsumingEnumerable方法实现，遍历过程中会将元素从集合中移除，适合生产者-消费者模式，比如一个线程生产数据放入集合，多个线程消费集合中的数据。当集合为空且没有其他线程会继续添加元素时，遍历会自动结束。

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        ConcurrentBag<int> bag = new ConcurrentBag<int>();

        // 生产者线程，添加10个元素
        Task producer = Task.Run(() =>
        {
            for (int i = 1; i <= 10; i++)
            {
                bag.Add(i);
                Console.WriteLine($"生产者添加元素：{i}");
                Thread.Sleep(150);
            }
        });

        // 两个消费者线程，消费集合中的元素
        Task consumer1 = Task.Run(() =>
        {
            Console.WriteLine("消费者1开始消费：");
            foreach (var item in bag.GetConsumingEnumerable())
            {
                Console.WriteLine($"消费者1消费元素：{item}");
                Thread.Sleep(300);
            }
            Console.WriteLine("消费者1消费结束");
        });

        Task consumer2 = Task.Run(() =>
        {
            Console.WriteLine("消费者2开始消费：");
            foreach (var item in bag.GetConsumingEnumerable())
            {
                Console.WriteLine($"消费者2消费元素：{item}");
                Thread.Sleep(300);
            }
            Console.WriteLine("消费者2消费结束");
        });

        // 等待所有任务完成
        Task.WaitAll(producer, consumer1, consumer2);
        Console.WriteLine($"最终集合元素数量：{bag.Count}");
    }
}

上述代码中，生产者添加元素后，两个消费者通过GetConsumingEnumerable遍历消费元素，最终集合的元素数量会变为0，所有元素都被成功消费，不会出现重复消费或者遗漏的情况。

使用注意事项

• ConcurrentBag是无序集合，不要依赖元素的添加顺序或者遍历顺序，如果需要有序的集合，可以考虑使用ConcurrentQueue等有序的线程安全集合。
• Count属性在多线程场景下获取的值可能不是实时的，因为其他线程可能正在添加或者移除元素，如果需要精确的数量，建议先通过ToArray方法转为数组后再统计。
• 消费式遍历GetConsumingEnumerable会移除元素，如果不需要移除元素，不要使用这种方式遍历。
• ConcurrentBag不适合存储需要频繁查找的元素，因为它没有提供高效的查找方法，查找需要遍历整个集合，性能较低。

适用场景总结

ConcurrentBag最适合以下场景：多线程下临时存储数据、生产者-消费者模式中的数据缓存、不需要顺序和查找的多线程数据共享。如果场景需要顺序、查找、固定容量等特性，应该选择其他对应的线程安全集合，比如ConcurrentQueue、ConcurrentDictionary等。

C#ConcurrentBag线程安全集合多线程AddGetConsumingEnumerable修改时间：2026-06-09 12:42:25