C#_队列执行函数，跨线程队列必须使用ConcurrentQueue！

刚猛宝宝

已于 2024-10-29 13:50:08 修改

阅读量380

点赞数

分类专栏： C# 文章标签： c# 开发语言

于 2024-10-12 19:13:12 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_43986048/article/details/142884287

版权

C# 专栏收录该内容

29 篇文章 ¥9.90 ¥99.00

订阅专栏

超级会员免费看

我们经常会遇到一些函数多个地方调用，但是同一时间只能一个地方执行就需要用到队列，让他们排队执行。

1.创建多线程专用队列ConcurrentQueue。

注：若使用Queue队列从不同线程进队列会有问题，运行时间长了会加不进来！因为它不是线程安全的。

// 定义一个队列来存储待执行的动作
public static ConcurrentQueue<List<object>> actionQueue = new ConcurrentQueue<List<object>>();

2.加入队列的函数，可从不同线程调用

        /// <summary>
        /// 加入队列
        /// </summary>
        /// <param name="b1">cs</param>
        /// <param name="b2">buf</param>
        /// <param name="read_or_write"&g

了解本专栏

订阅专栏解锁全文

超级会员免费看

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

刚猛宝宝

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
打赏
打赏
打赏举报

举报

专栏目录

订阅专栏

C#分布式任务队列的“量子加速”秘籍：从卡顿到飞起的N个技巧！

java专栏

04-28

451

🔥关注墨瑾轩，带你探索编程的奥秘！🚀🔥超萌技术攻略，轻松晋级编程高手🚀🔥技术宝库已备好，就等你来挖掘🚀🔥订阅墨瑾轩，智趣学习不孤单🚀🔥即刻启航，编程之旅更有趣🚀taskIdtaskId。

C#集合：一文掌握12种集合优缺点及使用场景，高效编程必修课！

分享价值，持续输出高质量内容！

01-06

1540

C#是一种强大的编程语言，广泛用于各种应用和服务开发。在数据结构中，集合（Collection）是一个非常重要的概念，它们用于存储和操作一组数据对象。本文将详细介绍C#中的各种集合类型及其使用场景，帮助开发者更好地掌握这一重要技能。

参与评论您还未登录，请先登录后发表或查看评论

C#中使用ConcurrentQueue进行线程安全的操作

Liu_G的博客

09-26

3806

C#中ConcurrentQueue进行线程安全的操作普通的队列什么时候、为什么能不够保证线程安全的操作呢？想要知道ConcurrentQueue为什么能够保证在多线程环境下的安全性，首先应该要知道，为什么普通的队列不能够保证、什么情况下会保证不了线程安全性的操作。在前面有了解过.net framework中队列的源码，它是使用一个数组进行数据的存储的，使用_head和_tail来指示队列的头部和尾部在数组中的索引，那么，就举一个入队的简单的例子，如果有多个线程同时进行入队列操作，当他们同时运行

C# ConcurrentQueue实现

weixin_33984032的博客

11-22

700

我们从C# Queue 和Stack的实现知道Queue是用数组来实现的，数组的元素不断的通过Array.Copy从一个数组移动到另一个数组，ConcurrentQueue我们需要关心2点：1线程安全是怎么实现的，2队列又是怎么实现的?我们来看看其实现code： public interface IProducerConsumerCollection<T> : IEnumerabl...

深入探究 C# 中的 ConcurrentQueue 类

最新发布

2401_85253577的博客

03-07

1615

ConcurrentQueue<T> 类在 C# 的多线程编程中扮演着重要的角色，它为开发者提供了一个安全高效的队列数据结构，用于在多线程环境下处理数据。通过本文的介绍，我们了解了 ConcurrentQueue<T> 的基本概念、如何使用实例代码进行操作、在实际项目中的具体应用场景，以及与之相关的其他知识拓展。希望这些内容能帮助你更好地理解和运用 ConcurrentQueue<T>，在开发多线程应用程序时更加得心应手。

.Net中的并行编程-3.ConcurrentQueue实现与分析

weixin_30627341的博客

09-25

1473

在上文《.Net中的并行编程-2.ConcurrentQueue的实现与分析》中解释了无锁的相关概念，无独有偶BCL提供的ConcurrentQueue也是基于原子操作实现, 由于ConcurrentQueue的代码较多所以本文主要分析几个常用操作：入队(EnQueue) 、出队(TryDequeue) 、是否为空(IsEmpty)、获取队列内元素数量(Count)。一、Con...

c# ConcurrentQueue

lxy的学习笔记

08-01

9987

1、ConcurrentQueue是c# 中线程安全的队列。 2、ConcurrentQueue具有以下属性： count（元素个数） isEmpty（队列是否为空） 3、ConcurrentQueue具有以下方法： Enqueue 将元素添加到队列末尾 TryDequeue 尝试移除处于队列开头的对象 TryPeek 尝试返回队列开头的对象，但不移除 ToArray 将队列中存储的元素复制到新数

C# ConcurrentQueue （线程安全）

weixin_43632687的博客

05-19

1729

http://dotnetpattern.com/csharp-concurrentqueue Add Items in ConcurrentQueue It provides an Enqueue method to add any item at the end of the queue. Enqueue takes the argument which data type matches with the type argument. Below is the example. ConcurrentQ

【原创】C#多线程_跨线程窗体同步_进度条_生产消费（源代码）

04-17

在C#中，可以使用`BlockingCollection<T>`或者`ConcurrentQueue<T>`等线程安全的数据结构来实现这个模型。生产者将数据放入队列，消费者从队列中取出数据进行处理，两者之间通过队列进行同步，避免了直接的线程交互...

C#锁与并发集合对比分析：何时选择ConcurrentQueue?

本章将为你揭开C#并发编程的基础知识，包括线程的创建、任务的管理以及同步原语的使用。 ## 1.1 线程的基本概念线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际

浅谈C#之ConcurrentQueue

a876106354的博客

09-06

2505

是一个线程安全的队列，它允许多个线程同时对队列进行操作而不会相互干扰。它是命名空间下的一个类，提供了基本的队列操作，如Enqueue（入队）、TryDequeue（尝试出队）、TryPeek（尝试查看队首元素）等，并且是线程安全的。

C#任务队列的实现

10-30

用C#实现任务队列，一个队列存放任务，线程互斥的从任务队列中取，放任务，任务队列为空，线程等待，直到有任务加入队列为止。

C#线程在某一时间内,只有N个线程在并发执行,其余都在队列中的实现

10-12

C#线程在某一时间内,只有N个线程在并发执行,其余都在队列中的实现

C#队列Queue多线程用法实例

09-03

主要介绍了C#队列Queue多线程用法,实例分析了队列的相关使用技巧,需要的朋友可以参考下

C#多线程开发-并发集合中的ConcurrentQueue

dotNET跨平台

01-22

1169

前言大家好，我是阿辉。上一篇博文简单介绍了C#中支持并发的数据字典，简单举例说明比较了常规集合与ConcurrentDictionary的读写速度。下来简单介绍其中一个线程安全队列Conc...

C# 并发队列ConcurrentQueue

cnmeimei的博客

03-19

781

测试函数 static async Task RunProgram(){ var taskQueue = new ConcurrentQueue<CustomTask>(); var cts = new CancellationTokenSource(); //生成任务添加至并发队列 var taskSource = Task.Run(() => TaskProducer(taskQueue)); //同时启动四个任务处理队列中的任务 Task[] p.

c# ConcurrentQueue 性能测试

HETONGDE的博客

06-16

668

1000万条，入队出队大概1秒

一个项目中有多个模块，有跨线程，实现这些模块间的通信方法有哪些，尽量与操作系统无关

02-23

<think>嗯，用户现在问的是在一个项目中有多个模块，跨线程的情况下，实现这些模块间的通信方法有哪些，而且希望尽量与操作系统无关。我需要先理解用户的需求。他们可能在开发一个多线程应用程序，模块之间需要通信，但不想依赖特定的操作系统特性，这样代码可以在不同平台上运行。首先，我要回忆一下常见的跨线程通信方法。可能包括共享内存、消息队列、管道、信号量、回调函数、发布-订阅模式等等。但需要确保这些方法与操作系统无关，也就是说，应该使用标准的库或者语言特性，而不是像Windows的管道或者Linux的信号量这样的特定API。然后，我需要考虑用户可能的背景。他们可能是一个开发人员，正在设计一个多线程系统，需要模块间高效通信，同时保持可移植性。可能他们之前遇到过平台相关的问题，或者希望代码能在不同系统上运行，比如Windows、Linux、macOS等。因此，解决方案应该基于通用的编程语言特性或跨平台库。接下来，我需要列举各种通信方法，并检查它们是否符合与操作系统无关的条件。例如，共享内存虽然常见，但在不同操作系统上的实现可能不同，但如果是通过语言层面的结构（比如线程安全的队列）来实现，可能更合适。比如使用Python的queue模块，或者Java的BlockingQueue，这些是语言标准库提供的，不依赖特定OS。然后，消息传递机制，如使用消息队列，可以通过语言内置的队列结构实现，这样也是跨平台的。发布-订阅模式可以用事件驱动的方式，通过回调或者事件总线来实现，这通常依赖于语言本身的线程和同步机制，而不是操作系统特定的功能。另外，考虑同步机制，比如互斥锁、条件变量，这些在大多数语言的线程库中都有实现，比如Python的threading模块，Java的java.util.concurrent包，C++的std::mutex等，这些都是跨平台的。但是用户提到要尽量与操作系统无关，可能需要避免使用像共享内存这样的机制，因为共享内存在不同系统上的管理方式可能不同，除非通过标准库抽象。例如，Python的multiprocessing模块提供了跨平台的共享内存，但如果是纯线程的话，可能不需要共享内存，因为线程共享进程内存空间。可能用户还关心的是如何设计模块间的通信，而不仅仅是数据传递方式。比如事件驱动、回调、通道（Go语言中的channel概念），或者Actor模型（如Erlang或Akka框架，但Akka是JVM的，可能涉及库依赖）。需要考虑的还有数据序列化的问题，如果通信涉及复杂数据结构，可能需要使用跨平台的数据格式，如JSON、Protocol Buffers等，但这可能更多涉及进程间通信而非线程间通信。不过线程间通信通常直接传递对象或内存结构，不需要序列化，除非模块分布在不同线程但需要解耦。用户可能需要的是设计模式层面的建议，比如观察者模式、中介者模式，或者是使用线程安全的数据结构进行通信。例如，一个模块将消息放入队列，另一个模块从队列中取出处理，这种生产者-消费者模型，使用线程安全队列，是跨平台的。另外，需要考虑错误处理和线程安全。例如，确保在多个线程访问共享资源时不会出现竞态条件，使用锁或者其他同步机制，但这些同步机制是否跨平台？如果使用语言内置的锁，如Python的threading.Lock，那么它们是跨平台的，因为语言运行时处理了底层操作系统的差异。可能还需要提到管道或套接字，但这些通常用于进程间通信，而线程间通信可能更高效的方式是使用内存中的结构。不过用户问题明确是在多线程环境下，所以进程间通信的方法可能不适用，除非用户有特殊需求。总结可能的通信方法： 1. **共享数据结构**：如线程安全的队列、列表等，使用锁或原子操作来保证线程安全。例如Python的queue.Queue，Java的ConcurrentLinkedQueue。 2. **事件/信号机制**：通过条件变量（Condition variables）实现，一个线程等待某个条件，另一个线程通知条件达成。例如Python的threading.Condition。 3. **回调函数**：一个模块注册回调，另一个模块在特定事件发生时调用回调。需要注意线程安全和同步。 4. **消息传递**：使用消息队列或通道，模块通过发送和接收消息来通信。例如Go的channel，或者使用队列实现。 5. **发布-订阅模式**：模块可以订阅特定的事件或主题，当有消息发布时，所有订阅者都会收到通知。可以使用观察者模式实现。 6. **管道（Pipe）**：虽然通常用于进程间通信，但某些语言或库提供线程间的管道，如Python的multiprocessing.Pipe（但用于进程），线程间可能直接用队列更好。 7. **Future/Promise**：异步编程模型，一个线程返回Future，另一个线程等待结果。例如Java的Future，Python的concurrent.futures。 8. **Actor模型**：每个模块作为一个Actor，通过消息传递进行通信，如使用第三方库（如Python的thespian），但可能引入依赖。需要确保这些方法不依赖特定操作系统API，而是使用语言的标准库或跨平台库。例如，在C++中，可以使用std库中的线程和同步原语；在Python中使用threading和queue模块；在Java中使用java.util.concurrent包。另外，用户可能希望避免使用低级的同步原语，而采用更高层次的抽象，如消息队列，来减少复杂性。同时，需要考虑性能问题，不同的方法在性能上可能有差异，比如锁可能导致竞争，而无锁数据结构可能更高效但更难实现。最后，应该给出每种方法的优缺点，适用场景，以及如何实现，帮助用户根据项目需求选择合适的方式。</think>在跨线程的多模块项目中，实现通信的核心是**解耦模块依赖并确保线程安全**，同时尽量保持与操作系统无关。以下是常见的通信方法及实现思路： --- ### **一、通用通信方法（与操作系统无关）** #### **1. 消息队列（生产者-消费者模型）** - **原理**：模块通过共享的队列发送和接收消息，队列本身是线程安全的。 - **实现方式**： - **语言内置队列**：如 Python 的 `queue.Queue`、Java 的 `BlockingQueue`、C++ 的 `std::queue` + 锁。 - **无锁队列**：使用原子操作（如 C++ 的 `std::atomic`）实现高性能无锁队列。 - **优点**：解耦生产者和消费者，天然支持异步通信。 - **缺点**：需处理队列容量限制和消息积压问题。 ```python # Python 示例 import queue, threading msg_queue = queue.Queue() def producer(): msg_queue.put("Hello from Producer") def consumer(): msg = msg_queue.get() print(msg) threading.Thread(target=producer).start() threading.Thread(target=consumer).start() ``` --- #### **2. 事件驱动（发布-订阅模式）** - **原理**：模块通过订阅事件，当事件触发时执行回调。 - **实现方式**： - **自定义事件总线**：维护一个全局事件注册表，模块可注册/触发事件。 - **语言特性**：如 C# 的 `event`、JavaScript 的 `EventEmitter`，或手动实现观察者模式。 - **优点**：松耦合，支持一对多通信。 - **缺点**：回调函数需注意线程安全和死锁。 ```java // Java 示例（简化版） import java.util.concurrent.CopyOnWriteArrayList; class EventBus { private CopyOnWriteArrayList<Runnable> listeners = new CopyOnWriteArrayList<>(); public void subscribe(Runnable listener) { listeners.add(listener); } public void publish() { listeners.forEach(Runnable::run); } } // 模块A订阅事件 EventBus bus = new EventBus(); bus.subscribe(() -> System.out.println("Event received!")); // 模块B发布事件 bus.publish(); ``` --- #### **3. 共享内存 + 同步原语** - **原理**：模块通过共享数据结构（如字典、列表）交换数据，使用锁或信号量同步。 - **实现方式**： - **锁机制**：如 Python 的 `threading.Lock`、C++ 的 `std::mutex`。 - **条件变量**：如 `threading.Condition`，用于等待特定条件达成。 - **优点**：直接访问数据，延迟低。 - **缺点**：易引发竞态条件，需谨慎设计锁范围。 ```cpp // C++ 示例 #include <mutex> #include <queue> std::queue<std::string> shared_queue; std::mutex mtx; void producer() { std::lock_guard<std::mutex> lock(mtx); shared_queue.push("Data"); } void consumer() { std::lock_guard<std::mutex> lock(mtx); if (!shared_queue.empty()) { auto data = shared_queue.front(); shared_queue.pop(); } } ``` --- #### **4. Future/Promise 异步模型** - **原理**：模块通过 `Future` 对象返回异步结果，其他模块可等待结果。 - **实现方式**： - **语言支持**：如 Java 的 `CompletableFuture`、Python 的 `asyncio.Future`。 - **手动实现**：通过条件变量和状态标志模拟。 - **优点**：代码逻辑清晰，适合异步任务链。 - **缺点**：需要处理异常和超时。 ```python # Python asyncio 示例 import asyncio async def producer(): await asyncio.sleep(1) return "Result" async def consumer(): result = await producer() print(result) asyncio.run(consumer()) ``` --- #### **5. Actor 模型** - **原理**：每个模块作为独立 Actor，通过消息传递通信（类似分布式系统）。 - **实现方式**： - **第三方库**：如 Erlang/Elixir 原生支持，Python 的 `pykka`、Java 的 Akka。 - **手动实现**：结合消息队列和状态机。 - **优点**：天然避免共享状态，高容错性。 - **缺点**：需引入额外依赖，学习成本较高。 --- ### **二、方法对比与选型建议** | **方法** | **适用场景** | **性能** | **复杂度** | **跨平台性** | |------------------|---------------------------|----------|------------|--------------| | 消息队列 | 模块间异步通信 | 中 | 低 | 高 | | 事件驱动 | 一对多通知 | 高 | 中 | 高 | | 共享内存 + 锁 | 低延迟数据交换 | 高 | 高 | 高（需同步） | | Future/Promise | 异步任务链 | 中 | 中 | 高 | | Actor 模型 | 复杂系统，需高容错 | 中 | 高 | 依赖库 | --- ### **三、设计注意事项** 1. **线程安全**：优先使用线程安全的数据结构（如无锁队列）或严格加锁。 2. **死锁预防**：避免嵌套锁，统一锁的获取顺序。 3. **资源管理**：合理控制消息队列容量，防止内存溢出。 4. **超时机制**：在 `get()`/`put()` 操作中设置超时，避免线程永久阻塞。 --- ### **四、扩展：跨语言通信（如混合编程）** 若模块用不同语言编写（如 C++ + Python），可通过以下方式实现通信： 1. **共享内存 + 协议**：约定数据格式（如 Protocol Buffers）。 2. **HTTP/gRPC**：模块作为微服务暴露 API（适合分布式系统）。 3. **中间件**：通过 Redis/RabbitMQ 等消息中间件解耦。 --- 根据项目需求选择合适的方法，**简单场景推荐消息队列，复杂系统可考虑 Actor 模型**。