ThreadPool

最新推荐文章于 2025-04-07 18:22:11 发布
最新推荐文章于 2025-04-07 18:22:11 发布
阅读量627 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cxzhq2002/article/details/9420153
本文介绍了一个异步更新管理器的设计与实现，包括多线程处理、队列管理及错误重试机制。通过使用线程池和队列，有效地提高了系统的并发处理能力和故障恢复能力。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
using System.Threading;
using System.Configuration;

namespace Frame.BaseLib.UpdateAsynManager
{
    public static class UpdateAsynManager
    {
        /// <summary>
        /// 保存线程引用
        /// </summary>
        private static List<System.Threading.Thread> _Thread = null;

        /// <summary>
        /// 暂停标志
        /// </summary>
        private static bool _stop = false;

        /// <summary>
        /// update队列
        /// </summary>
        private static Queue _updateQueue = new Queue(5000,10);

        /// <summary>
        /// update重做队列
        /// </summary>
        private static Queue _reUpdateQueue = new Queue(5000,10);

        /// <summary>
        /// 构造函数,完成相关初始化
        /// </summary>
        static UpdateAsynManager()
        {
            //初始化线程
            LaunchUpdateManager();
        }

        //启动线程
        internal static void LaunchUpdateManager()
        {
            _stop = false;
            _Thread = new List<System.Threading.Thread>();

            //启动update处理线程 * 3
            for (int i = 0; i < 5; i++)
            {
                _Thread.Add(new Thread(new ThreadStart(LogThreadProcess)));
            }

            //update重做处理线程 * 1
            _Thread.Add(new Thread(new ThreadStart(ReLogThreadProcess)));

            //启动线程
            for (int i = 0; i < _Thread.Count; i++)
            {
                _Thread[i].Start();
            }
        }

        //暂停线程
        internal static void PauseLogManager()
        {
            _stop = true;
            //删除对线程List的引用
            _Thread = null;
        }

        /// <summary>
        /// 存入update队列
        /// </summary>
        /// <param name="logEntity">update实体</param>
        internal static void UpdateQueuEnQueue(UpdateAsynEntity updateAsynEntity)
        {
            lock (_updateQueue)
            {
                _updateQueue.Enqueue(updateAsynEntity);
            }
        }

        /// <summary>
        /// 从update队列中取出update实体
        /// </summary>
        /// <returns></returns>
        internal static UpdateAsynEntity UpdateQueuDeQueue()
        {
            lock (_updateQueue)
            {
                if (_updateQueue.Count > 0)
                {
                    return (UpdateAsynEntity)_updateQueue.Dequeue();
                }
                else
                {
                    return null;
                }
            }
        }


        /// <summary>
        /// 存入update重做队列
        /// </summary>
        /// <param name="logEntity">update实体</param>
        internal static void ReUpdateQueuEnQueue(UpdateAsynEntity updateAsynEntity)
        {
            lock (_reUpdateQueue)
            {
                _reUpdateQueue.Enqueue(updateAsynEntity);
            }
        }

        /// <summary>
        /// 将update实体由此函数传入,之后交由Manager类处理
        /// </summary>
        /// <param name="LogEntity">日志实体</param>
        public static void WriteToLocal(UpdateAsynEntity updateAsynEntity, IUpdateAsynProcess updateAsynProcess)
        {
            if (updateAsynProcess == null)
            {
                throw new Exception("请提供update操作实例！！");
            }
            updateAsynEntity._updateAsynProcess = updateAsynProcess;
            UpdateQueuEnQueue(updateAsynEntity);
        }

        public static void WriteToServer(UpdateAsynEntity updateAsynEntity, IUpdateAsynProcess updateAsynProcess)
        {

        }

        /// <summary>
        /// update线程
        /// </summary>
        private static void LogThreadProcess()
        {
            //暂停标志
            while (!_stop)
            {
                try
                {
                    //写入数据库
                    UpdateAsynEntity updateAsynEntity = UpdateQueuDeQueue();
                    if (updateAsynEntity != null)
                    {
                        try
                        {
                            updateAsynEntity._updateAsynProcess.Write(updateAsynEntity);
                        }
                        catch
                        {
                            //报错则进入重做队列
                            ReUpdateQueuEnQueue(updateAsynEntity);
                        }
                    }
                }
                catch
                {
                }
                Thread.Sleep(5);
            }
        }

        /// <summary>
        /// update重做线程
        /// </summary>
        private static void ReLogThreadProcess()
        {
            //暂停标志
            while (!_stop)
            {
                try
                {
                    //锁定update重做队列
                    lock (_reUpdateQueue)
                    {
                        if (_reUpdateQueue.Count < 1000)
                        {
                            //如果重发队列中小于1000条记录,取出update实体重做
                            if (_reUpdateQueue.Count > 0)
                            {
                                UpdateAsynEntity updateAsynEntity = (UpdateAsynEntity)_reUpdateQueue.Dequeue();

                                try
                                {
                                    updateAsynEntity._updateAsynProcess.Write(updateAsynEntity);
                                }
                                catch
                                {
                                    //报错则再次进入重做队列
                                    _reUpdateQueue.Enqueue(updateAsynEntity);
                                }
                            }
                        }
                        else
                        {
                            //如果重做队列中达到1000条记录,全部保存到Log4Net日志
                            int count = 0;
                            StringBuilder sb = new StringBuilder();
                            //string sendMessage;
                            while (_reUpdateQueue.Count > 0)
                            {
                                UpdateAsynEntity updateEntity = (UpdateAsynEntity)_reUpdateQueue.Dequeue();
                                if (count == 0) sb.AppendLine("");
                                sb.AppendLine("@@@" + updateEntity._updateAsynProcess.GetLog(updateEntity));
                                count++;
                                if (count == 100)
                                {
                                    //send email
                                    SendEmail(sb.ToString());
                                    //WriteLog4Net(sb.ToString());
                                    count = 0;
                                    //清空sb
                                    sb = new StringBuilder();
                                }
                            }
                            //不到100条的时候,如果有剩余也再做一次
                            if (count != 0)
                            {
                                SendEmail(sb.ToString());
                                //WriteLog4Net(sb.ToString());
                            }
                        }
                    }
                }
                catch
                {
                }
                Thread.Sleep(100);
            }
        }

        /// <summary>
        /// 发送邮件
        /// </summary>
        private static void SendEmail(string emailContent)
        {

        }

    }
}


 

using System;

namespace Frame.CommLib
{
    /// <summary>
    /// 异步update实体
    /// </summary>
    public class UpdateAsynEntity
    {
        private object _updateEntity;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="entity">update实体</param>
        public UpdateAsynEntity(Object updateEntity)
        {
            _updateEntity = updateEntity;
        }

        /// <summary>
        /// update实体
        /// </summary>
        public object UpdateEntity
        {
            get { return _updateEntity; }
        }

        /// <summary>
        /// update处理逻辑
        /// </summary>
        internal IUpdateAsynProcess _updateAsynProcess;

    }
}


 

using System;
using System.Collections.Generic;
using System.Text;

namespace Frame.BaseLib.Interface
{
    public interface IUpdateAsynProcess
    {
        /// <summary>
        /// udpate的操作函数
        /// </summary>
        /// <param name="updateEntity"></param>
        void Write(UpdateAsynEntity updateEntity);

        /// <summary>
        /// 如果update失败,在替代操作时取得内容
        /// </summary>
        /// <param name="updateEntity"></param>
        /// <returns></returns>
        string GetLog(UpdateAsynEntity updateEntity);
    }
}


 

 

===========================

            ManualResetEvent[] doneEvents = new ManualResetEvent[AppConfig.ThreadCount];
            for (int i = 0; i < AppConfig.ThreadCount; i++)
            {
                doneEvents[i] = new ManualResetEvent(false);
                ThreadPool.QueueUserWorkItem(new WaitCallback(MutiHtmlToPdf), doneEvents[i]);
                Thread.Sleep(1000);
            }
            WaitHandle.WaitAll(doneEvents);

 

 

        public void MutiHtmlToPdf(object obj)
        {
            while (productNoQueue.Count > 0)
            {                string productNo = string.Empty;
                if (productNoQueue.TryDequeue(out productNo))
                {
                    this.HtmlToPdf(productNo);
                }                
            }
            ((ManualResetEvent)obj).Set();
        }

 

        ConcurrentQueue<string> productNoQueue = new ConcurrentQueue<string>();

 

========================

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

namespace BufferingWorker
{
    public class AsyncActionManager<TActionParam> where TActionParam : class
    {
        private BlockingCollection<ActionBag<TActionParam>> _q1 = new BlockingCollection<ActionBag<TActionParam>>(5000);

        public AsyncActionManager()
        {
            for (int i = 0; i < 5; i++)
            {
                new Thread(() =>
                {
                    while (!_q1.IsCompleted)
                    {
                        var bag = _q1.Take();

                        try
                        {
                            bag.Action(bag.Param);
                        }
                        catch
                        {
                            // todo: _q2.Add(bag);
                        }
                    }
                }).Start();
            }
        }

        public void AddAction(Action<TActionParam> action, TActionParam param)
        {
            _q1.Add(new ActionBag<TActionParam>(action, param));
        }

        private class ActionBag<TParam> where TParam : class
        {
            public ActionBag(Action<TParam> action, TParam param)
            {
                this.Action = action;
                this.Param = param;
            }

            public Action<TParam> Action { get; private set; }

            public TParam Param { get; private set; }
        }
    }

    public class Bar
    {
        public Bar(string name)
        {
            this.Name = name;
        }

        public string Name { get; private set; }
    }

    public class Foo
    {
        public Foo(string name)
        {
            this.Name = name;
        }

        public string Name { get; private set; }
    }

    internal class Program
    {
        //消费是内部消费，生产是外部生产的，调用生产的地方应该单例；
        //BlockingCollection是生产消费的集合，不是生产消费管理者；
        private static AsyncActionManager<Bar> s_barManager = new AsyncActionManager<Bar>();
        private static AsyncActionManager<Foo> s_fooManager = new AsyncActionManager<Foo>();
        private static void Main(string[] args)
        {
            Action<Foo> printFoo = (foo) => { Console.WriteLine(string.Format("foo manager {0}. ThreadId: {1}", foo.Name, Thread.CurrentThread.ManagedThreadId)); };
            Action<Bar> printBar = (bar) => { Console.WriteLine(string.Format("boo manager {0}. ThreadId: {1}", bar.Name, Thread.CurrentThread.ManagedThreadId)); };

            s_fooManager.AddAction(printFoo, new Foo("first add"));


            s_barManager.AddAction(printBar, new Bar("first add"));

            for (int i = 1; i <= 100; i++)
            {
                s_barManager.AddAction(printBar, new Bar(i.ToString()));
            }

            for (int i = 1; i <= 100; i++)
            {
                s_fooManager.AddAction(printFoo, new Foo(i.ToString()));
            }

            Foo foo2 = new Foo("last add");
            s_fooManager.AddAction(printFoo, foo2);

            s_barManager.AddAction(printBar, new Bar("last add"));

            Console.WriteLine("begin? ");
            Console.ReadKey();
        }
    }
}


 

 

cxzhq2002
关注
C#多线程ThreadPool线程池详解
08-30
C#多线程ThreadPool线程池详解 C#多线程ThreadPool线程池是C#中的一种线程管理机制，用于管理和维护线程池中的线程。下面是对C#多线程ThreadPool线程池的详细介绍。 一、线程池的定义 线程池可以看做容纳线程的...
boost threadpool(修复内存泄露后的版本)
02-23
《Boost.Threadpool：内存泄漏修复版详解》 Boost.Threadpool是一个功能强大的线程池库，由Boost库家族提供，用于高效地管理和调度并发任务。在实际应用中，内存泄漏问题可能会严重影响程序的性能和稳定性，因此，...
threadpool线程池
fengzhan12138的博客
07-09 516
这里我们使用condition_variable实现线程同步，当没有任务执行时，condition_variable使线程处于等待状态，当有任务进入队列后，调用notify_one唤醒一个等待的线程处理任务，处理完成后线程又恢复到等待状态等待下一次被唤醒。为了防止竞争，条件变量总是和一个互斥锁结合在一起，通常情况下这个锁是 std::mutex，并且管理这个锁的只能是 std::unique_lock<std::mutex> RAII 的模板类。另外一个线程使条件成立，给出信号，从而唤醒被等待的线程。
C++ ThreadPool
XXXTENTAC1ON的博客
05-02 1968
线程池半同步半异步线程池 半同步半异步线程池 再处理大量并发任务的时候，如果按照传统的方式，来一个任务请求，对应一个线程来处理请求任务，大量的线程创建和销毁将消耗过多的系统资源，还增加了线程运行环境切换的开销，而通过线程池技术就可以很好地解决这些问题；线程池技术通过再系统中预先创建一定量的线程，当任务请求到来时从线程池中分配一个预先创建的线程去处理任务，线程在处理完任务之后还可以重用，不会销毁，而是等待下次任务的到来 这样，通过线程池能避免大量的线程创建和销毁动作，从而节省系统资源，这样做的一个好处是，对于
线程池 ThreadPool
m0_51648467的博客
05-15 692
但过多创建线程和销毁线程，会消耗掉大量的内存和CPU资源， 假如某段时间内突然爆发了100个短小的线程，创建和销毁这些线程就会消耗很多时间， 可能比线程本身运行的时间还长。线程池提供若干个固定线程轮流为大量的任务服务，比如用10个 线程轮流执行100个任务，当一个线程完成任务时，并不马上销毁，而是接手另一个任务， 从而减少创建和销毁线程的消耗。在上面的程序中，我们向线程池中排入了100个工作函数，线程池分别独立的完成了 这100个任务。如果这段时间内没有线程完成任务，就创建一个新线程去执行新任务。
C# ThreadPool
SJ15630070060的博客
12-12 394
假设线程池中的线程数量上限是50,要执行的任务却有100个，而线程池中的线程数量到50上限之后就不会再去增加新的线程了，那么其余的50个任务会在线程池外进行等待，等某个线程执行完毕之后会继续从队列中执行任务。在线程池中，管理器维护多个已经创建的线程，使每个线程可以被重复利用，从而达到节省线程创建时间的目的，提高线程使用效率。：表示线程池线程要执行的回调方法。此方法在有线程池线程变得可用时执行。：如果此方法成功排队，则为True；在不创建新线程的情况下执行此方法。ThreadPool里面有个静态。
ThreadPool-线程池使用及原理
m0_72560900的博客
03-27 1160
前面提到过，一般在工作中都是根据业务场景进行自定义线程池；西面是阿里巴巴开发手册的说明；
ThreadPool 线程池
m0_54202121的博客
04-25 5013
文章目录ThreadPool 线程池线程池简介(三大方法，七大参数，四大策略)Executor类线程池参数说明拒绝策略(重点)Executors线程池的方法与创建newCachedThreadPool(常用)(可扩容)newFixedThreadPool(常用)(固定)newSingleThreadExecutor(常用)(单个)线程池的提交方式execute()submit()线程池的关闭方式 ThreadPool 线程池 三大方法： newSingleThreadExecutor(常用)(单个)–&
ThreadPool讲解
changhangshi的博客
11-30 1876
1.1获取线程的方法 实现Runnable接口 实现Callable接口 实例化Thread类 使用线程池获取 1.2为什么用线程池 线程池主要工作是控制运行的线程的数量，处理过程中，将任务放入到队列中，然后线程创建后，启动这些任务，如果线程数量超过了最大数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。 1.2.1 它的主要特点为：线程复用、控制最大并发数、管理线程 1.2.2 线程池中的任务是放入到阻塞队列中的 1.2.3线程池的好处 降低资源消耗。通过重复利用已创建的
c++ threadpool
黑塞的博客
01-15 2261
ThreadPool c++17 采用多线程多对列,每个线程控制一个队列，替代老的多个线程公用一个队列。 将任务拆分多个下发给每个线程，每个线程掌管 M(tasks) / N(threads)个任务 M(tasks) / N(threads)个任务 公用一个队列。减少竞争。 使用方法： 初始化线程池 ThreadPool pool(4); //4个thread std::vector<std::future<int>>vec; 添加任务 for(int i =0;
【C++项目】C++ ThreadPool
weixin_45769058的博客
04-07 799
C++ 线程池
threadpool
03-08
throw std::runtime_error("enqueue on stopped ThreadPool"); } tasks.emplace(std::forward(f)); } condition.notify_one(); } }; int main() { ThreadPool pool(4); // 创建一个包含4个线程的线程池 for...
threadpool11:快速，无锁，跨平台的C ++ 11线程池库，旨在实现轻量级且简单
05-02
与OpenMP相比，threadpool11的性能 这是在树中找到OpenMP演示的结果。 您机器的硬件并发度是8 threadpool11执行花费了22704毫秒。 threadpool11（没有将来）的执行花费了21198毫秒。 openmp执行花费了21663毫秒...
MPU9250九轴传感器数据融合：扩展卡尔曼滤波（EKF）算法解析与应用——以四元数、陀螺仪和加速度计为核心 · 四元数
08-13
MPU9250 九轴传感器的工作原理及其应用背景，重点讲解了如何利用扩展卡尔曼滤波 (EKF) 进行数据融合。文中解释了选择四元数作为状态量、三轴陀螺仪的漂移作为控制量以及三轴加速度计和磁偏角作为观测量的原因。通过这种方式，在短时间尺度上优先信任陀螺仪提供的高精度角速度数据，而在长时间尺度上则依赖于加速度计提供的稳定姿态信息。此外，还提供了 Python 实现的简单 EKF 数据融合算法代码示例。 适合人群：对传感器数据融合感兴趣的电子工程技术人员、自动化控制领域的研究人员、从事机器人导航系统开发的技术人员。 使用场景及目标：适用于需要精确测量和稳定控制的场合，如无人机飞行控制系统、自动驾驶汽车的姿态感知模块、智能穿戴设备的动作捕捉单元等。目的是提高运动信息的准确性与稳定性。 其他说明：本文不仅理论阐述详尽，而且附有实际代码示例，便于读者理解和实践。对于希望深入了解传感器数据融合技术并掌握其实现细节的专业人士而言，是一份非常有价值的参考资料。
S7-200与MCGS PLC控制抽水泵系统：梯形图程序、接线图及组态画面解析 梯形图
08-13
No.201 S7-200与MCGS PLC在控制抽水泵系统中的应用。首先，文章讲解了梯形图程序作为控制逻辑的关键组成部分，展示了如何通过梯形图实现自动化控制，如当水位低于设定值时启动抽水泵电机。其次，文章阐述了IO分配与接线图原理图的重要性，通过合理的输入输出分配，确保系统的高效稳定运行。最后，文章介绍了MCGS PLC的组态画面，使操作人员能实时监控和管理系统，提供便捷的操作界面和故障排查工具。 适合人群：从事工业自动化领域的工程师和技术人员，特别是对PLC控制系统有一定了解的人群。 使用场景及目标：适用于需要理解和掌握S7-200与MCGS PLC在抽水泵系统中的具体应用场合，帮助工程师和技术人员更好地设计、安装和维护此类系统。 其他说明：文章不仅提供了理论知识，还附有具体的实例和图表，便于读者理解和实践。
威纶通触摸屏配方管理模板（含图库与宏程序详解）
08-13
内容概要：本文深入介绍了威纶通触摸屏配方管理模板的应用，涵盖从模板概览、文件构成到宏程序详解等多个方面。首先，模板包含完整的图库、原图和PS原文件，用户可以通过直接拖拽的方式快速设计触摸屏界面，或者对原文件进行个性化修改。其次，文中详细解释了宏程序的工作原理，以一个简单的照明控制系统为例，展示了如何利用宏程序实现灯光的开关控制。最后，文章强调了这套模板在实际应用中的灵活性和高效性，无论是简单控制还是复杂工艺流程，都能提供极大便利。 适合人群：从事自动化控制领域的工程师和技术人员，尤其是需要使用威纶通触摸屏进行项目开发的人员。 使用场景及目标：适用于各类工业控制场景，旨在提高工作效率，简化触摸屏界面设计和配置过程，帮助用户更好地理解和应用宏程序。 其他说明：本文不仅提供了理论指导，还通过具体实例进行了操作演示，确保读者能够在实践中掌握相关技能。
DC-Buck芯片TPS56637 4.5V-28V输入,6A
最新发布
08-13
同步降压，三阶环路调节
### 【工业自动化】西门子梯形图程序转换手册：指令与内存映射解析
08-13
内容概要：本文档是西门子梯形图程序转换器的操作手册附录，版本为 Rev 1.10。主要内容包括三大部分：指令转换列表、指令转换解决方案以及I/O内存转换表。指令转换列表详细列出了从S7-200到不同型号PLC（如CP1E、CP1L、CP1H）之间的指令对应关系，涵盖了逻辑操作、比较、定时器、计数器、数据移动、算术运算、转换指令等。对于某些复杂指令，提供了详细的转换解决方案。I/O内存转换表则详细说明了S7-200与各型号PLC之间输入输出寄存器、变量存储器、位存储器、定时器、计数器等内存区域的映射关系。此外，还包括特殊内存位的转换对照。 适合人群：具有PLC编程基础的技术人员，特别是从事西门子S7-200系列PLC向其他品牌或型号PLC迁移工作的工程师。 使用场景及目标：①帮助工程师将现有S7-200程序迁移到其他型号PLC上；②确保转换后的程序逻辑正确性和功能完整性；③提供详细的转换规则和步骤，减少迁移过程中可能出现的问题。 其他说明：文档提供了详尽的指令和内存映射表，适用于多种应用场景。工程师可以根据具体需求选择合适的转换方案，并参考提供的详细说明进行实际操作。同时，对于一些复杂指令，文档给出了具体的转换方法和注意事项，有助于提高迁移的成功率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值