如何将此 C# 工作线程代码与共享数据变量的主线程解耦？

Question

我如何修改下面的代码，以便更好地阅读代码：

a）将“workThreadMethod（）”移动到它自己的类中

b）此工作线程类中没有任何代码引用主“程序”中的静态变量“

c 类）以上是主要的两个要求，但是我希望作为副作用，这将确保工作线程类方法的可测试性更容易测试，并且理想情况下可以通过 IOC 进行测试（例如Ninject）概念[如果这没有意义，那么出于问题的目的忽略这一点]

我不确定要解决的主要挑战是如何处理原始线程和原始线程之间的两个不同的共享变量。新线程（其中一个是新线程添加到的 ConcurrentQueue，另一个是原始线程用于指示新线程何时停止的 bool 变量）

using System.Collections.Concurrent;
using System.Diagnostics;
using System.Threading;

namespace TestConsoleApp
{
    class Program
    {
        // Main Thread uses to indicate to New Thread to stop
        private static bool _shouldStop = false;

        // New Thread uses to pass back result to Main Thread
        private static long _results = 0;

        // Main Thread passes ongoing updates to New Thread via this queue
        private static ConcurrentQueue<long> _workQueue = new ConcurrentQueue<long>();

        static void Main(string[] args)
        {
            var p = new Program();
            p.TestThreads();
        }

        public void TestThreads()
        {
            _shouldStop = false;
            var workThread = new Thread(workThreadMethod);
            workThread.Start();

            for (int i = 0; i < 100; i++)
            {
                _workQueue.Enqueue(i);   // Add test data to queue
                Debug.WriteLine("Queue  : " + i);
                Thread.Sleep(10);
            }

            Thread.Sleep(5000);

            _shouldStop = true;
            workThread.Join();
            Debug.WriteLine("Finished TestThreads.  Result = " + _results);
        }


        // Dequeuer Methods
        private void workThreadMethod()
        {
            // Update Summary
            while (!_shouldStop)
            {
                if (_workQueue.Count == 0)
                {
                    Thread.Sleep(10);
                }
                else
                {
                    long currentValue;
                    bool worked = _workQueue.TryDequeue(out currentValue);
                    if (worked)
                    {
                        _results += currentValue;
                        Debug.WriteLine("DeQueue: " + currentValue);
                    }
                }
            }
        }
    }
}

Answer 1

这是关注点分离的练习，最初我会将这个程序拆分为工作提供者和工作人员。 Provider 负责队列和执行控制，而 Worker 负责计算。下面的代码是一个粗略的开始，但它应该可以帮助您继续。

拆分这两个问题并使用构造函数注入已经在可测试性方面得到了回报，您现在可以在不涉及 Program 的情况下完全测试 Worker。

注意：考虑到您的应用程序的进一步开发，我强烈建议您研究任务并行库。使用 TPL 等库使您能够利用多核处理器，而无需处理线程分配和工作调度的复杂性。 此处讨论了有关 TPL 的更多资源。

public interface IWorkProvider
{
    bool ShouldStop { get; }
    long? GetWork();
}

public class Program : IWorkProvider
{
    // Main Thread uses to indicate to New Thread to stop
    private static bool _shouldStop = false;

    // Main Thread passes ongoing updates to New Thread via this queue
    private static ConcurrentQueue<long> _workQueue = new ConcurrentQueue<long>();

    public bool ShouldStop { get { return _shouldStop; } }

    public long? GetWork()
    {
        long currentValue;
        bool worked = _workQueue.TryDequeue(out currentValue);
        if (worked)
            return currentValue;
        return null;
    }
}

public class Worker
{
    private long _results;
    private readonly IWorkProvider _workProvider;

    public long Results { get { return _results; }}

    public Worker(IWorkProvider workProvider)
    {
        _workProvider = workProvider;
    }

    public void DoWork()
    {
        // Update Summary
        while (!_workProvider.ShouldStop)
        {
            long? work = _workProvider.GetWork();
            if (work.HasValue)
            {
                _results += work.Value;
                Debug.WriteLine("DeQueue: " + work.Value);
            }
            else
            {
                Thread.Sleep(10);
            }
        }
    }

}