C# implements the thread pool function by itself (2)

Introduction

In the previous article C# implements the thread pool function by itself (1), we basically implemented a program that can be run, but it cannot really be called a thread pool. Because the code in the previous article has a fatal bug, that is, if there is no task, it is not waiting. Instead, it is running a while loop crazily and trying to lock the task list. The problem caused by this is that the performance is quite low and the program response speed is very slow. The reason for the slowness (when a new task is added, it takes a long time for the job to start running) is what I just mentioned.

In order to solve this problem, we need to use some method to enable the program to synchronize the process.

Method 1

Using semaphore

In order to reduce the locking operation of the task task, we only conduct testing when the task is not empty. Our semaphore represents the number in the task table. When s.WaitOne(); succeeds, we start to lock and take out the task

while (flag && TaskQueue != null)
            {
                //等待任务
                ThreadPoolManager.s.WaitOne();
                //获取任务
                lock (TaskQueue)
                {
                    try
                    {
                        if (TaskQueue.Count > 0)
                            task = TaskQueue.Dequeue();
                        else
                            task = null;
                    }
                    catch (Exception)
                    {
                        task = null;
                    }
                    if (task == null)
                        continue;

Add two variables to the ThreadPoolManager class

//由于采用信号量需要定义一个
        public int MaxJobNum = 1000;
        public static Semaphore s;

And initialize the semaphore s = new Semaphore(0, MaxJobNum);

This way you can Implement synchronization

The following is a test class

static void Main(string[] args)
       {
           ThreadPoolManager tpm = new ThreadPoolManager(2);
 
           TestTask t1 = new TestTask("task1");
           TestTask t2 = new TestTask("task2");
           TestTask t3 = new TestTask("task3");
           TestTask t4 = new TestTask("task4");
           TestTask t5 = new TestTask("task5");
           TestTask t6 = new TestTask("task6");
           TestTask t7 = new TestTask("task7");
           TestTask t8 = new TestTask("task8");
           TestTask t9 = new TestTask("task9");
 
           tpm.AddTask(t1);
           tpm.AddTask(t2);
           tpm.AddTask(t3);
           tpm.AddTask(t4);
           tpm.AddTask(t5);
           tpm.AddTask(t6);
           tpm.AddTask(t7);
           tpm.AddTask(t8);
           tpm.AddTask(t9);
       }

##ab13959057aa1bad90a5ec223c55de01vcD4KPGgxPre9t6i2/jwvaDE+Cs7Sw8eyu8rH08PQxbrFwb+jrM7Sw8fKudPDQXV0b1Jlc2V0RXZlbnTAtMq1z9bNrLK9Cjxicj4KCrXa0ruyvaOs1NpUaHJlYWRQb 29sTWFuYWdlcrP1yry7r8qxuvK0tL2o0ru49iAgbG9ja3MgPSBuZXcgQXV0b1Jlc2V0RXZlbnQoZmFsc2UpOwq1sUFkZFRhc2u1xMqxuvJsb2Nrcy5TZXQoKTvNqNqtci0/bXEstnX96Gj Csi7uvPO0sPHttRXb3JrVGhyZWFktcRydW66r8r91/bSu7j20KHQobXE0N64xAo8cHJlIGNsYXNzPQ=="brush:java;"> public void run() { while (flag && TaskQueue != null) { //Waiting for tasks //ThreadPoolManager.sep.WaitOne(); //Wait for tasks while (TaskQueue.Count == 0 && flag) { try { ThreadPoolManager.locks.WaitOne(); } catch (Exception) { } } //Get task lock ( TaskQueue) { try { task = TaskQueue.Dequeue(); } catch (Exception) { task = null; } if (task == null) continue; } try { task.SetEnd(false); task.StartTask(); } catch (Exception) { } try { if (!task.IsEnd()) { task.SetEnd(false); task.EndTask(); } } catch (Exception) { } }//end of while }Only when the task list We will block when the number is 0, and will not continue until AddTask

The above is the content of C#'s own implementation of the thread pool function (2). For more related content, please pay attention to the PHP Chinese website (www.php. cn)!