线程上下文切换的性能损耗测试

线程上下文切换的性能损耗到底有多少，一直没有直观的理解，今天写个程序测试一下。先看看下面的程序（点击下载）：

ThreadTester是所有Tester的基类。所有的Tester都干的是同样一件事情，把counter增加到100000000，每次只能加1。

public abstract class ThreadTester
    {
        public const long MAX_COUNTER_NUMBER = 100000000;

        private long _counter = 0;

        //获得计数
        public virtual long GetCounter()
        {
            return this._counter;
        }

        //增加计数器
        protected virtual void IncreaseCounter()
        {
            this._counter += 1;
        }

        //启动测试
        public abstract void Start();

        //获得Counter从开始增加到现在的数字所耗的时间
        public abstract long GetElapsedMillisecondsOfIncreaseCounter();

        //测试是否正在运行
        public abstract bool IsTesterRunning();
    }

SingleThreadTester是单线程计数。

class SingleThreadTester : ThreadTester
    {
        private Stopwatch _aStopWatch = new Stopwatch();

        public override void Start()
        {
            _aStopWatch.Start();

            Thread aThread = new Thread(() => WorkInThread());
            aThread.Start();
        }

        public override long GetElapsedMillisecondsOfIncreaseCounter()
        {
            return this._aStopWatch.ElapsedMilliseconds;
        }

        public override bool IsTesterRunning()
        {
            return _aStopWatch.IsRunning;
        }

        private void WorkInThread()
        {
            while (true)
            {
                if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
                {
                    _aStopWatch.Stop();
                    break;
                }

                this.IncreaseCounter();
            }
        }
    }

TwoThreadSwitchTester是两个线程交替计数。

class TwoThreadSwitchTester : ThreadTester
    {
        private Stopwatch _aStopWatch = new Stopwatch();
        private AutoResetEvent _autoResetEvent = new AutoResetEvent(false);

        public override void Start()
        {
            _aStopWatch.Start();

            Thread aThread1 = new Thread(() => Work1InThread());
            aThread1.Start();

            Thread aThread2 = new Thread(() => Work2InThread());
            aThread2.Start();
        }

        public override long GetElapsedMillisecondsOfIncreaseCounter()
        {
            return this._aStopWatch.ElapsedMilliseconds;
        }

        public override bool IsTesterRunning()
        {
            return _aStopWatch.IsRunning;
        }

        private void Work1InThread()
        {
            while (true)
            {
                _autoResetEvent.WaitOne();

                this.IncreaseCounter();

                if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
                {
                    _aStopWatch.Stop();
                    break;
                }

                _autoResetEvent.Set();
            }
        }

        private void Work2InThread()
        {
            while (true)
            {
                _autoResetEvent.Set();
                _autoResetEvent.WaitOne();
                this.IncreaseCounter();

                if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
                {
                    _aStopWatch.Stop();
                    break;
                }
            }
        }
    }

MultiThreadTester可以指定线程数，多个线程争抢计数。

class MultiThreadTester : ThreadTester
    {
        private Stopwatch _aStopWatch = new Stopwatch();
        private readonly int _threadCount = 0;
        private readonly object _counterLock = new object();

        public MultiThreadTester(int threadCount)
        {
            this._threadCount = threadCount;
        }

        public override void Start()
        {
            _aStopWatch.Start();

            for (int i = 0; i < _threadCount; i++)
            {
                Thread aThread = new Thread(() => WorkInThread());
                aThread.Start();
            }
        }

        public override long GetElapsedMillisecondsOfIncreaseCounter()
        {
            return this._aStopWatch.ElapsedMilliseconds;
        }

        public override bool IsTesterRunning()
        {
            return _aStopWatch.IsRunning;
        }

        private void WorkInThread()
        {
            while (true)
            {
                lock (_counterLock)
                {
                    if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
                    {
                        _aStopWatch.Stop();
                        break;
                    }

                    this.IncreaseCounter();
                }
            }
        }
    }

Program的Main函数中，根据用户的选择来决定执行哪个测试类。

class Program
    {
        static void Main(string[] args)
        {

            string inputText = GetUserChoice();

            while (!"4".Equals(inputText))
            {
                ThreadTester tester = GreateThreadTesterByInputText(inputText);
                tester.Start();

                while (true)
                {
                    Console.WriteLine(GetStatusOfThreadTester(tester));
                    if (!tester.IsTesterRunning())
                    {
                        break;
                    }
                    Thread.Sleep(100);
                }

                inputText = GetUserChoice();
            }

            Console.Write("Click enter to exit...");
        }

        private static string GetStatusOfThreadTester(ThreadTester tester)
        {
            return string.Format("[耗时{0}ms] counter = {1}, {2}",
                    tester.GetElapsedMillisecondsOfIncreaseCounter(), tester.GetCounter(),
                    tester.IsTesterRunning() ? "running" : "stopped");
        }

        private static ThreadTester GreateThreadTesterByInputText(string inputText)
        {
            switch (inputText)
            {
                case "1":
                    return new SingleThreadTester();
                case "2":
                    return new TwoThreadSwitchTester();
                default:
                    return new MultiThreadTester(100);
            }
        }

        private static string GetUserChoice()
        {
            Console.WriteLine(@"==Please select the option in the following list:==
1. SingleThreadTester
2. TwoThreadSwitchTester
3. MultiThreadTester
4. Exit");

            string inputText = Console.ReadLine();

            return inputText;
        }
    }

三个测试类，运行结果如下：

Single Thread:
[耗时407ms] counter = 100000001, stopped
[耗时453ms] counter = 100000001, stopped
[耗时412ms] counter = 100000001, stopped

Two Thread Switch:
[耗时161503ms] counter = 100000001, stopped
[耗时164508ms] counter = 100000001, stopped
[耗时164201ms] counter = 100000001, stopped

Multi Threads - 100 Threads:
[耗时3659ms] counter = 100000001, stopped
[耗时3950ms] counter = 100000001, stopped
[耗时3720ms] counter = 100000001, stopped

Multi Threads - 2 Threads:
[耗时3078ms] counter = 100000001, stopped
[耗时3160ms] counter = 100000001, stopped
[耗时3106ms] counter = 100000001, stopped

什么是线程上下文切换

上下文切换的精确定义可以参考: http://www.linfo.org/context_switch.html。多任务系统往往需要同时执行多道作业。作业数往往大于机器的CPU数，然而一颗CPU同时只能执行一项任务，为了让用户感觉这些任务正在同时进行，操作系统的设计者巧妙地利用了时间片轮转的方式，CPU给每个任务都服务一定的时间，然后把当前任务的状态保存下来，在加载下一任务的状态后，继续服务下一任务。任务的状态保存及再加载，这段过程就叫做上下文切换。时间片轮转的方式使多个任务在同一颗CPU上执行变成了可能，但同时也带来了保存现场和加载现场的直接消耗。(Note. 更精确地说, 上下文切换会带来直接和间接两种因素影响程序性能的消耗. 直接消耗包括: CPU寄存器需要保存和加载, 系统调度器的代码需要执行, TLB实例需要重新加载, CPU 的pipeline需要刷掉; 间接消耗指的是多核的cache之间得共享数据, 间接消耗对于程序的影响要看线程工作区操作数据的大小).

根据上面上下文切换的定义，我们做出下面的假设：

1. 之所以TwoThreadSwitchTester执行速度最慢，因为线程上下文切换的次数最多，时间主要消耗在上下文切换了，两个线程交替计数，每计数一次就要做一次线程切换。
2. “Multi Threads - 100 Threads”比“Multi Threads - 2 Threads”开的线程数量要多，导致线程切换次数也比后者多，执行时间也比后者长。

由于Windows下没有像Linux下的vmstat这样的工具，这里我们使用Process Explorer看看程序执行的时候线程上线文切换的次数。

Single Thread:

计数期间，线程总共切换了580-548=32次。（548是启动程序后，初始的数值）

Two Thread Switch:

计数期间，线程总共切换了33673295-124=33673171次。（124是启动程序后，初始的数值）

Multi Threads - 100 Threads:

计数期间，线程总共切换了846-329=517次。（329是启动程序后，初始的数值）

Multi Threads - 2 Threads:

计数期间，线程总共切换了295-201=94次。（201是启动程序后，初始的数值）

从上面收集的数据来看，和我们的判断基本相符。

干活的其实是CPU，而不是线程

再想想原来学过的知识，之前一直以为线程多干活就快，简直是把学过的计算机原理都还给老师了。真正干活的不是线程，而是CPU。线程越多，干活不一定越快。

那么高并发的情况下什么时候适合单线程，什么时候适合多线程呢？

适合单线程的场景：单个线程的工作逻辑简单，而且速度非常快，比如从内存中读取某个值，或者从Hash表根据key获得某个value。Redis和Node.js这类程序都是单线程，适合单个线程简单快速的场景。

适合多线程的场景：单个线程的工作逻辑复杂，等待时间较长或者需要消耗大量系统运算资源，比如需要从多个远程服务获得数据并计算，或者图像处理。

例子程序：http://pan.baidu.com/s/1ntNUPWP

参考：

• Context Switch – Wikipedia
• 多线程的代价
• Threading in C#
• 为什么我要用 Node.js? 案例逐一介绍
• 知乎——redis是个单线程的程序，为什么会这么快呢？每秒10000？这个有点不解，具体是快在哪里呢？EPOLL？内存？多线程
• 从Java视角理解系统结构(一)CPU上下文切换