资讯专栏INFORMATION COLUMN

从Java视角理解系统结构 (一) CPU上下文切换

yuxue / 2184人阅读

摘要:本文是从视角理解系统结构连载文章在高性能编程时经常接触到多线程起初我们的理解是多个线程并行地执行总比单个线程要快就像多个人一起干活总比一个人干要快然而实际情况是多线程之间需要竞争设备或者竞争锁资源,导致往往执行速度还不如单个线程在这里有一个

本文是从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]  )       = 0
[pid  5969] futex(0x9571ad4, FUTEX_WAIT_PRIVATE, 949, NULL
[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}
[pid  5969]  )       = 0
[pid  5968]  )       = 1
[pid  5969] futex(0x9571628, FUTEX_WAIT_PRIVATE, 2, NULL

果然还是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的博文再说 :)。

by Minzhou via ifeve

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/64053.html

相关文章

  • Java编程思想之多线程(

    摘要:多线程技术是个很庞大的课题,编程思想这本书英文版,以下简称中也用了页介绍的多线程体系。一个线程归属于唯一的进程,线程无法脱离进程而存在。五线程内数据线程的私有数据仅归属于一个线程,不在线程之间共享,例如,,。 多线程技术是个很庞大的课题,《Java编程思想》这本书(英文版,以下简称TIJ)中也用了136页介绍Java的多线程体系。的确,Java语言发展到今天,多线程机制相比其他的语言从...

    taohonghui 评论0 收藏0
  • 三年半Java后端面试经历

    摘要:经过半年的沉淀,加上对,和分布式这块的补齐,终于开始重拾面试信心,再次出征。面试官提示没有提到线程的有内核态的切换,程只在用户态调度。三面综合技术面这面面的是阵脚大乱,面试官采用刨根问底的方式提问,终究是面试经验不够,导致面试的节奏有点乱。 经过半年的沉淀,加上对MySQL,redis和分布式这块的补齐,终于开始重拾面试信心,再次出征。 鹅厂 面试职位:go后端开发工程师,接受从Jav...

    kviccn 评论0 收藏0
  • Java视角理解系统结构(二)CPU缓存

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

    eternalshallow 评论0 收藏0
  • Java视角理解系统结构(三)伪共享

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

    asce1885 评论0 收藏0
  • 【Go语言学习】2019-04-24 协程初步讨论与简单扩展

    摘要:它避免了上下文切换的额外耗费,兼顾了多线程的优点,简化了高并发程序的复杂。而可以理解为一种语言的协程。线程轻量级进程,,是程序执行流的最小单元。一个标准的线程由线程,当前指令指针,寄存器集合和堆栈组成。其实就是或者等语言中的多线程开发。 grape 全部视频:https://segmentfault.com/a/11... 原视频地址:https://biglive.xueersi.c...

    SnaiLiu 评论0 收藏0

发表评论

0条评论

yuxue

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<