从Java视角理解CPU上下文切换(Context Switch)

标签： 未分类 | 发表时间：2012-05-07 10:59 | 作者：zhouchen
出处：http://rdc.taobao.com/team/jm
从Java视角理解系统结构连载, 关注我的微博( 链接)了解最新动态在高性能编程时,经常接触到多线程. 起初我们的理解是, 多个线程并行地执行总比单个线程要快, 就像多个人一起干活总比一个人干要快. 然而实际情况是, 多线程之间需要竞争IO设备, 或者竞争锁资源，导致往往执行速度还不如单个线程. 在这里有一个经常提及的概念就是: 上下文切换(Context Switch).

上下文切换的精确定义可以参考: http://www.linfo.org/context_switch.html. 下面做个简单的介绍. 多任务系统往往需要同时执行多道作业.作业数往往大于机器的CPU数, 然而一颗CPU同时只能执行一项任务, 如何让用户感觉这些任务正在同时进行呢? 操作系统的设计者巧妙地利用了时间片轮转的方式, CPU给每个任务都服务一定的时间, 然后把当前任务的状态保存下来, 在加载下一任务的状态后, 继续服务下一任务. 任务的状态保存及再加载, 这段过程就叫做上下文切换. 时间片轮转的方式使多个任务在同一颗CPU上执行变成了可能, 但同时也带来了保存现场和加载现场的直接消耗.

(Note. 更精确地说, 上下文切换会带来直接和间接两种因素影响程序性能的消耗. 直接消耗包括: CPU寄存器需要保存和加载, 系统调度器的代码需要执行, TLB实例需要重新加载, CPU 的pipeline需要刷掉; 间接消耗指的是多核的cache之间得共享数据, 间接消耗对于程序的影响要看线程工作区操作数据的大小).

在linux中可以使用vmstat观察上下文切换的次数. 执行命令如下:

Shell代码 
  1. $ vmstat 1  
  2. procs ———–memory———- —swap– —–io—- -system– —-cpu—-  
  3.  r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa  
  4.  1  0      0 4593944 453560 1118192    0    0    14    12  238   30  6  1 92  1  
  5.  0  0      0 4593212 453568 1118816    0    0     0    96  958 1108  4  1 94  2  
  6.  0  0      0 4593360 453568 1118456    0    0     0     0  895 1044  3  1 95  0  
  7.  1  0      0 4593408 453568 1118456    0    0     0     0  929 1073  4  1 95  0  
  8.  0  0      0 4593496 453568 1118456    0    0     0     0 1133 1363  6  1 93  0  
  9.  0  0      0 4593568 453568 1118476    0    0     0     0  992 1190  4  1 95  0  

  
vmstat 1指每秒统计一次, 其中cs列就是指上下文切换的数目. 一般情况下, 空闲系统的上下文切换每秒大概在1500以下.

  
对于我们经常使用的抢占式操作系统来说, 引起上下文切换的原因大概有以下几种: 1. 当前执行任务的时间片用完之后, 系统CPU正常调度下一个任务 2. 当前执行任务碰到IO阻塞, 调度器将挂起此任务, 继续下一任务 3. 多个任务抢占锁资源, 当前任务没有抢到,被调度器挂起, 继续下一任务 4. 用户代码挂起当前任务, 让出CPU时间 5. 硬件中断. 前段时间发现有人在使用futex的WAIT和WAKE来测试context switch的直接消耗(   链接), 也有人使用阻塞IO来测试context switch的消耗(   链接).那么Java程序怎么测试和观察上下文切换的消耗呢?

  
我做了一个小实验, 代码很简单, 有两个工作线程. 开始时，第一个线程挂起自己; 第二个线程唤醒第一个线程，再挂起自己; 第一个线程醒来之后唤醒第二个线程, 再挂起自己. 就这样一来一往,互相唤醒对方, 挂起自己. 代码如下:

  

   

    
Java代码



   
    
    
  1. import java.util.concurrent.atomic.AtomicReference;  
    2. 
    
  2. import java.util.concurrent.locks.LockSupport;  
    3. 
    
  3.   
    4. 
    
  4. public final class ContextSwitchTest {  
    5. 
    
  5.     static final int RUNS = 3;  
    6. 
    
  6.     static final int ITERATES = 1000000;  
    7. 
    
  7.     static AtomicReference turn = new AtomicReference();  
    8. 
    
  8.   
    9. 
    
  9.     static final class WorkerThread extends Thread {  
    10. 
    
  10.         volatile Thread other;  
    11. 
    
  11.         volatile int nparks;  
    12. 
    
  12.   
    13. 
    
  13.         public void run() {  
    14. 
    
  14.             final AtomicReference t = turn;  
    15. 
    
  15.             final Thread other = this.other;  
    16. 
    
  16.             if (turn == null || other == null)  
    17. 
    
  17.                 throw new NullPointerException();  
    18. 
    
  18.             int p = 0;  
    19. 
    
  19.             for (int i = 0; i < ITERATES; ++i) {  
    20. 
    
  20.                 while (!t.compareAndSet(other, this)) {  
    21. 
    
  21.                     LockSupport.park();  
    22. 
    
  22.                     ++p;  
    23. 
    
  23.                 }  
    24. 
    
  24.                 LockSupport.unpark(other);  
    25. 
    
  25.             }  
    26. 
    
  26.             LockSupport.unpark(other);  
    27. 
    
  27.             nparks = p;  
    28. 
    
  28.             System.out.println(“parks: ” + p);  
    29. 
    
  29.   
    30. 
    
  30.         }  
    31. 
    
  31.     }  
    32. 
    
  32.   
    33. 
    
  33.     static void test() throws Exception {  
    34. 
    
  34.         WorkerThread a = new WorkerThread();  
    35. 
    
  35.         WorkerThread b = new WorkerThread();  
    36. 
    
  36.         a.other = b;  
    37. 
    
  37.         b.other = a;  
    38. 
    
  38.         turn.set(a);  
    39. 
    
  39.         long startTime = System.nanoTime();  
    40. 
    
  40.         a.start();  
    41. 
    
  41.         b.start();  
    42. 
    
  42.         a.join();  
    43. 
    
  43.         b.join();  
    44. 
    
  44.         long endTime = System.nanoTime();  
    45. 
    
  45.         int parkNum = a.nparks + b.nparks;  
    46. 
    
  46.         System.out.println(“Average time: ” + ((endTime - startTime) / parkNum)  
    47. 
    
  47.                 + “ns”);  
    48. 
    
  48.     }  
    49. 
    
  49.   
    50. 
    
  50.     public static void main(String[] args) throws Exception {  
    51. 
    
  51.         for (int i = 0; i < RUNS; i++) {  
    52. 
    
  52.             test();  
    53. 
    
  53.         }  
    54. 
    
  54.     }  
    55. 
    
  55. }  
    56. 




  

  
编译后,在我自己的笔记本上( Intel(R) Core(TM) i5 CPU M 460  @ 2.53GHz, 2 core, 3M L3 Cache) 用测试几轮，结果如下:

  

   

    
Shell代码



   
    
    
  1. java -cp . ContextSwitchTest  
    2. 
    
  2. parks: 953495  
    3. 
    
  3. parks: 953485  
    4. 
    
  4. Average time: 11373ns  
    5. 
    
  5. parks: 936305  
    6. 
    
  6. parks: 936302  
    7. 
    
  7. Average time: 11975ns  
    8. 
    
  8. parks: 965563  
    9. 
    
  9. parks: 965560  
    10. 
    
  10. Average time: 13261ns  
    11. 




  

  
我们会发现这么简单的for循环, 线性执行会非常快,不需要1秒, 而执行这段程序需要几十秒的耗时. 每个上下文切换需要耗去十几us的时间,这对于程序吞吐量的影响很大.

  
同时我们可以执行vmstat 1 观查一下上下文切换的频率是否变快

  

   

    
Shell代码



   
    
    
  1. $ vmstat 1  
    2. 
    
  2. procs ———–memory———- —swap– —–io—- -system– —-cpu—-  
    3. 
    
  3.  r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa  
    4. 
    
  4.  1  0      0 4424988 457964 1154912    0    0    13    12  252   80  6  1 92  1  
    5. 
    
  5.  0  0      0 4420452 457964 1159900    0    0     0     0 1586 2069  6  1 93  0  
    6. 
    
  6.  1  0      0 4407676 457964 1171552    0    0     0     0 1436 1883  8  3 89  0  
    7. 
    
  7.  1  0      0 4402916 457964 1172032    0    0     0    84 22982 45792  9  4 85  2  
    8. 
    
  8.  1  0      0 4416024 457964 1158912    0    0     0     0 95382 198544 17 10 73  0  
    9. 
    
  9.  1  1      0 4416096 457964 1158968    0    0     0   116 79973 159934 18  7 74  0  
    10. 
    
  10.  1  0      0 4420384 457964 1154776    0    0     0     0 96265 196076 15 10 74  1  
    11. 
    
  11.  1  0      0 4403012 457972 1171096    0    0     0   152 104321 213537 20 12 66  2  
    12. 




  
再使用strace观察以上程序中Unsafe.park()究竟是哪道系统调用造成了上下文切换:

  

   

    
Shell代码



   
    
    
  1. $strace -f java -cp . ContextSwitchTest  
    2. 
    
  2. [pid  5969] futex(0x9571a9c, FUTEX_WAKE_OP_PRIVATE, 1, 1, 0x9571a98, {FUTEX_OP_SET, 0, FUTEX_OP_CMP_GT, 1}) = 1  
    3. 
    
  3. [pid  5968] <… futex resumed> )       = 0  
    4. 
    
  4. [pid  5969] futex(0x9571ad4, FUTEX_WAIT_PRIVATE, 949, NULL <unfinished …>  
    5. 
    
  5. [pid  5968] futex(0×9564368, FUTEX_WAKE_PRIVATE, 1) = 0  
    6. 
    
  6. [pid  5968] futex(0x9571ad4, FUTEX_WAKE_OP_PRIVATE, 1, 1, 0x9571ad0, {FUTEX_OP_SET, 0, FUTEX_OP_CMP_GT, 1} <unfinished …>  
    7. 
    
  7. [pid  5969] <… futex resumed> )       = 0  
    8. 
    
  8. [pid  5968] <… futex resumed> )       = 1  
    9. 
    
  9. [pid  5969] futex(0×9571628, FUTEX_WAIT_PRIVATE, 2, NULL <unfinished …>  
    10. 




  
果然还是futex.

  
再使用perf看看上下文对于Cache的影响:

  

   

    
Shell代码



   
    
    
  1. $ perf stat -e cache-misses   java -cp . ContextSwitchTest  
    2. 
    
  2. parks: 999999  
    3. 
    
  3. parks: 1000000  
    4. 
    
  4. Average time: 16201ns  
    5. 
    
  5. parks: 998930  
    6. 
    
  6. parks: 998926  
    7. 
    
  7. Average time: 14426ns  
    8. 
    
  8. parks: 998034  
    9. 
    
  9. parks: 998204  
    10. 
    
  10. Average time: 14489ns  
    11. 
    
  11.   
    12. 
    
  12.  Performance counter stats for ‘java -cp . ContextSwitchTest’:  
    13. 
    
  13.   
    14. 
    
  14.          2,550,605 cache-misses                                                  
    15. 
    
  15.   
    16. 
    
  16.       90.221827008 seconds time elapsed  
    17. 




  
1分半钟内有255万多次cache未命中.

  
嗯, 貌似太长了, 可以结束了. 接下来会继续几篇博文继续分析一些有意思的东西.

  
(1) 从Java视角看内存屏障 (Memory Barrier)

  
(2) 从java视角看CPU亲缘性 (CPU Affinity)

  
等..敬请关注

  
PS. 其实还做了一个实验, 测试CPU Affinity对于Context Switch的影响.

  

   

    
Shell代码



   
    
    
  1. $ taskset -c 0 java -cp . ContextSwitchTest  
    2. 
    
  2. parks: 992713  
    3. 
    
  3. parks: 1000000  
    4. 
    
  4. Average time: 2169ns  
    5. 
    
  5. parks: 978428  
    6. 
    
  6. parks: 1000000  
    7. 
    
  7. Average time: 2196ns  
    8. 
    
  8. parks: 989897  
    9. 
    
  9. parks: 1000000  
    10. 
    
  10. Average time: 2214ns  
    11. 




  
这个命令把进程绑定在0号CPU上,结果Context Switch的消耗小了一个数量级, 什么原因呢? 卖个关子, 在谈到CPU Affinity的博文再说




相关 [java 视角 理解] 推荐：
从Java视角理解伪共享(False Sharing)

-  - 淘宝网通用产品团队博客

从Java视角理解系统结构连载, 关注我的微博(  链接)了解最新动态从我的  前一篇博文中, 我们知道了CPU缓存及缓存行的概念, 同时用一个例子说明了编写单线程Java代码时应该注意的问题. 下面我们讨论更为复杂, 而且更符合现实情况的多核编程时将会碰到的问题. 这些问题更容易犯, 连j.u.c包作者Doug Lea大师的JDK代码里也存在这些问题. 
从Java视角理解CPU缓存(CPU Cache)

-  - 淘宝网通用产品团队博客

从Java视角理解系统结构连载, 关注我的微博(  链接)了解最新动态众所周知, CPU是计算机的大脑, 它负责执行程序的指令; 内存负责存数据, 包括程序自身数据. 同样大家都知道, 内存比CPU慢很多. 其实在30年前, CPU的频率和内存总线的频率在同一个级别, 访问内存只比访问CPU寄存器慢一点儿. 
从Java视角理解CPU上下文切换(Context Switch)

-  - 淘宝网通用产品团队博客

从Java视角理解系统结构连载, 关注我的微博(  链接)了解最新动态在高性能编程时,经常接触到多线程. 起初我们的理解是, 多个线程并行地执行总比单个线程要快, 就像多个人一起干活总比一个人干要快. 然而实际情况是, 多线程之间需要竞争IO设备, 或者竞争锁资源，导致往往执行速度还不如单个线程. 在这里有一个经常提及的概念就是: 上下文切换(Context Switch). 
Java基础—ClassLoader的理解

-  - ZJD'S NOTES

} 
```
其余两个ClassLoader都是继承自`ClassLoader`这个类. Java的类加载采用了一种叫做“双亲委托”的方式（稍后解释），所以除了`Bootstarp ClassLoader`其余的ClassLoader都有一个“父”类加载器， 不是通过集成，而是一种包含的关系. ```
##“双亲委托”
所谓“双亲委托”就是当加载一个类的时候会先委托给父类加载器去加载，当父类加载器无法加载的时候再尝试自己去加载，所以整个类的加载是“自上而下”的，如果都没有加载到则抛出`ClassNotFoundException`异常. 
JAVA基础之理解JNI原理

- shuangxi - 博客园-首页原创精华区

JNI是JAVA标准平台中的一个重要功能，它弥补了JAVA的与平台无关这一重大优点的不足，在JAVA实现跨平台的同时，也能与其它语言（如C、C++）的动态库进行交互，给其它语言发挥优势的机会. 有了JAVA标准平台的支持，使JNI模式更加易于实现和使用. 环境说明：ubuntu 10.4.2 LTS系统. 
深入理解Java：内省(Introspector)

-  - 博客园_首页

　　内省(Introspector) 是Java 语言对 JavaBean 类属性、事件的一种缺省处理方法. 　　JavaBean是一种特殊的类，主要用于传递数据信息，这种类中的方法主要用于访问私有的字段，且方法名符合某种命名规则. 如果在两个模块之间传递信息，可以将信息封装进JavaBean中，这种对象称为“值对象”(Value Object)，或“VO”. 
理解Java对象序列化

-  - 博客 - 伯乐在线

来源：  jiangshapub 的博客（  @jiangshapub）. 关于Java序列化的文章早已是汗牛充栋了，本文是对我个人过往学习，理解及应用Java序列化的一个总结. 此文内容涉及Java序列化的基本原理，以及多种方法对序列化形式进行定制. 在撰写本文时，既参考了  Thinking in Java,   Effective Java，JavaWorld，developerWorks中的相关文章和其它网络资料，也加入了自己的实践经验与理解，文、码并茂，希望对大家有所帮助. 
Java序列化理解与总结

-  - CSDN博客编程语言推荐文章

Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长. 但在现实应用中，就可能要求在JVM停止运行之后能够保存指定的对象，并在将来重新读取被保存的对象. Java对象序列化就能够帮助我们实现该功能. 
理解Java虚拟机体系结构

-  - ImportNew

众所周知，Java支持平台无关性、安全性和网络移动性. 而Java平台由Java虚拟机和Java核心类所构成，它为纯Java程序提供了统一的编程接口，而不管下层操作系统是什么. 正是得益于Java虚拟机，它号称的“一次编译，到处运行”才能有所保障. 1.1 Java程序执行流程. Java程序的执行依赖于编译环境和运行环境.