关于c#:实现常驻任务除了避免昙花线程还需要避免重返线程池

后面咱们应用简略的例子演示了 Task 和 Thread 的两种制作昙花线程的形式。那么除了防止昙花线程，在实现常驻工作的时候，还须要防止重返线程池。本文将介绍如何防止重返线程池。

常驻工作

常驻工作十分常见，比方：

1. 咱们正在编写一个日志文件库，咱们心愿在后盾一直的将日志写入文件，尽可能不影响业务线程的执行。因而，须要一个写文件的常驻工作。
2. 咱们对接了一个近程 TCP 服务，对方要求咱们每隔一段时间发送一个心跳包，以放弃连贯。因而，须要一个发送心跳包的常驻工作。
3. 咱们编写了一个简略的内存缓存，通过一个后台任务来定期清理过期的缓存。因而，须要一个清理缓存的常驻工作。

相似的场景还有很多。因而，咱们须要一个可能实现常驻工作的办法。

而实现常驻工作的次要要点是：

1. 常驻工作必须防止影响业务线程的执行，因而须要在后盾执行。
2. 常驻工作不能被业务线程影响，无论以后业务如许忙碌，常驻工作都必须可能失常执行。否则会呈现日志不落盘，心跳包不发送，缓存不清理等问题。

实现常驻工作的伎俩有很多。本文将围绕如何应用常驻繁多线程来实现常驻工作。

所谓常驻繁多线程，就是指始终应用一个线程来执行常驻工作。从而达到：

1. 防止频繁的创立和销毁线程，从而防止频繁的线程切换。
2. 更容易的解决背压问题。
3. 更容易的解决线程平安问题。

评测主体

咱们将采纳如下状况来评测如何编写常驻工作的正确性。

private int _count = 0;private void ProcessTest(Action<CancellationToken> action, [CallerMemberName] string methodName = ""){    var cts = new CancellationTokenSource();    // 启动常驻线程    action.Invoke(cts.Token);    // 严架给压力    YanjiaIsComing(cts.Token);    // 期待一段时间    Thread.Sleep(TimeSpan.FromSeconds(5));    cts.Cancel();    // 输入后果    Console.WriteLine($"{methodName}: count = {_count}");}private void YanjiaIsComing(CancellationToken token){    Parallel.ForEachAsync(Enumerable.Range(0, 1_000_000), token, (i, c) =>    {        while (true)        {            // do something            c.ThrowIfCancellationRequested();        }    });}

这里咱们定义了一个 ProcessTest 办法，用于评测常驻工作的正确性。咱们将在这个办法中启动常驻工作，而后执行一个严架给压力的办法，来模仿十分忙碌的业务操作。最初咱们将输入常驻工作中的计数器的值。

能够初步看一下严架带来的压力有多大：

而后咱们无妨假如，咱们的常驻工作是心愿每秒进行一次计数。那么最终在控制台输入的后果应该是 5 或者 6。但如果小于 5，那么就阐明咱们的常驻工作有问题。

比方上面这样：

[Test]public void TestTaskRun_Error(){    ProcessTest(token =>    {        Task.Run(async () =>        {            while (true)            {                _count++;                await Task.Delay(TimeSpan.FromSeconds(1), token);            }        }, token);    });    // TestTaskRun_Error: count = 1}

在该测试中，咱们心愿应用 Task.Run 来执行咱们期待的循环，进行每秒加一的操作。然而，咱们发现，最终输入的后果是 1。这是因为：

1. Task.Run 会将咱们的工作放入 Task Default Scheduler 线程池中执行。
2. 然而因为迫于严架给压力，咱们的业务线程会始终处于忙碌状态，因而线程池中的线程也会始终处于忙碌状态。
3. 从而日导致咱们的常驻工作无奈失常执行。

这里咱们能够看到，Task.Run 并不是一种正确的实现常驻工作的办法。当然实际上这也不是常驻繁多线程，因为这样实质是应用了线程池。

欢送关注作者的微信公众号“newbe技术专栏”，获取更多技术内容。

全同步过程

联合咱们之前提到的 TaskCreationOptions.LongRunning 以及 Thread 很容易在全同步的状况下实现常驻繁多线程。

[Test]public void TestSyncTaskLongRunning_Success(){    ProcessTest(token =>    {        Task.Factory.StartNew(() =>        {            while (true)            {                _count++;                Thread.Sleep(TimeSpan.FromSeconds(1));            }        }, token, TaskCreationOptions.LongRunning, TaskScheduler.Current);    });    // TestSyncTaskLongRunning_Success: count = 6}[Test]public void TestThread_Success(){    ProcessTest(token =>    {        new Thread(() =>        {            while (true)            {                _count++;                Thread.Sleep(TimeSpan.FromSeconds(1));                if (token.IsCancellationRequested)                {                    return;                }            }        })        {            IsBackground = true,        }.Start();    });    // TestThread_Success: count = 6}

这两种正确的写法都实现了常驻繁多线程，因而咱们能够看到，最终输入的后果都是 6。

昙花线程

那么天然，咱们也能够晓得，如果混合了昙花线程，那么就会呈现问题。

[Test]public void TestAsyncTaskLongRunning_Error(){    ProcessTest(token =>    {        Task.Factory.StartNew(async () =>        {            while (true)            {                _count++;                await Task.Delay(TimeSpan.FromSeconds(1), token);            }        }, token, TaskCreationOptions.LongRunning, TaskScheduler.Current);    });    // TestAsyncTaskLongRunning_Error: count = 1}[Test]public void TestThreadWithAsync_Error(){    ProcessTest(token =>    {        Task CountUp(CancellationToken c)        {            _count++;            return Task.CompletedTask;        }        new Thread(async () =>        {            while (true)            {                try                {                    await CountUp(token);                    await Task.Delay(TimeSpan.FromSeconds(1), token);                    token.ThrowIfCancellationRequested();                }                catch (OperationCanceledException e)                {                    return;                }            }        })        {            IsBackground = true,        }.Start();    });    // TestThreadWithAsync_Error: count = 1}

这两种谬误的写法都无奈实现常驻繁多线程，因而咱们能够看到，最终输入的后果都是 1。

不是有 Task 就是异步的

尽管不是本篇的要害内容，然而还是额定补充两个 case 作为比照：

[Test]public void TestThreadWithTask_Success(){    ProcessTest(token =>    {        Task CountUp(CancellationToken c)        {            _count++;            return Task.CompletedTask;        }        new Thread(() =>        {            while (true)            {                try                {                    CountUp(token).Wait(token);                    Thread.Sleep(TimeSpan.FromSeconds(1));                }                catch (OperationCanceledException e)                {                    return;                }            }        })        {            IsBackground = true,        }.Start();    });    // TestThreadWithTask_Success: count = 6}[Test]public void TestThreadWithDelayTask_Error(){    ProcessTest(token =>    {        Task CountUp(CancellationToken c)        {            _count++;            return Task.Delay(TimeSpan.FromSeconds(1), c);        }        new Thread(() =>        {            while (true)            {                try                {                    CountUp(token).Wait(token);                    token.ThrowIfCancellationRequested();                }                catch (OperationCanceledException e)                {                    return;                }            }        })        {            IsBackground = true,        }.Start();    });    // TestThreadWithDelayTask_Error: count = 1}

在这两个 case 但中，尽管在 while 中蕴含了 wait Task，然而因为 Task.CompletedTask 实际上是一种同步代码，所以并不会进入到线程池当中。因而也就不会呈现谬误的状况。

然而这种谬误的起因不是因为昙花线程，是因为咱们在 Thread 中进行了 Wait，然而被调用的 Task 如果的确是一个异步的 Task，那么因为线程池忙碌，咱们的 Task 就会被提早执行，因而就会呈现谬误的状况。

总结

1. 在全同步的状况下，咱们能够应用 TaskCreationOptions.LongRunning 或者 Thread 来实现常驻繁多线程。从而实现稳固的常驻工作。
2. 留神 async/await 可能会导致线程池的应用，从而防止常驻繁多线程被毁坏。
3. 咱们暂未给出带有异步代码的状况下如何实现稳固的常驻工作，咱们将在后续探讨。

测试代码：https://github.com/newbe36524/Newbe.Demo/tree/main/src/BlogDemos/Newbe.LongRunningJob

参考

• .NET Task 揭秘（2）：Task 的回调执行与 await¹
• Task²
• TaskCreationOptions³
• 这样在 C# 应用 LongRunningTask 是错的⁴
• async 与 Thread 的谬误联合⁵

感谢您的浏览，如果您感觉本文有用，快点击下方点赞按钮，让更多的人看到本文。

欢送关注作者的微信公众号“newbe技术专栏”，获取更多技术内容。

• 本文作者： newbe36524
• 本文链接： https://www.newbe.pro/Others/0x028-avoid-return-to-threadpool-in-longrunning-task/
• 版权申明： 本博客所有文章除特地申明外，均采纳 BY-NC-SA 许可协定。转载请注明出处！