有没有更好的方法来实现多线程？

Question

The source code portion below makes the CPU consumes high! Is there a better way to implement multithreading?

// This application will run 24 hours 7 days per week
//     in server

static void Main(string[] args)
{
    const int NUM = 10;

    Thread[] t = new Thread[NUM];

    for (int i = 0; i < t.Length; i++)
        t[i] = new Thread(new ThreadStart(DoWork));

    foreach (Thread u in t)
        u.Start();
}

static void DoWork()
{
    while (true)
    {
        // Perform scanning work
        // If some conditions are satisfied,
        //     it will perform some actions
    }
}

Answer 1

The question is hard to answer if it isn't clear what's inside the while(true) spinning loop. If you start 10 threads where each one does spinning without any waits (using something like AutoResetEvent.WaitOne() , Thread.Sleep() , etc.), the CPU will be consumed - since you are asking the CPU for it.

To improve overall performance threads shouldn't spin if it isn't absolutely necessary to do - and in most cases it isn't. Threads should do their work and then if there aren't more work to do, they should go to sleep. They should be woken up only if they have more work items to process. If your thread is running all the time - checking some conditions that are met only from time to time and if you have a mechanism to inform your thread that conditions are true - then the spinning is wasting of your CPU cycles.

Conceptually a thread should work in this way.

while(true)
{
    // Wait until a thread has something meaningful to do. Waiting can be done for instance by calling AutoResetEvent.WaitOne().

    // Do a meaningful work here.
}

If you do your thread code in this way, when a thread is waiting, it doesn't spend the CPU, so system is not overworked and other threads/processes can do their work.

The principal question here is, if you have some kind of notification mechanism that allows your thread to wake up when a new work item arrives. For instance, most IO operations like TCP sockets, HTTP communication, reading from files, etc. support asynchronous communication that allows your thread to go to sleep and awake only if new data arrive.

On the other hand, if you don't have such mechanism - for instance you are using a 3rd party library that doesn't notify you when something meaningful happened, you have to do some kind of spinning. But even it this case, the question is, how often do you need to check if conditions were met - so there is some work to do.

If let say, you need to check only every second if conditions were met, add Thread.Sleep(1000) calls to your thread code. This will greatly increases overal performance. Even Thread.Sleep(0) is much better then wait-less spinning.

One important note here. In modern C#, threads should not be used as your primary asynchronous programming mechanism. Using task based asynchronous programming using class Task is much easier to implement, especially if you are using await-async C# keywords and in most cases leads to better performance.

Tasks use threads internally creating new ones if there are too many work items to process with current number of threads and releasing threads, if there isn't enough work to do. Optimal number of threads reduces overal memory consumption.

In these days virtually all standard .NET APIs support task based asynchronous programming so it should be your primary tool how to achieve paralel execution of your code.

Here is some example of task based asynchronous programming.