C#之：线程池：ThreadPool

最新推荐文章于 2023-07-18 19:31:41 发布
最新推荐文章于 2023-07-18 19:31:41 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： C# 多线程，并行和异步 文章标签： C# 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41049188/article/details/100126388
版权

ThreadPool: 线程池

提供一个线程池，该线程池可用于执行任务、发送工作项、处理异步 I/O、代表其他线程等待以及处理计时器。

使用线程能极大地提升用户体验度，但作为开发者应该注意，线程的开销是很大的。

线程的空间开销来自：

  1. 线程内核对象(Thread Kernel Object ) 。每个线程都会创建一个这样的对象，它主要包含线程的上下文信息。在32位系统中占用700个字节左右。
  2. 线程环境块(Thread Environment Block) 。TEB 包括线程的异常处理链。32位系统中会占用4KB 内存。
  3. 用户模式栈( User Model Stack ) ，即线程栈。线程栈用于保护方法的 参数，局部变量和返回值。每个 线程栈占用 1024KB 的内存。要用完这些内存很简单，写一个不能结束的递归方法，让方法参数和返回值不停的消耗内存，很快就会 OutOfMemoryException。
  4. 内核模式栈( Kernel Model Stack) 。当调用操作系统的内核模式函数时，系统就会将函数参数从用户模式栈复制到内核模式栈。在 32位操作系统中会占用 12KB 内存。

线程的时间开销：

  • 创建线程的时候，系统相继初始化以上这些内存空间。
  • 接着CLR 会调用所有加载DLL 的 DLLMain方法，并传递连接标志(线程终止的时候，也会调用DLL 的 DLLMain 方法，并传递分离标志)。
  • 线程上下文切换。一个系统会加载很多进程，而一个进程又包含若干线程。但是一个CPU在任何时候只能又一个线程在执行。为了让每个线程看上取都在运行，系统会不断地切换“线程上下文” ：每个线程大概得到几十毫秒的执行时间，然后就切换到下一个线程了。这个过程大概又分为一下5步：
    1：进入内核模式
    2：将上下文信息（主要是一些CPU寄存器信息）保存到正在执行的线程内核对象上。
    3：系统获取一个 SpinLock ,并确定下一个要执行的线程，然后释放 SpinLock 。如果下一个线程不在同一个进程内，则需要进行虚拟的地址交换。
    4：从被执行的线程内核对象上载入上下文信息。
    5：离开内核模式。

由于要进行如此多的工作，所以创建和销毁一个线程就意味者代价"昂贵"。而线程池就避免了，这些弊端。简单来说，线程池就是替开发人员来管理工作线程。当一项工作完毕时，CLR不会销毁这个线程，而会保留这个线程一段时间，看是否又别的工作 需要这个线程。至于何时销毁，又 CLR 根据自身的算法来做这个决定。

示例Dome:

class Program
    {
        static readonly int num = 3;
        static void Main(string[] args)
        {
            for (int i = 0; i < num; i++)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(s =>
                {
                    Console.WriteLine("线程ID:{0},开始执行", Thread.CurrentThread.ManagedThreadId);
                    Stopwatch stw = new Stopwatch();
                    stw.Start();
                    long result = SumNumbers(10000000);
                    stw.Stop();
                    Console.WriteLine("线程ID:{0},执行完成,执行结果:{1},执行用时{2}毫秒,",Thread.CurrentThread.ManagedThreadId, result, stw.ElapsedMilliseconds);
                }));
            }

            Console.ReadKey();
        }

        static long SumNumbers(int count)
        {
            long sum = 0;
            for (int i = 0; i < count; i++)
            {
                sum += i;
            }
            Thread.Sleep(1000);
            return sum;
        }
    }

在这里插入图片描述

class Program
    {
        static readonly int num = 3;
        static void Main(string[] args)
        {
            int val = 100;
            for (int i = 0; i < num; i++)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(s =>
                {
                    int n = (int)val;
                    Console.WriteLine("传入参数是：{0}",n);
                    Console.WriteLine("线程ID:{0},开始执行", Thread.CurrentThread.ManagedThreadId);
                    Stopwatch stw = new Stopwatch();
                    stw.Start();
                    long result = SumNumbers(10000000);
                    stw.Stop();
                    Console.WriteLine("线程ID:{0},执行完成,执行结果:{1},执行用时{2}毫秒,",Thread.CurrentThread.ManagedThreadId, result, stw.ElapsedMilliseconds);
                }), val);//传入参数
            }

            Console.ReadKey();
        }

        static long SumNumbers(int count)
        {
            long sum = 0;
            for (int i = 0; i < count; i++)
            {
                sum += i;
            }
            Thread.Sleep(1000);
            return sum;
        }
    }

在这里插入图片描述
用线程池之后就无法对线程进行精细化的控制了（线程启停、优先级控制等）
ThreadPool类的一个重要方法：
static bool QueueUserWorkItem(WaitCallback callBack)
static bool QueueUserWorkItem(WaitCallback callBack, object state)
第二个重载是用来传递一个参数给线程代码的。
除非要对线程进行精细化的控制，否则建议使用线程池，因为又简单、性能调优又更好。

ThreadPool官方链接：ThreadPool

BackgroundWorker：在单独的线程上执行操作。

BackgroundWorker 类型内部使用了线程池技术，同时在 WinForm和 WPF中，它给工作线程和UI提供了交互能力。ThreadPool 和 Thread 默认都没有这种能力。 而 BackgroundWoeker却通过事件提供了这种能力。这种能力包括：报告进度，支持完成回调，取消任务，暂停任务等。

示例 Dome:
下面的代码示例演示了用于以异步BackgroundWorker方式执行耗时操作
WinForm 程序，在界面添加一个BackgroundWorker组件。

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            backgroundWorker1.WorkerReportsProgress = true;//报告进度
            backgroundWorker1.WorkerSupportsCancellation = true;//支持异步取消
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //操作
            backgroundWorker1.DoWork += BackgroundWorker1_DoWork;
            //进度
            backgroundWorker1.ProgressChanged += BackgroundWorker1_ProgressChanged;
            //完成回调
            backgroundWorker1.RunWorkerCompleted += BackgroundWorker1_RunWorkerCompleted;
        }

        /// <summary>
        /// 此事件处理程序处理后台操作的结果。回调函数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BackgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled == true)
            {
                resultLabel.Text = "已取消!";
            }
            else if (e.Error != null)
            {
                resultLabel.Text = "Error: " + e.Error.Message;
            }
            else
            {
                resultLabel.Text = "完成!";
            }
        }

        /// <summary>
        /// 报告进度
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BackgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            resultLabel.Text = (e.ProgressPercentage.ToString() + "%");
        }

        /// <summary>
        /// 具体操作
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BackgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;

            for (int i = 1; i <= 10; i++)
            {
                if (worker.CancellationPending == true)
                {
                    e.Cancel = true;
                    break;
                }
                else
                {
                    // 模拟执行耗时的操作并报告进度。
                    System.Threading.Thread.Sleep(500);
                    worker.ReportProgress(i * 10);
                }
            }
        }

        /// <summary>
        /// 异步开始
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ButStart_Click(object sender, EventArgs e)
        {
            if(backgroundWorker1.IsBusy!=true)//如果没有正在执行异步操作
            {
                backgroundWorker1.RunWorkerAsync();//开始执行后台操作
            }
        }

        /// <summary>
        /// 异步取消
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ButCancel_Click(object sender, EventArgs e)
        {
            if(backgroundWorker1.WorkerSupportsCancellation==true)
            {
                backgroundWorker1.CancelAsync();
            }
        }
    }

效果：
在这里插入图片描述
示例Dome:
下面的代码示例演示如何使用BackgroundWorker类异步执行耗时的操作
操作计算选定的斐波那契数, 在计算过程中报告进度更新, 并允许取消挂起的计算。

 public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            this.backgroundWorker1.WorkerReportsProgress = true;
            this.backgroundWorker1.WorkerSupportsCancellation = true;
        }
        private int numberToCompute = 0;
        private int highestPercentageReached = 0;

        /// <summary>
        /// 开始
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ButStart_Click(object sender, EventArgs e)
        {
            resultLabel.Text = String.Empty;
            this.numericUpDown1.Enabled = false;
            this.butStart.Enabled = false;
            this.butClecel.Enabled = true;
            numberToCompute = (int)numericUpDown1.Value;
            highestPercentageReached = 0;
            backgroundWorker1.RunWorkerAsync(numberToCompute);
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //操作
            this.backgroundWorker1.DoWork += BackgroundWorker1_DoWork;
            //完成回调函数
            this.backgroundWorker1.RunWorkerCompleted += BackgroundWorker1_RunWorkerCompleted;
            //进度报告
            this.backgroundWorker1.ProgressChanged += BackgroundWorker1_ProgressChanged;
        }

        /// <summary>
        /// 显示进度
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BackgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            this.progressBar1.Value = e.ProgressPercentage;
        }

        /// <summary>
        /// 完成回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BackgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if(e.Error!=null)
            {
                MessageBox.Show(e.Error.Message);
            }
            else if(e.Cancelled)
            {
                resultLabel.Text = "已取消";
            }
            else
            {
                resultLabel.Text = e.Result.ToString();
            }
            this.numericUpDown1.Enabled = true;
            this.butStart.Enabled = true;
            this.butClecel.Enabled = false;
        }

        private void BackgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;
            e.Result = ComputeFibonacci((int)e.Argument, worker, e);
        }

        /// <summary>
        /// 取消
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ButClecel_Click(object sender, EventArgs e)
        {
            this.backgroundWorker1.CancelAsync();
            butClecel.Enabled = false;
        }

        /// <summary>
        /// 求非彼那切数列
        /// </summary>
        /// <param name="n"></param>
        /// <param name="worker"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private long ComputeFibonacci(int n, BackgroundWorker worker, DoWorkEventArgs e)
        {
            if ((n < 0) || (n > 91))
            {
                throw new ArgumentException("value must be >= 0 and <= 91", "n");
            }
            long result = 0;
            if (worker.CancellationPending)
            {
                e.Cancel = true;
            }
            else
            {
                if (n < 2)
                {
                    result = 1;
                }
                else
                {
                    result = ComputeFibonacci(n - 1, worker, e) + ComputeFibonacci(n - 2, worker, e);
                }

                // Report progress as a percentage of the total task.
                int percentComplete = (int)((float)n / (float)numberToCompute * 100);
                if (percentComplete > highestPercentageReached)
                {
                    highestPercentageReached = percentComplete;
                    worker.ReportProgress(percentComplete);
                }
            }
            return result;
        }
    }

运行输出：
在这里插入图片描述

备注

注意不要操作DoWork事件处理程序中的任何用户界面对象。 而是通过ProgressChanged和RunWorkerCompleted事件与用户界面通信。
BackgroundWorker事件不跨AppDomain边界进行封送处理。 不要使用BackgroundWorker组件来执行多AppDomain线程操作。
如果后台操作需要参数, 请使用参数RunWorkerAsync调用。 在事件处理程序中, 可以DoWorkEventArgs.Argument从属性中提取参数。 DoWork

详细信息链接：BackgroundWorker

haixin-561
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 线程池ThreadPool的用法简析
smooth_tailor的博客
09-07 7万+
什么是线程池？为什么要用线程池？怎么用线程池？ 1. 什么是线程池？         .NET Framework的ThreadPool类提供一个线程池，该线程池可用于执行任务、发送工作项、处理异步 I/O、代表其他线程等待以及处理计时器。那么什么是线程池？线程池其实就是一个存放线程对象的“池子(pool)”，他提供了一些基本方法，如：设置pool中最小/最大线程数量、把要执行的方法排入队
ThreadPool:线程池+任务队列
05-15
ThreadPool 线程池+任务队列
C# 异步多线程入门到精通之ThreadPool篇
chinaherolts2008的博客
01-21 2054
c#教程​https://www.cnblogs.com/Yesi/p/15829200.html ​ ThreadPool是.net2.0时代的产物，有了Thread为什么还会有ThreadPool呢？ThreadPool可以做到限制线程数量、重用线程 启动线程池线程 ThreadPool 提供的 API 相对于 Thread 是比较少的，在 ThreadPool 中需使用 QueueUserWorkItem 方法，来启动一个线程 例如：Dosome 是个普通的方法...
C#基础--线程Thread和线程池ThreadPool
YSの陈憨憨
07-18 2006
ThreadStart 是属于System.Threading 中的一个内置委托ParameterizedThreadStart 是属于System.Threading 中的一个内置委托。
C#（四十五）之线程池
camellia的博客
07-20 1765
C#（四十五）之线程池
C# ThreadPool 线程池
yemaogu的专栏
08-07 188
代码】C# ThreadPool 线程池。
C#多线程ThreadPool线程池详解
08-30
C#多线程ThreadPool线程池详解 C#多线程ThreadPool线程池是C#中的一种线程管理机制，用于管理和维护线程池中的线程。下面是对C#多线程ThreadPool线程池的详细介绍。 一、线程池的定义 线程池可以看做容纳线程的...
C#线程系列讲座(3)：线程池和文件下载服务器.pdf
10-07
总结来说，C#线程池是处理并发任务的关键工具，特别是在服务器端编程中，它可以有效地管理线程资源，提高系统性能和响应速度。通过合理使用`ThreadPool`类及其相关方法，开发者可以构建高效、可扩展的服务程序，同时...
C#实现线程池的简单示例
09-04
在C#中，线程池是通过System.Threading命名空间中的ThreadPool类提供的。下面我们将深入探讨如何在C#中实现线程池以及其工作原理。 首先，线程池是一种线程管理机制，它维护着一组可重用的线程，当有新的任务需要...
ThreadPoolTaskScheduler注意事项之线程池大小poolSize以及通过JMX修改
天天向上
04-24 8829
在 Spring 中动态管理定时任务，通过简单的一句自动注入 ThreadPoolTaskScheduler 对象的代码，即可轻松实现，参见 Spring动态管理定时任务——ThreadPoolTaskScheduler 。 一、问题抛出 但如果没有查看 ThreadPoolTaskScheduler 的源码，则要特别注意 ThreadPoolTaskScheduler 中，初始化 poolS...
C# .net智能线程池 SmartThreadPool
08-14
该程序由C#完成，学习C#多线程的灵活运用。SmartThreadPool功能很强大，可以参考学习。
理解ThreadPoolExecutor源码(一)线程池的corePoolSize、maximumPoolSize和poolSize
lijunwyf的专栏
04-11 2949
我们知道，受限于硬件、内存和性能，我们不可能无限制的创建任意数量的线程，因为每一台机器允许的最大线程是一个有界值。也就是说ThreadPoolExecutor管理的线程数量是有界的。线程池就是用这些有限个数的线程，去执行提交的任务。然而对于多用户、高并发的应用来说，提交的任务数量非常巨大，一定会比允许的最大线程数多很多。为了解决这个问题，必须要引入排队机制，或者是在内存中，或者是在硬盘等容量很大的
C#线程(四、线程池ThreadPool)
鳄鱼泪的博客
06-02 2400
转自：http://blog.csdn.net/u014511737/article/details/47440495，本文有删减，请点击链接查看原文尊重楼主版权。 线程池 1.概念 线程池可以看做容纳线程的容器；一个应用程序最多只能有一个线程池； ThreadPool静态类通过QueueUserWorkItem()方法将工作函数排入线程池；每排入一个工作函数，就相当于请求创建一个
C# 线程池ThreadPool用法简介
dotNET跨平台
04-22 579
前言：自从task出现后，threadpool地位直线下降，但是一些老的程序员用惯了threadpool，我们在继承开发的时候也会时常看到这个用法，所以我们也很有必要熟悉认识它。什么是线程...
【WinForm】C#多线程Demo (线程池线程、异步任务、异步IO)
cxyhjl的博客
03-17 1175
一、随机进度条状态-线程池线程using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Windows.Forms; namespace Multithreadi...
C# 线程池ThreadPool的用法
LUOCHENLONG的专栏
10-17 2457
版权声明：本文为博主原创文章，未经博主允许不得转载。    https://blog.csdn.net/smooth_tailor/article/details/52460566 什么是线程池？为什么要用线程池？怎么用线程池？ 1. 什么是线程池？         .NET Framework的ThreadPool类提供一个线程池，该线程池可用于执行任务、发送工作项、处理异步 I/O、代表其...
C# Winform 跨线程更新UI控件常用方法汇总
weixin_30555515的博客
07-20 685
概述 C#Winform编程中，跨线程直接更新UI控件的做法是不正确的，会时常出现“线程间操作无效: 从不是创建控件的线程访问它”的异常。处理跨线程更新Winform UI控件常用的方法有4种：1. 通过UI线程的SynchronizationContext的Post/Send方法更新；2. 通过UI控件的Invoke/BeginInvoke方法更新； 3. 通过BackgroundWorke...
c# threadpool 线程池
最新发布
04-15
C#中的线程池（ThreadPool）是一种用于管理和复用线程的机制。它可以帮助我们更有效地使用系统资源，并提高多线程编程的性能和可伸缩性。 线程池的主要作用是在应用程序中维护一组可重用的线程，这些线程可以被分配...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值