<p>本文首先介绍了一些线程基础，比如并发、并行、内存分配、系统调用、POSIX线程。接着通过strace分析了线程与进程的区别。最后以Android、Golang等线程模型进行了分析。</p>    <h2>基础</h2>    <h3>1. 什么是并发(Concurrent)，什么是并行(Parallels)？</h3>    <p>并发指同时进行多个计算任务。</p>    <p><img src="http://static.open-open.com/lib/uploadImg/20160624/20160624094214_933.svg"></p>    <p> </p>    <p>并行指通过切换时间片模拟进行多个计算任务。</p>    <p><img src="http://static.open-open.com/lib/uploadImg/20160624/20160624094215_224.svg"></p>    <p> </p>    <blockquote>     <p>详细可以参考<a href="/misc/goto?guid=4959674789586747541">Difference between concurrent programming and parallel programming - stackoverflow</a></p>    </blockquote>    <h3>2. OS下的内存分配、用户区与内核区</h3>    <p>在32位的Linux操作系统中，当一个进程启动后，将被分配4G的虚拟内存。内存可以分为两个空间，一个是用户空间（0～3G），另一个是内核空间（3G～4G）。其中用户空间就是代码运行的空间，比如堆栈、BSS（未初始化数据段）、DATA（已经初始化数据段）、TEXT（代码二进制段）；而在内核空间中，是OS内核的映射，只有在执行syscall系统调用时，才能进行重写。</p>    <p><img alt="线程模型的综述" src="https://simg.open-open.com/show/a1dd65185ea08011df8bbfad6711faf8.jpg"></p>    <p>32 Bit OS Virtual Memory</p>    <p>在用户态中，执行用户代码，比如直接运行C程序、或者运行JVM虚拟机等。</p>    <p>在内核中，主要负责I/O(显示，层三以下的网络，FS)，Memory(虚拟内存，页面替换/缓存), Process（信号、线程/进程管理，CPU调度）的管理，直接控制CPU、内存等硬件，权限(privilege)非常大;</p>    <h3>3. 系统调用中断(SCI)</h3>    <p>系统调用是用户与内核间的一个桩(stub)，当在用户态执行高权限任务，需要通过系统调用切换入内核态去执行最底层任务。比如在C语言中调用<code>getTime()</code>时，大致流程如下</p>    <pre>  <code class="language-cpp">1. app method(User Application)      |      |调用stdlibc标准库      |  2. systemcall_stub(std libc)      |      |系统调用，进入内核态      |  3. system_call_table[call_number](Kernel)      |      |通过查表调用硬件函数      |  4. hardware_call(Kernel)</code></pre>    <ol>     <li>在App层面，开发者不需要自己写系统调用，系统会提供相关C标准库的SDK供开发者使用，比如开发者调用<code>getTime()</code>时，实际是使用了标准库的<code>time.h</code>头文件。</li>     <li>代码在执行时，OS自动加载标准库。比如在android的bionic库中，实际执行getTime的系统调用是<a href="/misc/goto?guid=4959674789675761653">这里</a>的平台相关的汇编代码，将系统调用的ID、参数传入内核。</li>     <li>内核通过系统调用ID进行表的索引，寻找真正的硬件调用函数</li>     <li>进行硬件相关的调用</li>    </ol>    <blockquote>     <p>在Mac下打开ActivityManager或者在Terminal中运行top，就可以显示地看到用户与系统的CPU占用</p>     <img alt="线程模型的综述" src="https://simg.open-open.com/show/3ed8868cc977deae91979a4112a8e10f.png">     <p>User and Kernel CPU usage</p>    </blockquote>    <h3>4. POSIX线程模型</h3>    <p>POSIX是IEEE P1003.1中的线程标准，目前所有的系统，甚至windows都支持POSIX。它提供了用户态下的线程编程接口，开发者在进行线程开发时，只用引用<code>pthread.h</code>头文件调用即可。程序在运行时通过系统调用，在内核中进行线程的实现。它有很多函数，比如create, exit, join, yield等，具体可以去各个平台下的libc源码/sdk中去看Header文件中方法的定义，比如android中使用biolibc中pthread.h的代码在<a href="/misc/goto?guid=4959674789757752425">这里</a>，这里的头文件是对内核线程的包装。</p>    <h2>线程与进程的区别</h2>    <p>以下特指32位下使用glibc的Linux系统中POSIX模型，即用户面模型</p>    <p>本测试基于Ubuntu 14.04 i386</p>    <h3>1. 测试代码设计</h3>    <p>1.1. 线程测试代码</p>    <pre>  <code class="language-cpp">//modified from https://computing.llnl.gov/tutorials/pthreads/samples/hello.c    //todo run:  //clang -Wall -g pthread.c -o pthread.out -lpthread  //strace -Cfo ./pthread.strace.log ./pthread.out    #include <stdio.h>  #include <stdlib.h>  #include <pthread.h>    void*  PrintHello(void *threadid)  {     long tid;     tid = (long)threadid;     printf("Hello World! It's me, thread #%ld!\n", tid);     pthread_exit(NULL);  }    int   main(int argc, char *argv[]){     pthread_t thread;     int rc = 0;     long t = 0;     printf("In main: creating thread %ld\n", t);     rc = pthread_create(&thread, NULL, PrintHello, (void *)t);     if (rc){       exit(-1);     }  }</code></pre>    <p>1.2. 进程测试代码</p>    <pre>  <code class="language-cpp">//todo run:  //clang -Wall -g fork.c -o fork.out  //strace -Cfo ./fork.strace.log ./fork.out    #include <unistd.h>    int   main(int argc, char *argv[])  {    pid_t pid;    pid = fork();    if(pid < 0){      return -1;    }        return 0;  }</code></pre>    <h3>2. 测试结果</h3>    <p>调用<code>strace</code>命令后，结果如下</p>    <p>2.1. 进程的strace路线如下</p>    <pre>  <code class="language-cpp">19948 execve("./fork.out", ["./fork.out"], [/* 68 vars */]) = 0  19948 brk(0)                            = 0x9bc000  19948 open("/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3  19948 read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\320\37\2\0\0\0\0\0"..., 832) = 832  .....  19948 clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f5adac4ca10) = 19949  ....  19949 +++ exited with 0 +++</code></pre>    <p>2.2. 线程的strace路线如下</p>    <pre>  <code class="language-cpp">21958 execve("./pthread.out", ["./pthread.out"], [/* 68 vars */]) = 0  21958 open("/lib/x86_64-linux-gnu/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3  ....  21958 access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)  21958 open("/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3  21958 read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\320\37\2\0\0\0\0\0"..., 832) = 832  21958 fstat(3, {st_mode=S_IFREG|0755, st_size=1845024, ...}) = 0  21958 mmap(NULL, 3953344, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f34229e4000  ....  21958 clone(child_stack=0x7f34229e2fb0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7f34229e39d0, tls=0x7f34229e3700, child_tidptr=0x7f34229e39d0) = 21959  ....  21958 +++ exited with 0 +++</code></pre>    <h3>3. 测试结论</h3>    <p>通过上述的调用栈分析，可以得知均是通过调用<code>x86_64-linux-gnu</code>下的libc库，接着通过systemcall函数<code>clone()</code>实现对内核Process的控制，主要区别在函数参数中FLAG上有所不同，clone_flag指定了可以共享的资源</p>    <pre>  <code class="language-cpp">//clone flag between thread and process  //⚠️: 省略了`CLONE_｀前缀    //进程的FLAG参数  flags=CHILD_CLEARTID|CHILD_SETTID|SIGCHLD    //线程的FLAG参数  flags=VM|FS|FILES|SIGHAND|THREAD|SYSVSEM|SETTLS|PARENT_SETTID|CHILD_CLEARTID</code></pre>    <p>通过对<code>clone</code>进行man<a href="/misc/goto?guid=4959674789838065675">查询</a>，</p>    <p>进程的参数解释：</p>    <ul>     <li><code>CLONE_CHILD_CLEARTID</code>: Erase child thread ID at location ctid in child memory when the child exits, and do a wakeup on the futex at that address。</li>     <li><code>CLONE_SETTLS</code>: thread local storage (TLS) area，注意这个不可移植</li>     <li><code>CLONE_SIGHAND</code>: 共享signal handlers</li>    </ul>    <p>线程的一些参数解释：</p>    <ul>     <li><code>CLONE_VM</code>: the calling process and the child process run in the same memory space. (注意这里说的是<code>memory space</code>，指通过mmap()分配的内存。再多说一点，线程中的栈内存由<code>pthread_attr_t</code>属性中的<code>pthread_attr_setstacksize</code>函数实现，默认可能为8MB，当然在实际中我们使用栈内存大多都是几KB而已；堆内存是共享的，这里不讨论)</li>     <li><code>CLONE_FS</code>: 共享文件系统，如下函数chroot(2), chdir(2), or umask(2)会被影响。</li>     <li><code>CLONE_FILES</code>: 共享file descriptor table</li>     <li><code>CLONE_SIGHAND</code>: 共享signal handlers</li>     <li><code>CLONE_THREAD</code>: 共享thread group，即有相同的PID，独立的TID；</li>     <li><code>CLONE_SYSVSEM</code>: 共享System V semaphore undo values列表，俺表示目前还不懂。</li>     <li><code>CLONE_SETTLS</code>: thread local storage (TLS) area，注意这个不可移植</li>     <li><code>CLONE_PARENT_SETTID</code>: Store child thread ID at location ptid in parent and child memory.</li>     <li><code>CLONE_CHILD_CLEARTID</code>: Erase child thread ID at location ctid in child memory when the child exits, and do a wakeup on the futex at that address。</li>    </ul>    <p>接着结合一些教科书，可以得知</p>    <table>     <thead>      <tr>       <th> </th>       <th>进程</th>       <th>线程</th>      </tr>     </thead>     <tbody>      <tr>       <td>用户层函数</td>       <td>fork()</td>       <td>pthread_create()</td>      </tr>      <tr>       <td>内核实现</td>       <td>clone()</td>       <td>clone()</td>      </tr>      <tr>       <td>内存</td>       <td>新复制的内存(Copy-on-Write)，独立4G(1G+3G)</td>       <td>共享4G内存：其中8M左右的栈内存是私有的，可以通过参数决定；共享堆内存</td>      </tr>      <tr>       <td>创建耗时</td>       <td>复制的flag少，所以耗时多</td>       <td>低</td>      </tr>      <tr>       <td>上下文切换耗时</td>       <td>switching the memory address</td>       <td>几乎只有进出内核的损失</td>      </tr>      <tr>       <td>内部通信</td>       <td>IPC</td>       <td>共享的内存区(更简单)</td>      </tr>     </tbody>    </table>    <h2>高级语言对内核线程的封装实现</h2>    <p>除了通过POSIX标准外，高级语言也可以自己通过系统调用对内核的线程进行实现，主要有如下三种。</p>    <h3>1. 纯内核线程实现(1:1)</h3>    <p>此线程模型将内核线程与App线程一一对应，可以看作为一种简单的映射关系，这里的代表有POSIX线程模型(pthread)，以及依赖pThread标准库的Java与Ruby(1.9+)线程模型。</p>    <p>以在Android/ArtJvm下创建线程为例，具体实现调用栈如下</p>    <pre>  <code class="language-cpp">java.lang.Thread      |  POSIX thread(user mode){      0. art.runtime.Thread::CreateNativeThread(cpp, in jvm)      1. pthread_create(pthread.h，标准库头文件)      2. bionic标准库下的so文件，进行SystemCall(libc)      3. 用户态陷入内核态  }      |  Kernal thread(kernal mode)</code></pre>    <p>可以看出，在JVM下的实现主要是对POSIX线程的包装与映射，自己本身只是做了点微小的工作，特点如下：</p>    <ol>     <li>移植性较差，需要适配各种libc库，但是由于被OS直接管理，因此在分配任务上可以充分借用内核的高效调度，能够高效利用物理核并实现真正的并行。</li>     <li>用户态与内核态切换有一定的消耗损失</li>    </ol>    <h3>2. 纯用户态实现(1:N)</h3>    <p>将线程的调度在用户态实现，也称<code>green thread</code>，自己写调度算法，可以将一个native线程映射为多个app thread(这里也可以叫做线程包)，这里的代表有Ruby(1.8-)，Java等老版本，特点如下：</p>    <ol>     <li>移植性好，没有切换、映射到内核的损失</li>     <li>需要自己维护Scheduler</li>     <li>由于内核并不了解调度细节，很难进行多核利用</li>    </ol>    <h3>3. 混合实现(M:N)</h3>    <p>可以同时运行M个kernel线程下管理N个app线程，比如golang。通过设置<code>GOMAXPROCS</code>个native线程，然后通过<code>go</code>关键词创建app线程，它的特点如下：</p>    <ol>     <li>调度器实现比较困难</li>     <li>通过语法糖与管道简化了并发编程，切换损失低</li>     <li>部分调度需要自己主动释放时间片</li>    </ol>    <pre>  <code class="language-cpp">golang threading model(N)      ↓      ↓ goroutine      ↓  Kernal thread model(M)</code></pre>    <blockquote>     <p>详见<a href="/misc/goto?guid=4959674789974247285">libtask</a>与许式伟的《go语言编程》</p>    </blockquote>    <h2>总结</h2>    <ol>     <li>Concurrent是多个任务同时进行，而Parallels是分享时间片</li>     <li>在启动一个程序后，将分配用户态与内核态任务，通过系统调用执行内核中的高权限任务</li>     <li>POSIX是一种线程标准，或者是一种接口，由libc库实现</li>     <li>线程与进程最大的区别在于<code>clone</code>操作时的flag不同，导致共享资源不同。最终创建、切换耗时不同；以及内存分配、内部通信复杂度不同。</li>     <li>在Java中，<code>java.lang.Thread</code>与内核线程一一对应；在某些旧版语言中，实现了一个内核线程对应多个高层线程；在golang中，通过<code>goroutine</code>实现M个内核线程对应N个高层线程；</li>    </ol>    <h2>Ref</h2>    <ol>     <li><a href="/misc/goto?guid=4959674790048349009">https://www.zhihu.com/question/21461752</a></li>     <li><a href="/misc/goto?guid=4959674790131138565">https://blog.codinghorror.com/understanding-user-and-kernel-mode/</a></li>     <li><a href="/misc/goto?guid=4959674790209202714">http://stackoverflow.com/questions/1311402/differences-between-user-and-kernel-modes</a></li>     <li><a href="/misc/goto?guid=4959674790295038326">https://zh.wikipedia.org/wiki/%E5%BF%99%E7%A2%8C%E7%AD%89%E5%BE%85</a></li>     <li><a href="/misc/goto?guid=4959674790374813084">https://www.ibm.com/developerworks/cn/linux/l-system-calls/</a></li>    </ol>    <p><br>  </p>    <p>文／<a href="/misc/goto?guid=4959674790453950938">BlackSwift</a>（简书）<br>  </p>    <p> </p>