Test task for the Connected FixedThreadPool on C #. What is wrong here? UPD
UPDATE: I could not deny myself the pleasure of correcting my erroneous code. Added the section “Working on bugs”, in which I provide the corrected code and the description of corrections, based on the comments received.
This is rather a post-question to specialists, rather than just a piece of useful information. I invite to discussion.
Recently, I had the good fortune to send my resume in Svyaznoy to the position of a .NET developer. In response, I was asked to do a test task for knowledge of multi-threading. I cannot call myself an expert in this field, but, nevertheless, I understood perfectly how it seemed to me how to implement the following requirements:
Requires a class implementation in C #, similar to FixedThreadPool in Java, with the following requirements:
')
Since the task did not tell which primitives I should use, should I do everything on the simplest Thread or use ThreadPool, TPL, etc., I decided that the task involves the use of the most basic elements: Thread, ManualResetEvents, etc. Posted in a few hours, sent. Today I called and received an answer through the personnel officer, who sounded like this: “it’s not even close to what is needed”. This puzzled me, because the code is working and tested, there are no obvious flaws, in my opinion.
So, on your court I represent my implementation of FixedThreadPool and related classes. Immediately I warn you that, in their opinion, the implementation is erroneous, and, accordingly, you should not take my idea as a basis. Some comments on the code:
Thank you very much for the comments and constructive criticism. I decided that the topic would not be closed unless the revised solution was published. To begin with, I will list the recommendations and describe which ones are included in the code, and which are not, and why.
A test project with fixes can be downloaded here. Corrected code:
This is rather a post-question to specialists, rather than just a piece of useful information. I invite to discussion.
Recently, I had the good fortune to send my resume in Svyaznoy to the position of a .NET developer. In response, I was asked to do a test task for knowledge of multi-threading. I cannot call myself an expert in this field, but, nevertheless, I understood perfectly how it seemed to me how to implement the following requirements:
Requires a class implementation in C #, similar to FixedThreadPool in Java, with the following requirements:
- The constructor of this class must be passed the number of threads that will perform tasks.
- The class interface must provide methods: boolean execute (Task task, Priority priority) and void stop ()
- The Task interface should contain one method: void execute (), which is called on an arbitrary stream.
- The type of Priority is a listing of three priorities: HIGH, NORMAL, LOW. At the same time, when selecting the next job from the queue, the following rules apply: for three tasks with HIGH priority, one task with NORMAL priority is performed, tasks with LOW priority are not executed while there is at least one task with another priority in the queue.
- Before calling the stop () method, tasks are queued for execution and the boolean execute method (Task task, Priority priority) returns true immediately, without waiting for the task to complete; and after calling stop (), new tasks are not added to the queue for execution, and the boolean execute method (Task task, Priority priority) immediately returns false.
- The stop () method waits for all current tasks to complete (without clearing the queue).
')
Since the task did not tell which primitives I should use, should I do everything on the simplest Thread or use ThreadPool, TPL, etc., I decided that the task involves the use of the most basic elements: Thread, ManualResetEvents, etc. Posted in a few hours, sent. Today I called and received an answer through the personnel officer, who sounded like this: “it’s not even close to what is needed”. This puzzled me, because the code is working and tested, there are no obvious flaws, in my opinion.
So, on your court I represent my implementation of FixedThreadPool and related classes. Immediately I warn you that, in their opinion, the implementation is erroneous, and, accordingly, you should not take my idea as a basis. Some comments on the code:
- I decided to encapsulate task flows in the task class itself,
- two parameters with the ILog type are needed only for test purposes, they, of course, have no relation to the main functionality,
- the entire project, including the test application, can be downloaded from the link (27 kilobytes): a test project on ifolder
FixedThreadPool
/// <summary> /// , /// . /// </summary> /// <remarks> /// . /// </remarks> public sealed class FixedThreadPool { #region Constructors /// <summary> /// /// . /// </summary> /// <param name="aConcurrentTaskNumber"> /// . /// </param> /// <param name="aLog"> /// . /// </param> /// <param name="aPriorityLog"> /// . /// </param> /// <exception cref="ArgumentOutOfRangeException"> /// . /// </exception> public FixedThreadPool (int aConcurrentTaskNumber, ILog aLog = null, ILog aPriorityLog = null) { if (aConcurrentTaskNumber <= 1) { throw new ArgumentOutOfRangeException( "aConcurrentTaskNumber", " ."); } Log = aLog; PriorityLog = aPriorityLog; mConcurrentTaskNumber = aConcurrentTaskNumber; LogMessage(" ."); Thread lTaskSchedulerThread = new Thread(TaskSchedulerLogic) {Name = " ."}; lTaskSchedulerThread.Start(); LogMessage(" ."); } #endregion #region Public methods /// <summary> /// <paramref name="aTask"/> /// <paramref name="aTaskPriority"/>. /// </summary> /// <param name="aTask"> /// .. /// </param> /// <param name="aTaskPriority"> /// . /// </param> /// <returns> /// <see langword="true"/> - . /// <see langword="false"/> - , /// . /// </returns> /// <exception cref="ArgumentNullException"> /// . /// </exception> public bool Execute(Task aTask, TaskPriority aTaskPriority) { if (aTask == null) { throw new ArgumentNullException( "aTask", " ."); } LogMessage(" ."); lock (mIsStoppedLock) { if (IsStopped) { // . LogPriority(aTaskPriority, ConsoleColor.DarkGray); // . return false; } } // . EnqueueTask(aTask, aTaskPriority); LogMessage(" .", ConsoleColor.DarkYellow); return true; } /// <summary> /// , . /// . /// </summary> /// <remarks> /// /// <see cref="Execute"/> <see langword="false"/>. /// , , . /// </remarks> public void Stop() { // . lock (mIsStoppedLock) { IsStopped = true; LogMessage(" ."); } // , . LogMessage( " .", ConsoleColor.DarkRed); lock (mTaskSchedulerLock) { // mTaskSchedulerLock. Monitor.Pulse(mTaskSchedulerLock); } mPoolStoppedGate.WaitOne(); LogMessage(" .", ConsoleColor.DarkRed); } #endregion #region Private properties /// <summary> /// / , . /// </summary> /// <value> /// <see langword="true"/> - , /// . <see langword="false"/> - . /// </value> /// <remarks> /// <see cref="mIsStoppedLock"/>. /// </remarks> private bool IsStopped { get; set; } /// <summary> /// / . /// </summary> private ILog PriorityLog { get; set; } /// <summary> /// / . /// </summary> private ILog Log { get; set; } #endregion #region Private methods /// <summary> /// . . /// </summary> private void TaskSchedulerLogic() { lock (mTaskSchedulerLock) { while (true) { // , mTaskSchedulerLock. Monitor.Wait(mTaskSchedulerLock); lock (mQueuedTasksLock) { lock (mIsStoppedLock) { lock (mRunningTasksLock) { if (IsStopped && !mRunningTasks.Any() && !mQueuedTasks.Any()) { LogMessage( " ."); LogMessage(" - ."); // . mPoolStoppedGate.Set(); return; } } } } lock (mQueuedTasksLock) { if (!mQueuedTasks.Any()) { // . // . continue; } } lock (mRunningTasksLock) { if (mRunningTasks.Count >= mConcurrentTaskNumber) { // . // . continue; } } LogMessage( " .", ConsoleColor.DarkRed); // . TaskListEntry lTask = DequeueTask(); LogMessage(" - ."); // . lTask.Task.Finished += OnTaskFinished; // . lock (mRunningTasksLock) { mRunningTasks.Add(lTask); } if (lTask.TaskPriority == TaskPriority.High) { // . // . Interlocked.Increment(ref mQueuedHighPriorityTaskCounter); } else if (lTask.TaskPriority == TaskPriority.Normal) { // . // HighPriorityTaskFactor. Interlocked.Add( ref mQueuedHighPriorityTaskCounter, -HighPriorityTaskFactor); } // . lTask.Task.Execute(); LogMessage( string.Format( " - {0}.", lTask.TaskPriority), ConsoleColor.DarkYellow); lock (mRunningTasksLock) { LogMessage( string.Format( " {0} .", mRunningTasks.Count)); } } } } /// <summary> /// . /// </summary> /// <param name="aSender"> /// - . /// </param> /// <param name="aEventArgs"> /// . /// </param> private void OnTaskFinished(object aSender, EventArgs aEventArgs) { Task lSender = aSender as Task; Debug.Assert( lSender != null, " aSender ."); // , . lSender.Finished -= OnTaskFinished; // . lock (mRunningTasksLock) { // . TaskListEntry lEntry = mRunningTasks.First(aEntry => aEntry.Task == lSender); mRunningTasks.Remove(lEntry); LogMessage( string.Format(" {0} .", lEntry.TaskPriority), ConsoleColor.Red); } lock (mTaskSchedulerLock) { // mTaskSchedulerLock. Monitor.Pulse(mTaskSchedulerLock); } } /// <summary> /// <paramref name="aTask"/> . /// </summary> /// <param name="aTask"> /// , . /// </param> /// <param name="aTaskPriority"> /// . /// </param> private void EnqueueTask(Task aTask, TaskPriority aTaskPriority) { TaskListEntry lEntry = new TaskListEntry(aTask, aTaskPriority); LogPriority(aTaskPriority, ConsoleColor.Green); lock (mQueuedTasksLock) { // . mQueuedTasks.Add(lEntry); LogMessage( string.Format( " {0}", lEntry.TaskPriority), ConsoleColor.Green); // . LogMessage(" .", ConsoleColor.DarkRed); } lock (mTaskSchedulerLock) { // mTaskSchedulerLock. Monitor.Pulse(mTaskSchedulerLock); } } /// <summary> /// . /// , . /// </summary> /// <returns> /// , . /// </returns> private TaskListEntry DequeueTask() { TaskListEntry lNextTask; lock (mQueuedTasksLock) { lNextTask = FindNextTaskUsingPriorityRules(); LogPriority(lNextTask.TaskPriority, ConsoleColor.Red); LogMessage( string.Format( " {0}.", lNextTask.TaskPriority), ConsoleColor.DarkRed); mQueuedTasks.Remove(lNextTask); } lock (mTaskSchedulerLock) { // mTaskSchedulerLock. Monitor.Pulse(mTaskSchedulerLock); } return lNextTask; } /// <summary> /// . /// </summary> /// <returns> /// . /// </returns> /// <remarks> /// : /// . , , /// . , /// , , . /// , , -, /// - . /// </remarks> private TaskListEntry FindNextTaskUsingPriorityRules() { TaskListEntry lNextTask; lock (mQueuedTasksLock) { Debug.Assert( mQueuedTasks.Count > 0, " FindNextTaskUsingPriorityRules , ."); // . TaskPriority lNextTaskPriority = TaskPriority.High; // . if (mQueuedTasks.All(aEntry => aEntry.TaskPriority == TaskPriority.Low)) { // . // . lNextTaskPriority = TaskPriority.Low; } else { // . if (mQueuedTasks.Any( aEntry => aEntry.TaskPriority == TaskPriority.Normal) && (mQueuedTasks.All( aEntry => aEntry.TaskPriority != TaskPriority.High) || Interlocked.CompareExchange(ref mQueuedHighPriorityTaskCounter, 0, 0) >= HighPriorityTaskFactor)) { // // // . // . lNextTaskPriority = TaskPriority.Normal; } } lNextTask = mQueuedTasks.First( aEntry => aEntry.TaskPriority == lNextTaskPriority); } return lNextTask; } /// <summary> /// . /// </summary> /// <param name="aMessage"> /// . /// </param> /// <param name="aColor"> /// . /// </param> private void LogMessage(string aMessage, ConsoleColor aColor = ConsoleColor.Yellow) { if (Log == null) { return; } Log.WriteMessage(aMessage, aColor); } /// <summary> /// . /// </summary> /// <param name="aTaskPriority"> /// . /// </param> /// <param name="aColor"> /// . /// </param> private void LogPriority(TaskPriority aTaskPriority, ConsoleColor aColor) { if (PriorityLog == null) { return; } string lPriority = aTaskPriority == TaskPriority.High ? "H" : aTaskPriority == TaskPriority.Normal ? "N" : "L"; PriorityLog.WriteMessage(lPriority, aColor); } #endregion #region Private data /// <summary> /// , /// , , /// . /// </summary> private const int HighPriorityTaskFactor = 3; /// <summary> /// . /// . /// </summary> private readonly int mConcurrentTaskNumber; /// <summary> /// <see cref="IsStopped"/>. /// </summary> private readonly object mIsStoppedLock = new object(); /// <summary> /// . , /// . /// </summary> private readonly ManualResetEvent mPoolStoppedGate = new ManualResetEvent(false); /// <summary> /// , . /// </summary> /// <remarks> /// <see cref="mQueuedTasksLock"/>. /// </remarks> private readonly IList<TaskListEntry> mQueuedTasks = new List<TaskListEntry>(); /// <summary> /// <see cref="mQueuedTasks"/>. /// </summary> private readonly object mQueuedTasksLock = new object(); /// <summary> /// . /// </summary> /// <remarks> /// <see cref="mRunningTasksLock"/>. /// </remarks> private readonly IList<TaskListEntry> mRunningTasks = new List<TaskListEntry>(); /// <summary> /// <see cref="mRunningTasks"/>. /// </summary> private readonly object mRunningTasksLock = new object(); /// <summary> /// , / . /// </summary> private readonly object mTaskSchedulerLock = new object(); /// <summary> /// , . /// , /// <see cref="HighPriorityTaskFactor"/>. /// </summary> /// <remarks> /// /// <see cref="Interlocked"/>. /// </remarks> private int mQueuedHighPriorityTaskCounter; #endregion #region Nested type: TaskListEntry /// <summary> /// . /// </summary> /// <remarks> /// . /// </remarks> private struct TaskListEntry { #region Constructors /// <summary> /// . /// </summary> /// <param name="aTask"> /// . /// </param> /// <param name="aTaskPriority"> /// . /// </param> public TaskListEntry(Task aTask, TaskPriority aTaskPriority) { mTask = aTask; mTaskPriority = aTaskPriority; } #endregion #region Public properties /// <summary> /// . /// </summary> public Task Task { get { return mTask; } } /// <summary> /// . /// </summary> public TaskPriority TaskPriority { get { return mTaskPriority; } } #endregion #region Private data private readonly Task mTask; private readonly TaskPriority mTaskPriority; #endregion } #endregion } Task
/// <summary> /// <see cref="FixedThreadPool1"/>. /// </summary> public class Task { #region Constructors /// <summary> /// <see cref="FixedThreadPool1"/> /// . /// </summary> /// <param name="aTaskBody"> /// . /// </param> /// <exception cref="ArgumentNullException"> /// . /// </exception> public Task(Action aTaskBody) { if (aTaskBody == null) { throw new ArgumentNullException("aTaskBody", " ."); } TaskBody = aTaskBody; } #endregion #region Public properties /// <summary> /// / . /// </summary> public Action TaskBody { get; private set; } #endregion #region Events /// <summary> /// , . /// </summary> public event EventHandler Finished; #endregion #region Public methods /// <summary> /// . /// </summary> public void Execute() { Thread lTaskThread = new Thread( () => { // . TaskBody(); // . EventHandler lFinished = Finished; if (lFinished != null) { lFinished(this, EventArgs.Empty); } }) {Name = "Task thread."}; lTaskThread.Start(); } #endregion }
TaskPriority
/// <summary> /// . /// </summary> public enum TaskPriority { /// <summary> /// . /// </summary> High = 0, /// <summary> /// . /// </summary> Normal, /// <summary> /// . /// </summary> Low }
Bug work
Thank you very much for the comments and constructive criticism. I decided that the topic would not be closed unless the revised solution was published. To begin with, I will list the recommendations and describe which ones are included in the code, and which are not, and why.
- Creating a stream is a very expensive operation. A thread pool is needed in order to store several threads that have already been created in it. This was my main mistake and, apparently, it was precisely this that caused such a negative reaction from the technical specialist who checks my decision. I simply concentrated too much on the conditions of the problem and overlooked the requirement that followed from the very name of the class. Thank you, Unrul , iaroshenko . Now I create the required number of threads in the pool constructor. The Task class is no longer creating threads.
- Scheduler thread is not needed. Indeed, after the creation of the thread was transferred from the task class to the pool class, it became possible to shift the task extraction function from the queue to the threads themselves. Thank you, iaroshenko , romik .
- There should be no event in the Task interface. Since the task class is no longer involved in creating threads, the task end processing event is now really not needed. Thank you, nagg .
- The lock on IsStopped can be replaced with a regular volatile field. I do not agree with this. Despite the statement by MSDN that, thanks to the volatile modifier, the code reading the value of such a field will receive the most current value, this is not so. In fact, to put it simply, volatile ensures that the compiler, the CLR and the processor do not swap the read / write in the volatile field and other fields. More details can be read here . However, in my case, the IsStopped lock is needed for another. Without it, it is potentially possible that a new task will be in the queue after the actual pool stop, and it is also possible that the task stream will remain in the waiting state, despite the fact that the completion signal was given. In any case, a small reinsurance in a multi-threaded code never hurts. This is better than catching irregular mistakes. I will not stop foaming at the mouth of this solution. If anyone can refute my argument based on the code, I would be grateful. Thank you, elw00d .
- The priority queue is implemented separately from the logic of the ThreadPool itself. I did not do this either. In fact, the pool contains not so much code, there are more comments and logging. But, nevertheless, this is not the main reason. Imagine the selection condition changed. Or, you must provide the ability to customize the principle of selecting the next task at the time of creating the pool instance. We'll have to create a new class of the sorted collection (queue) and, accordingly, produce classes of pools according to the number of collection classes. This is the wrong decision. In this case, it would be better to move the algorithm for selecting the next task into a separate class by implementing the Strategy pattern. The “selector” object will then be passed to the constructor. But I will not complicate my decision, since it is not required by the condition of the problem. Thank you, elw00d .
- Interlocked methods are also unclear why (if monitors and event are already used). I also did not touch this part. Interlocked-methods allow you to avoid violation of the conditions of selection of tasks with priorities High and Normal. Since there are no locks for access to the mQueuedHighPriorityTaskCounter counter, I chose to play it safe just in case using Interlocked methods. Perhaps a deeper analysis of the code will reveal my wrong, but as I said, I'm not the greatest expert in multithreading and prefer to lay straw, especially when it is cheap. Thank you, elw00d .
- It would be very interesting if the author decided the shortcomings voiced in the comments and again sent the updated version of the solution to the Messenger. Of course, this is only indirectly related to the code, but nonetheless. I think I will not send a fixed solution to the Messenger. This will be dishonest, since I took advantage of your help. Most likely, I will send them a link to this article, and then let them decide whether they need a “ready-made specialist” or a person who knows how to admit his mistakes and develop is advised to move on. Thanks for the support, @ARC_Programmer.
A test project with fixes can be downloaded here. Corrected code:
FixedThreadPool
// : Eshva.Threading // : FixedThreadPool.cs // GUID : 7F1EECB7-F28A-4A20-9536-26D174BCD437 // : Mike Eshva (mike@eshva.ru) // : 04.06.2012 using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Threading; namespace Eshva.Threading.Framework { /// <summary> /// , /// . /// </summary> /// <remarks> /// . /// </remarks> public sealed class FixedThreadPool { #region Constructors /// <summary> /// /// . /// </summary> /// <param name="aConcurrentTaskNumber"> /// . /// </param> /// <param name="aLog"> /// . /// </param> /// <param name="aPriorityLog"> /// . /// </param> /// <exception cref="ArgumentOutOfRangeException"> /// . /// </exception> public FixedThreadPool (int aConcurrentTaskNumber, ILog aLog = null, ILog aPriorityLog = null) { if (aConcurrentTaskNumber <= 1) { throw new ArgumentOutOfRangeException( "aConcurrentTaskNumber", " ."); } Log = aLog; PriorityLog = aPriorityLog; for (int lThreadIndex = 0; lThreadIndex < aConcurrentTaskNumber; lThreadIndex++) { string lThreadName = string.Format("Task thread #{0}", lThreadIndex); Thread lTaskThread = new Thread(TaskThreadLogic) {Name = lThreadName}; lTaskThread.Start(); } } #endregion #region Public methods /// <summary> /// <paramref name="aTask"/> /// <paramref name="aTaskPriority"/>. /// </summary> /// <param name="aTask"> /// .. /// </param> /// <param name="aTaskPriority"> /// . /// </param> /// <returns> /// <see langword="true"/> - . /// <see langword="false"/> - , /// . /// </returns> /// <exception cref="ArgumentNullException"> /// . /// </exception> public bool Execute(Task aTask, TaskPriority aTaskPriority) { if (aTask == null) { throw new ArgumentNullException( "aTask", " ."); } LogMessage(" ."); lock (mIsStoppedLock) { if (IsStopped) { // . LogPriority(aTaskPriority, ConsoleColor.DarkGray); // . return false; } } // . EnqueueTask(aTask, aTaskPriority); LogMessage(" .", ConsoleColor.DarkYellow); return true; } /// <summary> /// , . /// . /// </summary> /// <remarks> /// /// <see cref="Execute"/> <see langword="false"/>. /// , , . /// </remarks> public void Stop() { // . lock (mIsStoppedLock) { IsStopped = true; LogMessage(" ."); } // , . LogMessage( " .", ConsoleColor.DarkRed); lock (mTaskSchedulerLock) { // mTaskSchedulerLock. Monitor.PulseAll(mTaskSchedulerLock); } mPoolStoppedGate.WaitOne(); LogMessage(" .", ConsoleColor.DarkRed); } #endregion #region Private properties /// <summary> /// / , . /// </summary> /// <value> /// <see langword="true"/> - , /// . <see langword="false"/> - . /// </value> /// <remarks> /// <see cref="mIsStoppedLock"/>. /// </remarks> private bool IsStopped { get; set; } /// <summary> /// / . /// </summary> private ILog PriorityLog { get; set; } /// <summary> /// / . /// </summary> private ILog Log { get; set; } #endregion #region Private methods private void TaskThreadLogic() { lock (mTaskSchedulerLock) { while (true) { // , mTaskSchedulerLock. Monitor.Wait(mTaskSchedulerLock); lock (mQueuedTasksLock) { if (!mQueuedTasks.Any()) { lock (mIsStoppedLock) { if (IsStopped) { LogMessage( " ."); LogMessage(" - ."); // . mPoolStoppedGate.Set(); return; } } // , . // . continue; } } LogMessage( " .", ConsoleColor.DarkRed); // . TaskListEntry lTask = DequeueTask(); LogMessage(" - ."); switch (lTask.TaskPriority) { case TaskPriority.High: Interlocked.Increment(ref mQueuedHighPriorityTaskCounter); break; case TaskPriority.Normal: Interlocked.Add( ref mQueuedHighPriorityTaskCounter, -HighPriorityTaskFactor); break; } // . lTask.Task.Execute(); LogMessage( string.Format( " - {0}.", lTask.TaskPriority), ConsoleColor.DarkYellow); lock (mQueuedTasksLock) { lock (mIsStoppedLock) { if (IsStopped && !mQueuedTasks.Any()) { LogMessage( " ."); LogMessage(" - ."); // . mPoolStoppedGate.Set(); return; } } } } } } /// <summary> /// <paramref name="aTask"/> . /// </summary> /// <param name="aTask"> /// , . /// </param> /// <param name="aTaskPriority"> /// . /// </param> private void EnqueueTask(Task aTask, TaskPriority aTaskPriority) { TaskListEntry lEntry = new TaskListEntry(aTask, aTaskPriority); LogPriority(aTaskPriority, ConsoleColor.Green); lock (mQueuedTasksLock) { // . mQueuedTasks.Add(lEntry); LogMessage( string.Format( " {0}", lEntry.TaskPriority), ConsoleColor.Green); // . LogMessage(" .", ConsoleColor.DarkRed); } lock (mTaskSchedulerLock) { // mTaskSchedulerLock. Monitor.Pulse(mTaskSchedulerLock); } } /// <summary> /// . /// , . /// </summary> /// <returns> /// , . /// </returns> private TaskListEntry DequeueTask() { TaskListEntry lNextTask; lock (mQueuedTasksLock) { lNextTask = FindNextTaskUsingPriorityRules(); LogPriority(lNextTask.TaskPriority, ConsoleColor.Red); LogMessage( string.Format( " {0}.", lNextTask.TaskPriority), ConsoleColor.DarkRed); mQueuedTasks.Remove(lNextTask); } lock (mTaskSchedulerLock) { // mTaskSchedulerLock. Monitor.Pulse(mTaskSchedulerLock); } return lNextTask; } /// <summary> /// . /// </summary> /// <returns> /// . /// </returns> /// <remarks> /// : /// . , , /// . , /// , , . /// , , -, /// - . /// </remarks> private TaskListEntry FindNextTaskUsingPriorityRules() { TaskListEntry lNextTask; lock (mQueuedTasksLock) { Debug.Assert( mQueuedTasks.Count > 0, " FindNextTaskUsingPriorityRules , ."); // . TaskPriority lNextTaskPriority = TaskPriority.High; // . if (mQueuedTasks.All(aEntry => aEntry.TaskPriority == TaskPriority.Low)) { // . // . lNextTaskPriority = TaskPriority.Low; } else { // . if (mQueuedTasks.Any( aEntry => aEntry.TaskPriority == TaskPriority.Normal) && (mQueuedTasks.All( aEntry => aEntry.TaskPriority != TaskPriority.High) || Interlocked.CompareExchange(ref mQueuedHighPriorityTaskCounter, 0, 0) >= HighPriorityTaskFactor)) { // // // . // . lNextTaskPriority = TaskPriority.Normal; } } lNextTask = mQueuedTasks.First( aEntry => aEntry.TaskPriority == lNextTaskPriority); } return lNextTask; } /// <summary> /// . /// </summary> /// <param name="aMessage"> /// . /// </param> /// <param name="aColor"> /// . /// </param> private void LogMessage(string aMessage, ConsoleColor aColor = ConsoleColor.Yellow) { if (Log == null) { return; } Log.WriteMessage(aMessage, aColor); } /// <summary> /// . /// </summary> /// <param name="aTaskPriority"> /// . /// </param> /// <param name="aColor"> /// . /// </param> private void LogPriority(TaskPriority aTaskPriority, ConsoleColor aColor) { if (PriorityLog == null) { return; } string lPriority = aTaskPriority == TaskPriority.High ? "H" : aTaskPriority == TaskPriority.Normal ? "N" : "L"; PriorityLog.WriteMessage(lPriority, aColor); } #endregion #region Private data /// <summary> /// , /// , , /// . /// </summary> private const int HighPriorityTaskFactor = 3; /// <summary> /// <see cref="IsStopped"/>. /// </summary> private readonly object mIsStoppedLock = new object(); /// <summary> /// . , /// . /// </summary> private readonly ManualResetEvent mPoolStoppedGate = new ManualResetEvent(false); /// <summary> /// , . /// </summary> /// <remarks> /// <see cref="mQueuedTasksLock"/>. /// </remarks> private readonly IList<TaskListEntry> mQueuedTasks = new List<TaskListEntry>(); /// <summary> /// <see cref="mQueuedTasks"/>. /// </summary> private readonly object mQueuedTasksLock = new object(); /// <summary> /// , / . /// </summary> private readonly object mTaskSchedulerLock = new object(); /// <summary> /// , . /// , /// <see cref="HighPriorityTaskFactor"/>. /// </summary> /// <remarks> /// /// <see cref="Interlocked"/>. /// </remarks> private int mQueuedHighPriorityTaskCounter; #endregion #region Nested type: TaskListEntry /// <summary> /// . /// </summary> /// <remarks> /// . /// </remarks> private struct TaskListEntry { #region Constructors /// <summary> /// . /// </summary> /// <param name="aTask"> /// . /// </param> /// <param name="aTaskPriority"> /// . /// </param> public TaskListEntry(Task aTask, TaskPriority aTaskPriority) { mTask = aTask; mTaskPriority = aTaskPriority; } #endregion #region Public properties /// <summary> /// . /// </summary> public Task Task { get { return mTask; } } /// <summary> /// . /// </summary> public TaskPriority TaskPriority { get { return mTaskPriority; } } #endregion #region Private data private readonly Task mTask; private readonly TaskPriority mTaskPriority; #endregion } #endregion } }
Task
// : Eshva.Threading // : Task.cs // GUID : 292467E7-4816-4407-BB9B-3309D13C8614 // : Mike Eshva (mike@eshva.ru) // : 04.06.2012 using System; namespace Eshva.Threading.Framework { /// <summary> /// <see cref="FixedThreadPool"/>. /// </summary> public class Task { #region Constructors /// <summary> /// <see cref="FixedThreadPool"/> /// . /// </summary> /// <param name="aTaskBody"> /// . /// </param> /// <exception cref="ArgumentNullException"> /// . /// </exception> public Task(Action aTaskBody) { if (aTaskBody == null) { throw new ArgumentNullException("aTaskBody", " ."); } TaskBody = aTaskBody; } #endregion #region Public methods /// <summary> /// . /// </summary> public void Execute() { TaskBody(); } #endregion #region Private properties /// <summary> /// / . /// </summary> private Action TaskBody { get; set; } #endregion } }
Source: https://habr.com/ru/post/145551/
All Articles