CODEWITHSUNDEEP
c#.netmultithreadingclr
Brans Ds
Brans Ds

Reputation: 4117

Why thread creation is so fast?

I read in books that thread creation is expensive (not so expensive like process creation but nevertheless it is) and we should avoid it. I write the test code and I was shocked how fast thread creation is.

using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        static int testVal = 0;
        static void Main(string[] args)
        {
            const int ThreadsCount = 10000;
            var watch = Stopwatch.StartNew();
            for (int i = 0; i < ThreadsCount; i++)
            {
                var myThread = new Thread(MainVoid);
                myThread.Start();
            }
            watch.Stop();
            Console.WriteLine("Test value ={0}", testVal);
            Console.WriteLine("Ended in {0} miliseconds", watch.ElapsedMilliseconds);
            Console.WriteLine("{0} miliseconds per thread ", (double)watch.ElapsedMilliseconds / ThreadsCount);
        }

        static void MainVoid()
        {
            Interlocked.Increment(ref testVal);
        }
    }
}

Output: 

Test value =10000

Ended in 702 miliseconds

0,0702 miliseconds per thread.

Is my code wrong or thread creation is so fast and advices in books are wrong? (I see only some extra memory consumption per thread but no creation time.)

Upvotes: 2

Views: 1128

Answers (1)

Jim Mischel
Jim Mischel

Reputation: 134055

Thread creation is pretty slow. Consider this bit of code that contrasts the speed of doing things inline, and doing things with multiple threads:

private void DoStuff()
{
    const int ThreadsCount = 10000;
    var sw = Stopwatch.StartNew();
    int testVal = 0;
    for (int i = 0; i < ThreadsCount; ++i)
    {
        Interlocked.Increment(ref testVal);
    }
    sw.Stop();
    Console.WriteLine(sw.ElapsedTicks);

    sw = Stopwatch.StartNew();
    testVal = 0;
    for (int i = 0; i < ThreadsCount; ++i)
    {
        var myThread = new Thread(() =>
        {
            Interlocked.Increment(ref testVal);
        });
        myThread.Start();
    }
    sw.Stop();
    Console.WriteLine(sw.ElapsedTicks);
}

On my system, doing it inline requires 200 ticks. With threads it's almost 2 million ticks. So using threads here takes approximately 10,000 times as long. I used ElapsedTicks here rather than ElapsedMilliseconds because with ElapsedMilliseconds the output for the inline code was 0. The threads version takes around 700 milliseconds. Context switches are expensive.

In addition, your test is fundamentally flawed because you don't explicitly wait for all of the threads to finish before harvesting the result. It's quite possible that you could output the value of testVal before the last thread finishes incrementing it.

When timing code, by the way, you should be sure to run it in release mode without the debugger attached. In Visual Studio, use Ctrl+F5 (start without debugging).

Upvotes: 2

Related Questions