👁 Image
TJC.Cyclops.Threading 2026.6.11.2

🌟 Cyclops.Threading

📝 项目概述

Cyclops.Threading 是 Cyclops.Framework 框架中的线程同步与并发控制专家，为您的.NET应用程序提供全方位的并发编程解决方案！ 🚀

我们精心设计的组件简化了复杂的并发编程模型，让您能够轻松构建高性能、线程安全的应用程序。无论是处理高并发场景，还是优化资源利用，Cyclops.Threading都能为您提供强大的支持。

✨ 为什么选择 Cyclops.Threading？

• 简化并发编程：将复杂的线程同步原语封装为易用的API
• 提升性能：通过优化的对象池和线程管理，减少资源消耗
• 增强可靠性：提供完善的同步机制，避免竞态条件和死锁
• 异步友好：全面支持现代异步编程模型
• 易于集成：与.NET依赖注入系统无缝集成

🎯 核心功能模块

🔧 线程池管理

• 自定义线程池：灵活配置线程池大小和行为
• 智能监控：实时监控工作线程状态和性能
• 优先级控制：精细控制任务执行优先级
• 队列管理：优化任务调度和执行流程

🔒 同步原语

• 读写锁：高效处理多读少写场景
• 信号量：控制并发访问数量
• 互斥体：确保资源独占访问
• 屏障：协调多个线程的执行步骤
• 自旋锁：适用于短时间临界区的轻量级同步

📚 并发集合

• 线程安全字典：高效的并发键值存储
• 线程安全队列：安全的FIFO数据结构
• 线程安全栈：安全的LIFO数据结构
• 扩展方法：丰富的并发集合操作API

⚡ 异步编程工具

• 异步锁：无阻塞的异步同步机制
• 异步信号量：异步场景下的并发控制
• 异步事件：线程间安全的异步通信
• 异步协调器：协调多个异步操作的执行

🏊 对象池

• 通用对象池：适用于各种类型的对象复用
• 资源管理：智能管理池化资源的生命周期
• 策略配置：灵活配置池化行为和参数
• 内存优化：减少GC压力，提升应用性能

🚀 高级功能

• 超时控制：智能处理操作超时场景
• 取消令牌：优雅处理操作取消
• 异常传播：安全处理并发环境中的异常
• 并发模式：内置常用并发设计模式实现

🛠️ 技术栈

• .NET 8.0：利用最新的.NET特性和性能优化
• System.Threading.Tasks.Extensions：增强的异步编程支持
• System.Collections.Concurrent：基础并发集合
• Cyclops.Common：框架核心公共组件

📦 环境依赖

• .NET 8.0 SDK 或更高版本
• 支持的平台：Windows、Linux、macOS
• IDE推荐：Visual Studio 2022、Visual Studio Code

🚀 安装配置

🔍 安装方式

NuGet包管理器

Install-Package Cyclops.Threading

.NET CLI

dotnet add package Cyclops.Threading

PackageReference

<PackageReference Include="Cyclops.Threading" Version="1.0.0" />

⚙️ 基本配置

在应用程序启动时进行配置，享受开箱即用的并发能力！

// 在Program.cs或Startup.cs中
using Cyclops.Threading;

var builder = WebApplication.CreateBuilder(args);

// 添加Cyclops.Threading服务
builder.Services.AddCyclopsThreading(options => {
 // 线程池配置 - 根据应用需求调整
 options.ThreadPoolOptions = new ThreadPoolOptions {
 MinThreads = 4, // 最小工作线程数
 MaxThreads = 20, // 最大工作线程数
 IdleTimeout = TimeSpan.FromMinutes(5) // 空闲线程超时时间
 };
 
 // 对象池配置 - 优化内存使用
 options.ObjectPoolOptions = new ObjectPoolOptions {
 DefaultPoolSize = 100, // 默认池大小
 MaxPoolSize = 500, // 最大池大小
 EnableMetrics = true // 启用性能指标
 };
 
 // 并发控制配置 - 提升可靠性
 options.ConcurrencyOptions = new ConcurrencyOptions {
 DefaultTimeout = TimeSpan.FromSeconds(30), // 默认操作超时时间
 EnableDeadlockDetection = true, // 启用死锁检测
 DeadlockTimeout = TimeSpan.FromSeconds(10) // 死锁检测超时时间
 };
});

// ...

🎯 配置建议

• 线程池大小：根据CPU核心数和应用负载调整，一般建议设置为CPU核心数的1-2倍
• 对象池大小：根据对象创建成本和使用频率调整
• 超时设置：根据操作复杂度和系统响应时间要求调整
• 死锁检测：在开发和测试环境建议启用，生产环境根据性能需求决定

📝 代码示例

🔒 线程同步示例

以下示例展示了如何使用 Cyclops.Threading 提供的同步原语，确保多线程环境下的数据安全：

using Cyclops.Threading.Sync;
using Microsoft.Extensions.DependencyInjection;

// 使用读写锁
public class ReadWriteLockExample
{
 private readonly IReadWriteLock _readWriteLock;
 private readonly Dictionary<string, string> _sharedData = new();
 
 public ReadWriteLockExample(IReadWriteLock readWriteLock)
 {
 _readWriteLock = readWriteLock;
 }
 
 public void UpdateData(string key, string value)
 {
 // 获取写锁
 using (_readWriteLock.AcquireWriteLock())
 {
 _sharedData[key] = value;
 Console.WriteLine($"已更新数据: {key} = {value}");
 }
 }
 
 public string GetData(string key)
 {
 // 获取读锁
 using (_readWriteLock.AcquireReadLock())
 {
 if (_sharedData.TryGetValue(key, out var value))
 {
 Console.WriteLine($"读取数据: {key} = {value}");
 return value;
 }
 return null;
 }
 }
 
 // 带超时的锁获取
 public bool TryUpdateData(string key, string value, TimeSpan timeout)
 {
 try
 {
 // 尝试在指定时间内获取写锁
 using (_readWriteLock.TryAcquireWriteLock(timeout))
 {
 _sharedData[key] = value;
 Console.WriteLine($"已更新数据: {key} = {value}");
 return true;
 }
 }
 catch (TimeoutException)
 {
 Console.WriteLine($"获取锁超时: {key}");
 return false;
 }
 }
}

// 使用信号量
public class SemaphoreExample
{
 private readonly ISemaphore _semaphore;
 
 public SemaphoreExample(ISemaphoreFactory semaphoreFactory)
 {
 // 创建最多允许3个并发访问的信号量
 _semaphore = semaphoreFactory.Create("LimitedResourceSemaphore", 3, 3);
 }
 
 public async Task AccessLimitedResourceAsync(string resourceId)
 {
 Console.WriteLine($"等待访问资源: {resourceId}");
 
 // 获取信号量
 await _semaphore.WaitAsync();
 
 try
 {
 Console.WriteLine($"开始访问资源: {resourceId}");
 // 模拟资源访问
 await Task.Delay(2000);
 Console.WriteLine($"完成访问资源: {resourceId}");
 }
 finally
 {
 // 释放信号量
 _semaphore.Release();
 }
 }
 
 // 模拟并发访问
 public async Task SimulateConcurrentAccessAsync()
 {
 var tasks = new List<Task>();
 
 for (int i = 1; i <= 10; i++)
 {
 var resourceId = $"Resource-{i}";
 tasks.Add(AccessLimitedResourceAsync(resourceId));
 }
 
 await Task.WhenAll(tasks);
 }
}

📚 并发集合示例

以下示例展示了如何使用 Cyclops.Threading 提供的线程安全集合，处理高并发场景下的数据操作：

using Cyclops.Threading.Collections;
using Microsoft.Extensions.DependencyInjection;

// 使用线程安全集合
public class ConcurrentCollectionExample
{
 // 线程安全字典示例
 private readonly IConcurrentDictionary<string, Product> _products;
 
 // 线程安全队列示例
 private readonly IConcurrentQueue<Order> _orders;
 
 public ConcurrentCollectionExample(
 IConcurrentDictionaryFactory dictionaryFactory,
 IConcurrentQueueFactory queueFactory)
 {
 _products = dictionaryFactory.Create<string, Product>("ProductsDictionary");
 _orders = queueFactory.Create<Order>("OrdersQueue");
 }
 
 // 使用线程安全字典
 public void ManageProducts()
 {
 // 添加产品
 _products.AddOrUpdate("P001", new Product { Id = "P001", Name = "产品A", Price = 99.99 },
 (key, existingValue) => {
 existingValue.Price = 99.99;
 return existingValue;
 });
 
 // 获取产品
 if (_products.TryGetValue("P001", out var product))
 {
 Console.WriteLine($"找到产品: {product.Name}, 价格: {product.Price}");
 }
 
 // 条件更新产品
 _products.AddOrUpdate("P001", 
 key => throw new InvalidOperationException("产品不存在"),
 (key, existingValue) => {
 if (existingValue.Price < 100)
 {
 existingValue.Price = 109.99;
 return existingValue;
 }
 return existingValue;
 });
 
 // 删除产品
 _products.TryRemove("P001", out _);
 Console.WriteLine($"产品是否存在: {_products.ContainsKey("P001")}");
 }
 
 // 使用线程安全队列
 public async Task ProcessOrdersAsync()
 {
 // 入队订单
 for (int i = 1; i <= 5; i++)
 {
 _orders.Enqueue(new Order { OrderId = $"O{1000 + i}", CustomerId = $"C{100 + i}", Amount = i * 100 });
 }
 
 Console.WriteLine($"队列中的订单数量: {_orders.Count}");
 
 // 并行处理订单
 var processingTasks = new List<Task>();
 
 for (int i = 0; i < 3; i++)
 {
 processingTasks.Add(Task.Run(async () => {
 while (_orders.TryDequeue(out var order))
 {
 Console.WriteLine($"处理订单: {order.OrderId}, 客户: {order.CustomerId}, 金额: {order.Amount}");
 // 模拟订单处理
 await Task.Delay(500);
 }
 }));
 }
 
 await Task.WhenAll(processingTasks);
 Console.WriteLine($"处理后队列中的订单数量: {_orders.Count}");
 }
}

public class Product
{
 public string Id { get; set; }
 public string Name { get; set; }
 public double Price { get; set; }
}

public class Order
{
 public string OrderId { get; set; }
 public string CustomerId { get; set; }
 public double Amount { get; set; }
}

⚡ 异步同步原语示例

以下示例展示了如何使用 Cyclops.Threading 提供的异步同步原语，构建高效的异步应用程序：

using Cyclops.Threading.Async;
using Microsoft.Extensions.DependencyInjection;
using System.Threading.Tasks;

// 使用异步同步原语
public class AsyncSynchronizationExample
{
 private readonly IAsyncLock _asyncLock;
 private readonly IAsyncSemaphore _asyncSemaphore;
 private readonly IAsyncEvent _asyncEvent;
 
 private int _counter = 0;
 private bool _dataReady = false;
 
 public AsyncSynchronizationExample(
 IAsyncLockFactory asyncLockFactory,
 IAsyncSemaphoreFactory asyncSemaphoreFactory,
 IAsyncEventFactory asyncEventFactory)
 {
 _asyncLock = asyncLockFactory.Create("CounterLock");
 _asyncSemaphore = asyncSemaphoreFactory.Create("LimitedOperationSemaphore", 5);
 _asyncEvent = asyncEventFactory.CreateAutoResetEvent("DataReadyEvent");
 }
 
 // 使用异步锁保护共享资源
 public async Task<int> IncrementCounterAsync()
 {
 using (await _asyncLock.LockAsync())
 {
 Console.WriteLine($"线程 {Environment.CurrentManagedThreadId} 获取了异步锁");
 // 模拟工作
 await Task.Delay(100);
 _counter++;
 return _counter;
 }
 // 锁在这里自动释放
 }
 
 // 使用带超时的异步锁
 public async Task<int?> TryIncrementCounterWithTimeoutAsync(TimeSpan timeout)
 {
 try
 {
 using (await _asyncLock.LockAsync(timeout))
 {
 _counter++;
 return _counter;
 }
 }
 catch (TimeoutException)
 {
 Console.WriteLine("获取异步锁超时");
 return null;
 }
 }
 
 // 使用异步信号量控制并发
 public async Task PerformLimitedOperationAsync(string operationId)
 {
 await _asyncSemaphore.WaitAsync();
 
 try
 {
 Console.WriteLine($"执行受限操作: {operationId}, 可用资源: {_asyncSemaphore.CurrentCount}");
 // 模拟资源密集型操作
 await Task.Delay(2000);
 }
 finally
 {
 _asyncSemaphore.Release();
 }
 }
 
 // 使用异步事件进行线程间通信
 public async Task ProducerConsumerExampleAsync()
 {
 // 消费者任务
 var consumerTask = Task.Run(async () => {
 Console.WriteLine("消费者等待数据准备就绪...");
 await _asyncEvent.WaitAsync();
 Console.WriteLine("消费者检测到数据已准备就绪，开始处理");
 _dataReady = false;
 // 处理数据...
 });
 
 // 生产者准备数据
 await Task.Delay(3000);
 Console.WriteLine("生产者准备数据完成");
 _dataReady = true;
 
 // 通知消费者
 _asyncEvent.Set();
 
 await consumerTask;
 }
 
 // 模拟并发场景
 public async Task SimulateConcurrencyAsync()
 {
 // 1. 测试异步锁
 var counterTasks = new List<Task>();
 for (int i = 0; i < 10; i++)
 {
 counterTasks.Add(IncrementCounterAsync());
 }
 await Task.WhenAll(counterTasks);
 Console.WriteLine($"最终计数器值: {_counter}");
 
 // 2. 测试异步信号量
 var operationTasks = new List<Task>();
 for (int i = 0; i < 15; i++)
 {
 operationTasks.Add(PerformLimitedOperationAsync($"Op-{i}"));
 }
 await Task.WhenAll(operationTasks);
 
 // 3. 测试异步事件
 await ProducerConsumerExampleAsync();
 }
}

🏊 对象池示例

以下示例展示了如何使用 Cyclops.Threading 提供的对象池，优化内存使用和提升应用性能：

using Cyclops.Threading.Pooling;
using Microsoft.Extensions.DependencyInjection;
using System.Text;

// 使用对象池
public class ObjectPoolExample
{
 private readonly IObjectPool<StringBuilder> _stringBuilderPool;
 private readonly IObjectPool<DbConnection> _dbConnectionPool;
 
 public ObjectPoolExample(
 IObjectPoolFactory objectPoolFactory)
 {
 // 创建StringBuilder对象池
 _stringBuilderPool = objectPoolFactory.CreatePool<StringBuilder>(new StringBuilderPooledObjectPolicy {
 InitialCapacity = 1024,
 MaximumRetainedCapacity = 4096
 });
 
 // 创建数据库连接池
 _dbConnectionPool = objectPoolFactory.CreatePool<DbConnection>(new DbConnectionPooledObjectPolicy {
 ConnectionString = "Server=localhost;Database=TestDb;User Id=sa;Password=yourpassword;"
 });
 }
 
 // 使用StringBuilder对象池
 public string BuildLargeString(IEnumerable<string> items)
 {
 // 从池中获取StringBuilder
 var sb = _stringBuilderPool.Get();
 
 try
 {
 sb.Clear(); // 确保对象状态干净
 
 foreach (var item in items)
 {
 sb.AppendLine(item);
 }
 
 return sb.ToString();
 }
 finally
 {
 // 归还到池中
 _stringBuilderPool.Return(sb);
 }
 }
 
 // 使用数据库连接池
 public async Task<int> ExecuteDatabaseQueryAsync(string sql, params object[] parameters)
 {
 // 从池中获取连接
 var connection = _dbConnectionPool.Get();
 
 try
 {
 // 确保连接已打开
 if (connection.State != ConnectionState.Open)
 {
 await connection.OpenAsync();
 }
 
 // 执行查询
 using (var command = connection.CreateCommand())
 {
 command.CommandText = sql;
 
 // 添加参数
 for (int i = 0; i < parameters.Length; i++)
 {
 var parameter = command.CreateParameter();
 parameter.ParameterName = $"@p{i}";
 parameter.Value = parameters[i] ?? DBNull.Value;
 command.Parameters.Add(parameter);
 }
 
 return await command.ExecuteNonQueryAsync();
 }
 }
 catch (Exception ex)
 {
 // 连接出错，不归还到池中
 Console.WriteLine($"数据库操作异常: {ex.Message}");
 connection.Dispose();
 throw;
 }
 finally
 {
 // 归还连接到池中
 if (connection.State == ConnectionState.Open)
 {
 try
 {
 connection.Close();
 }
 catch { }
 }
 
 _dbConnectionPool.Return(connection);
 }
 }
 
 // 对象池使用示例
 public async Task DemonstrateObjectPoolsAsync()
 {
 // 测试StringBuilder对象池
 var largeData = Enumerable.Range(1, 1000).Select(i => $"Item {i}: This is a test string that would be appended to the StringBuilder");
 
 var sw = Stopwatch.StartNew();
 for (int i = 0; i < 100; i++)
 {
 var result = BuildLargeString(largeData);
 // 仅使用前100个字符进行验证
 Console.WriteLine($"构建的字符串长度: {result.Length}");
 }
 sw.Stop();
 Console.WriteLine($"使用对象池构建字符串耗时: {sw.ElapsedMilliseconds}ms");
 
 // 测试数据库连接池
 var query = "INSERT INTO TestTable (Name, Value) VALUES (@p0, @p1)";
 var batchSize = 100;
 
 sw.Restart();
 for (int i = 0; i < batchSize; i++)
 {
 await ExecuteDatabaseQueryAsync(query, $"Test-{i}", i * 10);
 }
 sw.Stop();
 Console.WriteLine($"使用连接池执行{batchSize}条SQL语句耗时: {sw.ElapsedMilliseconds}ms");
 }
}

// 自定义池化对象策略
public class StringBuilderPooledObjectPolicy : IPooledObjectPolicy<StringBuilder>
{
 public int InitialCapacity { get; set; } = 100;
 public int MaximumRetainedCapacity { get; set; } = 1024;
 
 public StringBuilder Create()
 {
 return new StringBuilder(InitialCapacity);
 }
 
 public bool Return(StringBuilder obj)
 {
 // 重置对象状态
 obj.Clear();
 
 // 超过最大容量的对象不再归还池中
 return obj.Capacity <= MaximumRetainedCapacity;
 }
}

public class DbConnectionPooledObjectPolicy : IPooledObjectPolicy<DbConnection>
{
 public string ConnectionString { get; set; }
 
 public DbConnection Create()
 {
 // 根据实际使用的数据库返回对应的连接对象
 // 这里以SQL Server为例
 return new SqlConnection(ConnectionString);
 }
 
 public bool Return(DbConnection obj)
 {
 // 检查连接是否有效
 if (obj.State != ConnectionState.Closed)
 {
 try
 {
 obj.Close();
 }
 catch
 {
 // 连接已损坏，不归还
 return false;
 }
 }
 
 // 连接有效，可以归还池中
 return true;
 }
}

// 用于示例的DbConnection抽象
public abstract class DbConnection : IDisposable
{
 public abstract ConnectionState State { get; }
 public abstract void Close();
 public abstract Task OpenAsync();
 public abstract DbCommand CreateCommand();
 public abstract void Dispose();
}

public enum ConnectionState
{
 Closed,
 Open
}

public abstract class DbCommand
{
 public abstract string CommandText { get; set; }
 public abstract IDataParameterCollection Parameters { get; }
 public abstract Task<int> ExecuteNonQueryAsync();
 public abstract DbParameter CreateParameter();
}

public abstract class DbParameter : IDataParameter
{
 public abstract string ParameterName { get; set; }
 public abstract object Value { get; set; }
 // 其他接口成员...
}

public interface IDataParameterCollection : IList, ICollection, IEnumerable
{}

public interface IDataParameter
{
 string ParameterName { get; set; }
 object Value { get; set; }
 // 其他接口成员...
}

public class SqlConnection : DbConnection
{
 private ConnectionState _state = ConnectionState.Closed;
 private readonly string _connectionString;
 
 public SqlConnection(string connectionString)
 {
 _connectionString = connectionString;
 }
 
 public override ConnectionState State => _state;
 
 public override void Close()
 {
 _state = ConnectionState.Closed;
 Console.WriteLine("SQL连接已关闭");
 }
 
 public override async Task OpenAsync()
 {
 // 模拟连接打开
 await Task.Delay(100);
 _state = ConnectionState.Open;
 Console.WriteLine("SQL连接已打开");
 }
 
 public override DbCommand CreateCommand()
 {
 return new SqlCommand();
 }
 
 public override void Dispose()
 {
 if (_state == ConnectionState.Open)
 {
 Close();
 }
 Console.WriteLine("SQL连接已释放");
 }
}

public class SqlCommand : DbCommand
{
 public override string CommandText { get; set; }
 public override IDataParameterCollection Parameters { get; } = new SqlParameterCollection();
 
 public override async Task<int> ExecuteNonQueryAsync()
 { 
 // 模拟执行SQL
 await Task.Delay(50);
 Console.WriteLine($"执行SQL: {CommandText}");
 return 1;
 }
 
 public override DbParameter CreateParameter()
 {
 return new SqlParameter();
 }
}

public class SqlParameter : DbParameter
{
 public override string ParameterName { get; set; }
 public override object Value { get; set; }
}

public class SqlParameterCollection : IDataParameterCollection
{
 // 简化实现，实际应完整实现接口
 // ...
}

🚀 高级并发模式示例

以下示例展示了如何使用 Cyclops.Threading 提供的高级并发模式，构建复杂的并发应用程序：

using Cyclops.Threading.Modes;
using Microsoft.Extensions.DependencyInjection;

// 高级并发模式实现
public class ConcurrentPatternExample
{
 private readonly IReaderWriterLockSlim _rwLock;
 private readonly IAsyncCoordinator _asyncCoordinator;
 private readonly ITimeoutPolicy _timeoutPolicy;
 
 private Dictionary<string, string> _sharedData = new();
 
 public ConcurrentPatternExample(
 IReaderWriterLockFactory readerWriterLockFactory,
 IAsyncCoordinatorFactory asyncCoordinatorFactory,
 ITimeoutPolicyFactory timeoutPolicyFactory)
 {
 // 创建读写锁
 _rwLock = readerWriterLockFactory.Create();
 
 // 创建异步协调器
 _asyncCoordinator = asyncCoordinatorFactory.Create("DataProcessingCoordinator");
 
 // 创建超时策略
 _timeoutPolicy = timeoutPolicyFactory.Create(TimeSpan.FromSeconds(30), 
 TimeSpan.FromSeconds(5)); // 操作超时30秒，心跳间隔5秒
 }
 
 // 读写锁模式
 public void ReaderWriterPattern()
 {
 // 读取操作 - 获取读锁
 _rwLock.EnterReadLock();
 try
 {
 if (_sharedData.TryGetValue("config", out var configValue))
 {
 Console.WriteLine($"读取配置: {configValue}");
 }
 }
 finally
 {
 _rwLock.ExitReadLock();
 }
 
 // 写入操作 - 获取写锁
 _rwLock.EnterWriteLock();
 try
 {
 _sharedData["config"] = DateTime.Now.ToString();
 Console.WriteLine("更新配置完成");
 }
 finally
 {
 _rwLock.ExitWriteLock();
 }
 
 // 升级锁模式
 _rwLock.EnterUpgradeableReadLock();
 try
 {
 if (!_sharedData.ContainsKey("featureFlag"))
 {
 // 需要时升级为写锁
 _rwLock.EnterWriteLock();
 try
 {
 // 双重检查锁定模式
 if (!_sharedData.ContainsKey("featureFlag"))
 {
 _sharedData["featureFlag"] = "true";
 Console.WriteLine("添加功能标志");
 }
 }
 finally
 {
 _rwLock.ExitWriteLock();
 }
 }
 
 // 继续读取
 Console.WriteLine($"功能标志: {_sharedData["featureFlag"]}");
 }
 finally
 {
 _rwLock.ExitUpgradeableReadLock();
 }
 }
 
 // 异步协调模式
 public async Task AsyncCoordinationPatternAsync()
 {
 // 注册多个并行操作
 var operation1 = _asyncCoordinator.RegisterOperation(async (token) => {
 Console.WriteLine("开始操作1");
 await Task.Delay(3000, token);
 Console.WriteLine("完成操作1");
 return "结果1";
 });
 
 var operation2 = _asyncCoordinator.RegisterOperation(async (token) => {
 Console.WriteLine("开始操作2");
 await Task.Delay(2000, token);
 Console.WriteLine("完成操作2");
 return "结果2";
 });
 
 var operation3 = _asyncCoordinator.RegisterOperation(async (token) => {
 Console.WriteLine("开始操作3");
 await Task.Delay(4000, token);
 Console.WriteLine("完成操作3");
 return "结果3";
 });
 
 // 设置进度回调
 _asyncCoordinator.ProgressCallback = (progress) => {
 Console.WriteLine($"操作进度: {progress.CompletedOperations}/{progress.TotalOperations}, " +
 $"完成百分比: {progress.CompletionPercentage:P2}");
 };
 
 // 等待所有操作完成
 var results = await _asyncCoordinator.WaitForAllOperationsAsync();
 
 Console.WriteLine("所有操作完成");
 foreach (var result in results)
 {
 Console.WriteLine($"操作结果: {result}");
 }
 }
 
 // 超时策略模式
 public async Task TimeoutPatternAsync()
 {
 try
 {
 // 使用超时策略执行操作
 var result = await _timeoutPolicy.ExecuteWithTimeoutAsync(async () => {
 // 模拟可能超时的操作
 await Task.Delay(25000); // 25秒，小于30秒超时
 return "操作完成";
 });
 
 Console.WriteLine($"操作结果: {result}");
 }
 catch (TimeoutException)
 {
 Console.WriteLine("操作执行超时");
 }
 
 // 带心跳的长时间操作
 try
 {
 var longRunningResult = await _timeoutPolicy.ExecuteWithHeartbeatAsync(
 async (heartbeat) => {
 for (int i = 0; i < 10; i++)
 {
 // 定期发送心跳
 heartbeat();
 Console.WriteLine($"执行步骤 {i + 1}/10");
 await Task.Delay(2000);
 }
 return "长时间操作完成";
 });
 
 Console.WriteLine($"长时间操作结果: {longRunningResult}");
 }
 catch (TimeoutException)
 {
 Console.WriteLine("带心跳的操作执行超时");
 }
 }
 
 // 演示所有模式
 public async Task DemonstrateAllPatternsAsync()
 {
 // 演示读写锁模式
 ReaderWriterPattern();
 
 // 演示异步协调模式
 await AsyncCoordinationPatternAsync();
 
 // 演示超时策略模式
 await TimeoutPatternAsync();
 }
}

🤝 贡献者

我们欢迎社区贡献！如果您有任何改进建议或功能需求，欢迎提交PR或Issue。

• yswenli：核心开发者

📋 版本信息

• 当前版本：👁 NuGet version (Cyclops.Framework)
  
• 作者：yswenli
• 描述：企服版框架中线程同步与并发控制组件
• 更新频率：定期更新，持续改进

📄 许可证

保留所有权利

🎉 结语

Cyclops.Threading 致力于为您的.NET应用程序提供最强大、最易用的并发编程工具。我们相信，通过简化并发编程的复杂性，您可以更专注于业务逻辑的实现，构建出更可靠、更高效的应用程序。

如果您有任何问题或建议，欢迎与我们联系！让我们一起构建更好的并发解决方案！ 🚀