自定义threadpool

最新推荐文章于 2023-02-15 17:48:42 发布
最新推荐文章于 2023-02-15 17:48:42 发布
阅读量1.8k 收藏
点赞数
分类专栏： 其他.net技术 文章标签： thread object system class .net 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niuniu23_1982/article/details/1685677
版权
 
由二部分组成，一个线程管理类 ThreadManager ，一个线程类 MyThread
Test 类是用来测试的
下面是代码，希望大家提出更好的建议：

1.ThreadManager.cs
using System;
using System.Threading;
using System.Collections;
 
namespace CustomThreadPool
{
         /// <summary>
         /// 线程管理器，会开启或唤醒一个线程去执行指定的回调方法
         /// </summary>
         public class ThreadManager
         {
                   private static ArrayList threadList = new ArrayList();       // 线程列表，静态
                  
                   // 不允许创建实例
                   private ThreadManager()
                   {
                   }
 
                   /// <summary>
                   /// 静态方法，开启或唤醒一个线程去执行指定的回调方法
                   /// </summary>
                   /// <param name="waitCallback"> 委托实例 </param>
                   /// <param name="obj"> 传递给回调方法的参数 </param>
                   /// <param name="timeOut"> 当没有可用的线程时的等待时间，以毫秒为单位 </param>
                   /// <returns></returns>
                   public static bool QueueUserWorkItem(WaitCallback waitCallback, Object obj, int timeOut)
                   {
                            // 锁住共享资源，实现线程安全
                            lock (threadList)
                            {
                                     try
                                     {
                                               // 如果线程列表为空，填充线程列表
                                               if (threadList.Count == 0)
                                               {
                                                        InitThreadList();
                                               }
 
                                               long startTime = DateTime.Now.Ticks;
 
                                               do
                                               {
                                                        // 遍历线程列表，找出可用的线程
                                                        foreach (MyThread myThread in threadList)
                                                        {
                                                                 // 线程为空，需要创建线程
                                                                 if (myThread.T == null )
                                                                 {
                                                                           myThread.Start(waitCallback, obj, false );
                                                                           return true ;
                                                                 }
                                                                 else if (myThread.T.ThreadState == ThreadState.Suspended)
                                                                 { // 线程为挂起状态，唤醒线程
                                                                           myThread.Start(waitCallback, obj, true );
                                                                           return true ;
                                                                 }
                                                        }
 
                                                        // 在线程 Sleep 前释放锁
                                                        Monitor.PulseAll(threadList);
                                                        Thread.Sleep(500);
 
                                               } while (((DateTime.Now.Ticks - startTime) / 10000) < timeOut);
                                     }
                                     finally
                                     {
                                               Monitor.Exit(threadList);
                                     }
                            }
                           
 
                            return false ;
                   }
 
                   // 使用 MyThread 对象填充线程列表，注意，这个时候线程并没有启动
                   private static void InitThreadList()
                   {
                            threadList = new ArrayList();
                            for ( int i = 0; i < 10; i++)
                            {
                                     MyThread t = new MyThread();
                                     threadList.Add(t);
                            }
                   }
 
         }
}
 
2.MyThread.cs
using System;
using System.Threading;
 
namespace CustomThreadPool
{
         /// <summary>
         /// 封装 .NET 框架提供的 Thread
         /// </summary>
         internal class MyThread
         {
                   private Thread t;             // 线程
                   private WaitCallback w;        // 委托，这里直接用 .NET 框架自带的，也可以根据需要自己定义一个
                   private Object o;             // 传递给符合委托的回调方法的参数值，根据委托的定义而定
 
                   /// <summary>
                   /// 执行回调方法的线程
                   /// </summary>
                   public Thread T
                   {
                            get
                            {
                                     return t;
                            }
                   }
 
                   public MyThread()
                   {
                   }
 
                   /// <summary>
                   /// 开启新线程或唤醒线程，去执行回调方法
                   /// </summary>
                   /// <param name="w"> 用回调方法实例化了的委托实例 </param>
                   /// <param name="o"> 传递给回调方法的参数值 </param>
                   /// <param name="isSuspend"> true 表示线程为挂起状态， false 则表示线程还没创建 </param>
                   public void Start(WaitCallback w, Object o, bool isSuspend)
                   {
                            // 开启新线程或唤醒线程前，先设置
                            this .w = w;
                            this .o = o;
 
                            // 线程为挂起状态，唤醒线程继续执行
                            if (isSuspend)
                            {
                                     t.Resume();
                            }
                            else
                            { // 线程还没有创建，创建一个新线程，并执行
                                     t = new Thread( new ThreadStart( this .ThreadProc));
                                     t.Start();
                            }
                   }
 
                   /// <summary>
                   /// 线程执行的方法
                   /// </summary>
                   private void ThreadProc()
                   {
                            // 死循环，使线程唤醒后不是退出，而是继续通过委托执行回调方法
                            while ( true )
                            {
                                     // 通过委托执行回调方法
                                     w(o);
                                     t.Suspend();
                            }
                   }
         }
}
 
3.Test.cs
using System;
using System.Threading;
 
namespace CustomThreadPool
{
         /// <summary>
         /// 测试自定义线程池
         /// </summary>
         class Test
         {
                   /// <summary>
                   /// 应用程序的主入口点。
                   /// </summary>
                   [STAThread]
                   static void Main( string [] args)
                   {
                            //
                            // TODO: 在此处添加代码以启动应用程序
                            //
 
                            for ( int i = 0; i < 5; i++)
                            {
                                     Console.WriteLine("Start thread {0}", i.ToString());
                                     Thread t = new Thread( new ThreadStart(WorkThread));
                                     t.Start();
                            }
 
                            Console.ReadLine();
                            Thread.CurrentThread.Abort();
                   }
 
                   public static void WorkThread()
                   {
                            for ( int i = 0; i < 10; i++)
                            {
                                     if (i ％ 2 == 0)
                                     {
                                               if (!ThreadManager.QueueUserWorkItem( new WaitCallback(ThreadProcOne), i, 2000))
                                               {
                                                        Console.WriteLine("Failed" + i.ToString());
                                               }
                                     }
                                     else
                                     {
                                               if (!ThreadManager.QueueUserWorkItem( new WaitCallback(ThreadProcTwo), i, 2000))
                                               {
                                                        Console.WriteLine("Failed" + i.ToString());
                                               }
                                     }
                            }
 
                            Thread.CurrentThread.Abort();
                   }
 
                   public static void ThreadProcOne(Object stateInfo)
                   {
                            Console.WriteLine("Test custom threadpool:" + (( int )stateInfo).ToString());
                   }
 
                   public static void ThreadProcTwo(Object stateInfo)
                   {
                            Console.WriteLine("Change work:" + (( int )stateInfo).ToString());
                   }
         }
}
 
 
niuniu23_1982
关注
专栏目录
dubbo 自定义线程池
congge
04-17 1万+
Dubbo 自定义线程池
Java:实现自定义线程池ThreadPool算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-29 210
Java:实现自定义线程池ThreadPool算法（附完整源码）
C# 自定义线程池
06-18
C#自定义线程池源码，很早以前的代码，现在翻出来给大家看看
自定义线程池－c#的简单实现
diyao2772的博客
11-19 223
下面是代码，希望大家提出更好的建议：1.ThreadManager.cs using System; using System.Threading; using System.Collections; namespace CustomThreadPool { /// <summary> /// 线程管理器，会开启或唤醒一个线程去执行指定的回...
C# ——自定义线程池
04-16
用C#自己实现的线程池。很好的范例。有助于对线程池，线程同步，线程锁的学习。很真研究通这个例子之后，我相信你对线程肯定有深刻的了解
c#为了实现自己的线程池功能(一)
weixin_33812433的博客
12-14 274
线程池的技术背景 在面向对象编程中，创建和销毁对象是非常费时间的，由于创建一个对象要获取内存资源或者其他很多其他资源，所以提高服务程序效率的一个手段就是尽可能降低创建和销毁对象的次数。特别是一些非常耗资源的对象创建和销毁。怎样利用已有对象来服务就是一个须要解决的关键问题，事实上这就是一些"池化资源"技术产生的原因。比方大家所熟悉的数据库连接池正是遵循这一思想而产生的，本文将介绍的线程...
CustomThreadPool:用于服务器上的计算工作的自定义ThreadPool实现（示例计算是第N个斐波那契数）
05-13
用于服务器上的计算工作的自定义ThreadPool实现（示例计算是第N个斐波纳契数）。 请参阅页面底部的基准测试结果。 设计注意事项： 服务器应用程序可以选择池设置，例如最小和最大线程，线程空闲时间等。 随着工作...
dubbo自定义线程池监控已有线程池的使用状态
qq_15736697的博客
02-08 633
创建一个maven工程 创建一个类继承FixedThreadPool package com.sherlock.service.impl; import org.apache.dubbo.common.URL; import org.apache.dubbo.common.threadpool.support.fixed.FixedThreadPool; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.uti.
自定义线程池
ypqdcsdn的博客
08-30 591
自定义线程池
自己写的C#线程池
03-29
从易语言转型到C#感觉C#自带的线程池不够灵活(或许是自己的技术不够),所以自己写了一个线程池工作类为了配合自己的使用习惯,有兴趣的可以下载参考 代码用到的是信号处理以及队列等一些比较基础的东西,已经测试了功能基本上可用
C#自定义线程池
10-29
自定义的线程池类，自己写的一个组件，用起来还是挺方便的。我已经用在了好几个项目上。 资源中包括一个DLL文件和一个XML文件，XML文件是方法和属性的一个注释文档，将其和DLL放置同一个目录下后，引用DLL后，使用DLL内的方法会有说明提示。
C#实现线程池的简单示例
09-04
主要介绍了C#实现线程池的简单示例,代码简洁易懂,有助于初学的朋友更好的理解C#的线程池，需要的朋友可以参考下
在C＃中创建自定义线程池
04-11
初学者创建自定义线程池的方法，以了解多线程和同步的概念。
线程池原理之自定义线程池
zimo_1993的博客
09-27 921
一、队列 先说一下线程池底层的数据结构 队列：一种线性表，它的特性是先进先出，插入在一端，删除在另一端。 队列又分为阻塞队列BlockingQueue和非阻塞队列ConcurrentLinkedQueue                                      生产者生产元素插入队列，消费者消费元素在另一端删除（假定队列的容量为10） 它们两者的区别： 1、非阻塞队...
C# 多线程 自定义线程池
绀目澄清
02-15 319
Net中并发连接限制数量默认是2,意思就是说,哪怕你开100条线程同时进行请求,有效的连接数仍是2条,解决办法就是在App.config中修改配置.↓↓↓↓↓↓↓↓↓↓↓↓↓↓解决方案↓↓↓↓↓↓↓↓↓↓↓↓↓↓1.打开App.config2.原来的3.添加并发连接限制设置代码:
springboot整合自定义线程池
最新发布
05-05
在Spring Boot中整合自定义线程池需要以下步骤： 1. 创建自定义线程池的类，继承ThreadPoolExecutor类，并实现构造方法和其它必要的方法。 ```java public class CustomThreadPool extends ThreadPoolExecutor { public CustomThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); } @Override protected void beforeExecute(Thread t, Runnable r) { super.beforeExecute(t, r); } @Override protected void afterExecute(Runnable r, Throwable t) { super.afterExecute(r, t); } @Override protected void terminated() { super.terminated(); } } ``` 2. 在Spring Boot的配置文件application.properties中定义线程池的属性。 ```properties threadPool.corePoolSize=5 threadPool.maximumPoolSize=10 threadPool.keepAliveTime=60 threadPool.queueCapacity=100 ``` 3. 创建线程池的Bean，使用@Value注解获取配置文件中定义的属性，初始化自定义线程池并返回。 ```java @Configuration public class ThreadPoolConfig { @Value("${threadPool.corePoolSize}") private int corePoolSize; @Value("${threadPool.maximumPoolSize}") private int maximumPoolSize; @Value("${threadPool.keepAliveTime}") private long keepAliveTime; @Value("${threadPool.queueCapacity}") private int queueCapacity; @Bean public ExecutorService threadPoolTaskExecutor() { CustomThreadPool threadPool = new CustomThreadPool(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS, new LinkedBlockingQueue<>(queueCapacity)); return threadPool; } } ``` 4. 在需要使用线程池的地方注入该Bean，即可使用自定义线程池。 ```java @Service public class MyService { @Autowired private ExecutorService threadPool; public void doTask() { threadPool.execute(() -> { // 执行任务 }); } } ``` 这样，我们就可以在Spring Boot中成功整合自定义线程池了。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值