多线程上下文切换的影响

红太狼 2022-02-04 07:19 320阅读 0赞

来自方腾飞老师《Java并发编程的艺术》第一章

### **什么是上下文切换** ###

即使是单核CPU也支持多线程执行代码，CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间，因为时间片非常短，所以CPU通过不停地切换线程执行，让我们感觉多个线程时同时执行的，时间片一般是几十毫秒（ms）。

CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再次加载这个任务的状态，**从任务保存到再加载的过程就是一次上下文切换**。

这就像我们同时读两本书，当我们在读一本英文的技术书籍时，发现某个单词不认识， 于是便打开中英文词典，但是在放下英文书籍之前，大脑必须先记住这本书读到了多少页的第多少行，等查完单词之后，能够继续读这本书。这样的切换是会影响读 书效率的，同样上下文切换也会影响多线程的执行速度。

在理解这个之前，要理解**程序计数器**的作用（以下摘抄来自《深入理解java虚拟机》）：

程序计数器是一块较小的内存空间，它可以看作是当前线程所执行字节码的行号指示器。在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现），字节解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。且由于java虚拟机的多线程是通过线程轮流切换并分配器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器（对于多核处理器是一个内核）都只会执行一条线程中的指令，因为为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间计数器互不影响，我们称这类区域为“线程私有”的内存。

线程切换时需要知道在这之前当前线程已经执行到哪条指令了，所以需要记录程序计数器的值，另外比如说线程正在进行某个计算的时候被挂起了，那么下次继续执行的时候需要知道之前挂起时变量的值时多少，因此需要记录CPU寄存器的状态。所以一般来说，**线程上下文切换过程中会记录程序计数器、CPU寄存器状态等数据**。

**上下文切换代码测试**

下面的代码演示串行和并行执行并累加操作的时间：

public class ContextSwitchTest
    {
        private static final long count = 10000;
        
        public static void main(String[] args) throws Exception
        {
            concurrency();
            serial();
        }
        
        private static void concurrency() throws Exception
        {
            long start = System.currentTimeMillis();
            Thread thread = new Thread(new Runnable(){
                public void run()
                {
                    int a = 0;
                    for (int i = 0; i < count; i++)
                    {
                        a += 5;
                    }
                }
            });
            thread.start();
            int b = 0;
            for (long i = 0; i < count; i++)
            {
                b --;
            }
            thread.join();
            long time = System.currentTimeMillis() - start;
            System.out.println("Concurrency：" + time + "ms, b = " + b);
        }
        
        private static void serial()
        {
            long start = System.currentTimeMillis();
            int a = 0;
            for (long i = 0; i < count; i++)
            {
                a += 5;
            }
            int b = 0;
            for (int i = 0; i < count; i++)
            {
                b --;
            }
            long time = System.currentTimeMillis() - start;
            System.out.println("Serial：" + time + "ms, b = " + b + ", a = " + a);
        }
    }

### 修改上面的count值，即修改循环次数，看一下串行运行和并发运行的时间测试结果： ###

<table> 
 <tbody> 
  <tr> 
   <td><strong>循环次数</strong></td> 
   <td><strong>串行执行耗时/ms</strong></td> 
   <td><strong>并发执行耗时/ms</strong></td> 
   <td><strong>串行和并发对比</strong></td> 
  </tr> 
  <tr> 
   <td>1亿</td> 
   <td>78</td> 
   <td>50</td> 
   <td>并发快约0.5倍</td> 
  </tr> 
  <tr> 
   <td>1000万</td> 
   <td>10</td> 
   <td>6</td> 
   <td>并发快约0.5~1倍</td> 
  </tr> 
  <tr> 
   <td>100万</td> 
   <td>3</td> 
   <td>2</td> 
   <td>差不多</td> 
  </tr> 
  <tr> 
   <td>10万</td> 
   <td>2</td> 
   <td>2</td> 
   <td>差不多</td> 
  </tr> 
  <tr> 
   <td>1万</td> 
   <td>0</td> 
   <td>1</td> 
   <td>差不多，十几次执行下来，总体而言串行略快</td> 
  </tr> 
 </tbody> 
</table>

从表中可以看出，100次并发执行累加以下，串行执行和并发执行的运行速度总体而言差不多，1万次以下串行执行甚至还可以说是略快。为什么并发执行的速度会比串行慢呢？这就是因为**线程有创建和上下文切换的开销**。

###  引起上下文切换的原因 ###

*  1.时间片用完，CPU正常调度下一个任务
 *  2.被其他优先级更高的任务抢占
 *  3.执行任务碰到IO阻塞，调度器挂起当前任务，切换执行下一个任务
 *  4.用户代码主动挂起当前任务让出CPU时间
 *  5.多任务抢占资源，由于没有抢到被挂起
 *  6.硬件中断

### **如何减少上下文切换** ###

既然上下文切换会导致额外的开销，因此减少上下文切换次数便可以提高多线程程序的运行效率。减少上下文切换的方法有无锁并发编程、CAS算法、使用最少线程和使用协程。

*  **无锁并发编程**。多线程竞争时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的ID按照Hash取模分段，不同的线程处理不同段的数据
 *  **CAS算法**。Java的Atomic包使用CAS算法来更新数据，而不需要加锁
 *  **使用最少线程**。避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这样会造成大量线程都处于等待状态
 *  **协程**。在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换