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

从Java视角理解系统结构连载, 关注我的微博(链接)了解最新动态

在高性能编程时,经常接触到多线程. 起初我们的理解是, 多个线程并行地执行总比单个线程要快, 就像多个人一起干活总比一个人干要快. 然而实际情况是, 多线程之间需要竞争IO设备, 或者竞争锁资源，导致往往执行速度还不如单个线程. 在这里有一个经常提及的概念就是: 上下文切换(Context Switch).

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


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

$ vmstat 1
procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa
 1  0      0 4593944 453560 1118192    0    0    14    12  238   30  6  1 92  1
 0  0      0 4593212 453568 1118816    0    0     0    96  958 1108  4  1 94  2
 0  0      0 4593360 453568 1118456    0    0     0     0  895 1044  3  1 95  0
 1  0      0 4593408 453568 1118456    0    0     0     0  929 1073  4  1 95  0
 0  0      0 4593496 453568 1118456    0    0     0     0 1133 1363  6  1 93  0
 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程序怎么测试和观察上下文切换的消耗呢?

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

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

public final class ContextSwitchTest {
	static final int RUNS = 3;
	static final int ITERATES = 1000000;
	static AtomicReference turn = new AtomicReference();

	static final class WorkerThread extends Thread {
		volatile Thread other;
		volatile int nparks;

		public void run() {
			final AtomicReference t = turn;
			final Thread other = this.other;
			if (turn == null || other == null)
				throw new NullPointerException();
			int p = 0;
			for (int i = 0; i < ITERATES; ++i) {
				while (!t.compareAndSet(other, this)) {
					LockSupport.park();
					++p;
				}
				LockSupport.unpark(other);
			}
			LockSupport.unpark(other);
			nparks = p;
			System.out.println("parks: " + p);

		}
	}

	static void test() throws Exception {
		WorkerThread a = new WorkerThread();
		WorkerThread b = new WorkerThread();
		a.other = b;
		b.other = a;
		turn.set(a);
		long startTime = System.nanoTime();
		a.start();
		b.start();
		a.join();
		b.join();
		long endTime = System.nanoTime();
		int parkNum = a.nparks + b.nparks;
		System.out.println("Average time: " + ((endTime - startTime) / parkNum)
				+ "ns");
	}

	public static void main(String[] args) throws Exception {
		for (int i = 0; i < RUNS; i++) {
			test();
		}
	}
}

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

java -cp . ContextSwitchTest
parks: 953495
parks: 953485
Average time: 11373ns
parks: 936305
parks: 936302
Average time: 11975ns
parks: 965563
parks: 965560
Average time: 13261ns

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

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

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

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

$strace -f java -cp . ContextSwitchTest
[pid  5969] futex(0x9571a9c, FUTEX_WAKE_OP_PRIVATE, 1, 1, 0x9571a98, {FUTEX_OP_SET, 0, FUTEX_OP_CMP_GT, 1}) = 1
[pid  5968] <... futex resumed> )       = 0
[pid  5969] futex(0x9571ad4, FUTEX_WAIT_PRIVATE, 949, NULL <unfinished ...>
[pid  5968] futex(0x9564368, FUTEX_WAKE_PRIVATE, 1) = 0
[pid  5968] futex(0x9571ad4, FUTEX_WAKE_OP_PRIVATE, 1, 1, 0x9571ad0, {FUTEX_OP_SET, 0, FUTEX_OP_CMP_GT, 1} <unfinished ...>
[pid  5969] <... futex resumed> )       = 0
[pid  5968] <... futex resumed> )       = 1
[pid  5969] futex(0x9571628, FUTEX_WAIT_PRIVATE, 2, NULL <unfinished ...>

果然还是futex.

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

$ perf stat -e cache-misses   java -cp . ContextSwitchTest
parks: 999999
parks: 1000000
Average time: 16201ns
parks: 998930
parks: 998926
Average time: 14426ns
parks: 998034
parks: 998204
Average time: 14489ns

 Performance counter stats for 'java -cp . ContextSwitchTest':

         2,550,605 cache-misses                                                

      90.221827008 seconds time elapsed

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

嗯, 貌似太长了, 可以结束了. 接下来会继续几篇博文继续分析一些有意思的东西.
(1) 从Java视角看内存屏障 (Memory Barrier)
(2) 从java视角看CPU亲缘性 (CPU Affinity)
等..敬请关注


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

$ taskset -c 0 java -cp . ContextSwitchTest
parks: 992713
parks: 1000000
Average time: 2169ns
parks: 978428
parks: 1000000
Average time: 2196ns
parks: 989897
parks: 1000000
Average time: 2214ns

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

评论

15 楼 thebye85 2014-12-17  

请教下大神，为什么频繁的park会导致大量context switch，难道park/unpark会强制cpu切换任务吗？

14 楼 sunmenggmail 2013-11-15  

对于文末的问题，为什么在绑定了cpu之后，context switch的消耗还更少了？
我的想法是，比如是两个核，第一个核上的线程堵塞了，然后上下文就缓存在第一个核的缓存中；接着，第二个核的线程堵塞了，然后，由第二个核运行第一个核的线程，那么首先就要先读取第一个核上缓存的上下文信息。如此，每次都可能需要跨核读取缓存，所以context switch的消耗肯定要比这两个线程在一个核上跑的

13 楼 lovegq 2013-02-24  

请教个问题, 关于切换的 那副图片 是楼主原创的,还是其他资料里的,想看看原始的文档。

12 楼 fh63045 2012-10-31  

求问: 这么绑定到指定CPU执行?

11 楼 coderplay 2012-04-25  

fuyou001 写道

绑定到特定的cpu 与不绑定cpu cache-misses相差不大

能告诉我你的CPU型号吗?

10 楼 fuyou001 2012-04-25  

绑定到特定的cpu 与不绑定cpu cache-misses相差不大:

yubaofu@java$perf stat -e cache-misses java -cp . ContextSwitchTest
parks: 990309
parks: 989792
Average time: 6750ns
parks: 1000000
parks: 1000001
Average time: 6030ns
parks: 998608
parks: 998506
Average time: 6320ns

 Performance counter stats for 'java -cp . ContextSwitchTest':

           889,137 cache-misses                                                

      38.123576396 seconds time elapsed

yubaofu@java$taskset -c 0 perf stat -e cache-misses java -cp . ContextSwitchTest 
parks: 996891
parks: 992637
Average time: 1832ns
parks: 997725
parks: 981451
Average time: 1855ns
parks: 990237
parks: 1000001
Average time: 1791ns

 Performance counter stats for 'java -cp . ContextSwitchTest':

           735,660 cache-misses                                                

      10.929714636 seconds time elapsed

绑定到特定的cpu 与不绑定cpu context-switch 相差也不大

yubaofu@java$taskset -c 0 perf stat -e cs java -cp . ContextSwitchTest
parks: 996667
parks: 996658
Average time: 1921ns
parks: 997488
parks: 979789
Average time: 1927ns
parks: 987008
parks: 1000001
Average time: 1871ns

 Performance counter stats for 'java -cp . ContextSwitchTest':

         6,102,090 cs                                                          

      11.402238007 seconds time elapsed

yubaofu@java$perf stat -e cs java -cp . ContextSwitchTest
parks: 949590
parks: 949608
Average time: 5680ns
parks: 956224
parks: 955899
Average time: 5581ns
parks: 941611
parks: 942028
Average time: 5578ns

 Performance counter stats for 'java -cp . ContextSwitchTest':

         5,708,444 cs                                                          

      32.024738227 seconds time elapsed

9 楼 rain2005 2012-04-16  

mineral 写道

请教一个问题，tomcat的线程池设置大小，需要用什么工具/方法来确定最优化的数值，达到最少context switch？

对于访问数据库的应用来说，根据context switch来判断线程数太不科学了，一般动态内容线程数要大点100到150左右。，静态内容单线程

8 楼 coderplay 2012-04-15  

任何系统调用都会被统计为一次软中断, 这个完全正确. LockSupport.unpark()不一定调用了futex系统调用, 有可能一直在用户态. 我刚才strace了我的Westmere机器, 几乎没有看到futex系统调用, vmstat 1和刚才回复的一样; 但i5的机器却是有很多futex系统调用.
看样子我的理解还有些问题, 得查查jvm和pthread代码.

7 楼 zldeng1984 2012-04-15  

我和你i5的机器结果类似，interrupt的效果是这样的（部分）：

256:  560188959          0          0          0     Dynamic-irq  timer0
257:   12289018          0          0          0     Dynamic-irq  resched0
258:         30          0          0          0     Dynamic-irq  callfunc0

观察了下和resched基本成正比。

不过估计我有一个误区，我以前以为linux的系统调用是通过软中断触发的，所以任何系统调用都会被统计为一次软中断，现在看来理解有问题。这里能帮忙科普下么？

6 楼 coderplay 2012-04-15  

zldeng1984 写道

请教下上面例子中vmstat的in和cs为什么是一个大概1：2的关系，一次futex系统调用导致一次软中断和一次上下文切换为什么不是1：1？

futex本身不造成软中断, 示例的测试是在我本子上的i5 M460. 引起中断的原因有可能是因为程序导致Rescheduling interrupts. 通过命令看到Rescheduling interrupt变化比较和程序context switch貌似成正比, 具体原因还需要调查.

 
$ watch -n 1 cat /proc/interrupts
           CPU0       CPU1       CPU2       CPU3       
  0:         43         12          4          2   IO-APIC-edge      timer
  1:         10          8       8112        996   IO-APIC-edge      i8042
  8:          0          1          0          0   IO-APIC-edge      rtc0
  9:       4397        175        162        165   IO-APIC-fasteoi   acpi
12:       2772        624        618        617   IO-APIC-edge      i8042
16:       2774         26         18         15   IO-APIC-fasteoi   mei
19:      80883         18         97         74   IO-APIC-fasteoi   ehci_hcd:usb2, ips
23:         56         58         61         64   IO-APIC-fasteoi   ehci_hcd:usb1
40:          4       2807          2          1   PCI-MSI-edge      eth0
41:     103696     109390       1288       1298   PCI-MSI-edge      ahci
42:     243335        163        186        173   PCI-MSI-edge      iwlagn
43:     113608     214462       5338       3386   PCI-MSI-edge      i915
44:         48         50         49         50   PCI-MSI-edge      hda_intel
NMI:          0          0          0          0   Non-maskable interrupts
LOC:    1286586    1178311     666412     660720   Local timer interrupts
SPU:          0          0          0          0   Spurious interrupts
PMI:          0          0          0          0   Performance monitoring interrupts
IWI:          0          0          0          0   IRQ work interrupts
RES:    2231272    2272751    4771974    4726837   Rescheduling interrupts
CAL:       2773       2443       7234       8466   Function call interrupts
TLB:      16529      17714      16475      11142   TLB shootdowns
TRM:          0          0          0          0   Thermal event interrupts
THR:          0          0          0          0   Threshold APIC interrupts
MCE:          0          0          0          0   Machine check exceptions
MCP:         20         20         20         20   Machine check polls

另外我在一台 Westmere机器上测试同样的程序,是不会造成中断的.

$ vmstat 1
procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu------
r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
1  0    368 169140 2005776 21162064    0    0     0     2    0    0  0  0 100  0  0
1  0    368 169140 2005776 21162072    0    0     0    24 1023 290984  2  4 95  0  0
1  0    368 169140 2005776 21162072    0    0     0   144 1024 295536  1  3 95  0  0
1  0    368 169140 2005780 21162072    0    0     0    84 1030 344833  2  4 95  0  0
1  0    368 169140 2005780 21162072    0    0     0    64 1022 302313  2  4 95  0  0
2  0    368 169140 2005780 21162072    0    0     0    88 1027 299323  1  4 95  0  0

不知道你那儿情况如何?

5 楼 zldeng1984 2012-04-15  

请教下上面例子中vmstat的in和cs为什么是一个大概1：2的关系，一次futex系统调用导致一次软中断和一次上下文切换为什么不是1：1？

4 楼 coderplay 2012-04-15  

wang_scu 写道

很期待内存屏障的讲解 有个问题请教一下  用volatile字段来保证写线程在volatile写操作之前的数据能被读线程在读volatile后看到  这样的方法来跨越内存屏障 volatile 如果常常修改会有啥后果?

后面会详细说到volatile与memory barrier之间的关系, 使用volatile不管有没有冲突都会比线性执行普通变量的操作要慢10多倍, 同时还很有可能会引起false sharing.

3 楼 coderplay 2012-04-15  

mineral 写道

请教一个问题，tomcat的线程池设置大小，需要用什么工具/方法来确定最优化的数值，达到最少context switch？

sorry,我没从事过web开发, 没用过tomcat, 所以.... 我一般是使用vmstat, perf和Intel Vtune这几种工具发现问题, 然后再查看源码.

2 楼 wang_scu 2012-04-15  

很期待内存屏障的讲解 有个问题请教一下  用volatile字段来保证写线程在volatile写操作之前的数据能被读线程在读volatile后看到  这样的方法来跨越内存屏障 volatile 如果常常修改会有啥后果?

1 楼 mineral 2012-04-14  

请教一个问题，tomcat的线程池设置大小，需要用什么工具/方法来确定最优化的数值，达到最少context switch？