C＃多线程

Question

让我说我有一个事件，每个秒被解雇10次

void Session_OnEvent(object sender, CustomEventArgs e)
{
  //DoStuff

  DoLongOperation(e);
}

我想要方法DoLongOperation（e）; 每次事件被触发时在一个单独的线程上处理，

我可以这样做：

new Thread(DoLongOperation).Start(e);

但我觉得这对性能不好，我想达到最佳性能，那么我能做的最好的事情是什么？

谢谢你...

编辑：当我说多长时间我并不意味着一个操作，最多需要超过1秒它只是我不希望事件等待那个时间所以我想在分离的线程中...

Answer 1

您问题的直接答案是：使用ThreadPool.QueueUserWorkItem将操作推送到托管线程池 。 （您可能想看看问题的答案“ 我何时使用线程池与我自己的线程？ ”）。

但是，从更大的角度来看：如果你开始的所有操作都需要超过100毫秒才能完成，那么你在数学上会产生比你能处理的更多的工作。 无论你如何分割，这都不会结束。 例如，如果每次创建一个单独的线程，那么你的进程将耗尽线程，如果你使用线程池，那么你将使用它永远无法完成的工作来淹没它，等等。

如果只有一些操作最终会很长，并且最终会立即完成，那么您可能有机会找到切实可行的解决方案。 否则，您需要重新考虑您的程序设计。

Answer 2

使用一个线程来处理您的请求，并将事件中的线程的工作项排入队列。

具体来说：

• 复制e
• 创建List <CustomEventArgs>并将副本插入到末尾
• 从线程和事件中同步对该列表的访问

作为类的成员对象，执行以下操作：

List< CustomEventArgs > _argsqueue;
Thread _processor;

在类的构造函数中，执行：

_argsqueue=new List< CustomEventArgs >();
_processor=new Thread(ProcessorMethod);

定义处理器方法：

void ProcessorMethod()
{
     while (_shouldEnd)
     {
         CustomEventArgs e=null;
         lock (_argsqueue)
         {
             if (_argsqueue.Count>0)
             {
                 CustomEventArgs e=_argsqueue[0];
                 _argsqueue.RemoveAt(0);
             }
         }
         if (e!=null) 
         {
             DoLongOperation(e);
         }
         else
         {
             Sleep(100);
         }
     }
}

在你的活动中：

lock (_argsqueue)
{
    _argsqueue.Add(e.Clone());
}

您必须自己计算细节，例如，在关闭表格或处理有问题的对象时，您必须：

_shouldEnd=true;
_processor.Join();

Answer 3

如果您使用的是C＃4.0，则可能需要考虑使用任务计划程序 。 由于您的DoLongOperation意味着它将长期运行，您应该考虑以下因素

长期任务

您可能希望明确阻止将任务放在本地队列中。 例如，您可能知道特定工作项将运行相对较长的时间，并且可能会阻止本地队列上的所有其他工作项。 在这种情况下，您可以指定LongRunning选项，该选项向调度程序提供一个提示，指示该任务可能需要一个额外的线程，这样它就不会阻止本地队列上其他线程或工作项的前进。 通过使用此选项，您可以完全避免ThreadPool，包括全局和本地队列。

使用TaskScheduler的另一个好处是它具有MaximumConcurrencyLevel。 这使您可以在完成Jon推荐的测试后相对容易地调整并发性。

以下是来自MSDN的示例

namespace System.Threading.Tasks.Schedulers
{

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Threading;

    class Program
    {
        static void Main()
        {
            LimitedConcurrencyLevelTaskScheduler lcts = new LimitedConcurrencyLevelTaskScheduler(1);
            TaskFactory factory = new TaskFactory(lcts);

            factory.StartNew(()=> 
                {
                    for (int i = 0; i < 500; i++)
                    {
                        Console.Write("{0} on thread {1}", i, Thread.CurrentThread.ManagedThreadId);
                    }
                }
            );

            Console.ReadKey();
        }
    }

    /// <summary>
    /// Provides a task scheduler that ensures a maximum concurrency level while
    /// running on top of the ThreadPool.
    /// </summary>
    public class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
    {
        /// <summary>Whether the current thread is processing work items.</summary>
        [ThreadStatic]
        private static bool _currentThreadIsProcessingItems;
        /// <summary>The list of tasks to be executed.</summary>
        private readonly LinkedList<Task> _tasks = new LinkedList<Task>(); // protected by lock(_tasks)
        /// <summary>The maximum concurrency level allowed by this scheduler.</summary>
        private readonly int _maxDegreeOfParallelism;
        /// <summary>Whether the scheduler is currently processing work items.</summary>
        private int _delegatesQueuedOrRunning = 0; // protected by lock(_tasks)

        /// <summary>
        /// Initializes an instance of the LimitedConcurrencyLevelTaskScheduler class with the
        /// specified degree of parallelism.
        /// </summary>
        /// <param name="maxDegreeOfParallelism">The maximum degree of parallelism provided by this scheduler.</param>
        public LimitedConcurrencyLevelTaskScheduler(int maxDegreeOfParallelism)
        {
            if (maxDegreeOfParallelism < 1) throw new ArgumentOutOfRangeException("maxDegreeOfParallelism");
            _maxDegreeOfParallelism = maxDegreeOfParallelism;
        }

        /// <summary>Queues a task to the scheduler.</summary>
        /// <param name="task">The task to be queued.</param>
        protected sealed override void QueueTask(Task task)
        {
            // Add the task to the list of tasks to be processed.  If there aren't enough
            // delegates currently queued or running to process tasks, schedule another.
            lock (_tasks)
            {
                _tasks.AddLast(task);
                if (_delegatesQueuedOrRunning < _maxDegreeOfParallelism)
                {
                    ++_delegatesQueuedOrRunning;
                    NotifyThreadPoolOfPendingWork();
                }
            }
        }

        /// <summary>
        /// Informs the ThreadPool that there's work to be executed for this scheduler.
        /// </summary>
        private void NotifyThreadPoolOfPendingWork()
        {
            ThreadPool.UnsafeQueueUserWorkItem(_ =>
            {
                // Note that the current thread is now processing work items.
                // This is necessary to enable inlining of tasks into this thread.
                _currentThreadIsProcessingItems = true;
                try
                {
                    // Process all available items in the queue.
                    while (true)
                    {
                        Task item;
                        lock (_tasks)
                        {
                            // When there are no more items to be processed,
                            // note that we're done processing, and get out.
                            if (_tasks.Count == 0)
                            {
                                --_delegatesQueuedOrRunning;
                                break;
                            }

                            // Get the next item from the queue
                            item = _tasks.First.Value;
                            _tasks.RemoveFirst();
                        }

                        // Execute the task we pulled out of the queue
                        base.TryExecuteTask(item);
                    }
                }
                // We're done processing items on the current thread
                finally { _currentThreadIsProcessingItems = false; }
            }, null);
        }

        /// <summary>Attempts to execute the specified task on the current thread.</summary>
        /// <param name="task">The task to be executed.</param>
        /// <param name="taskWasPreviouslyQueued"></param>
        /// <returns>Whether the task could be executed on the current thread.</returns>
        protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
        {
            // If this thread isn't already processing a task, we don't support inlining
            if (!_currentThreadIsProcessingItems) return false;

            // If the task was previously queued, remove it from the queue
            if (taskWasPreviouslyQueued) TryDequeue(task);

            // Try to run the task.
            return base.TryExecuteTask(task);
        }

        /// <summary>Attempts to remove a previously scheduled task from the scheduler.</summary>
        /// <param name="task">The task to be removed.</param>
        /// <returns>Whether the task could be found and removed.</returns>
        protected sealed override bool TryDequeue(Task task)
        {
            lock (_tasks) return _tasks.Remove(task);
        }

        /// <summary>Gets the maximum concurrency level supported by this scheduler.</summary>
        public sealed override int MaximumConcurrencyLevel { get { return _maxDegreeOfParallelism; } }

        /// <summary>Gets an enumerable of the tasks currently scheduled on this scheduler.</summary>
        /// <returns>An enumerable of the tasks currently scheduled.</returns>
        protected sealed override IEnumerable<Task> GetScheduledTasks()
        {
            bool lockTaken = false;
            try
            {
                Monitor.TryEnter(_tasks, ref lockTaken);
                if (lockTaken) return _tasks.ToArray();
                else throw new NotSupportedException();
            }
            finally
            {
                if (lockTaken) Monitor.Exit(_tasks);
            }
        }
    }
}

Answer 4

性能将在很大程度上取决于几个因素：

• 一次运行多少个线程？
• 他们会做什么？
• 他们会跑多久？ （最短执行时间，最大值，平均值）
• 如果其中一个线程异常结束会发生什么？

每秒十次是相当高的活动率。 根据执行的持续时间，使用单独的进程（如服务）可能更有意义。 该活动显然必须是线程安全的，这意味着（部分）没有资源争用。 如果两个线程可能需要更新相同的资源（文件，内存位置），则需要使用锁定。 如果处理不当，这可能会妨碍效率。

Answer 5

是的，你可以这样做。 但是，当您的事件每秒触发10次并且每秒启动10次长时间运行时，您将很快耗尽线程。