当前位置：首页 > news >正文

【Linux系统】线程

news 来源：原创 2025/5/3 11:59:58

1. Linux线程概念

1-1 什么是线程

在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的一个控制序列” 。
一切进程至少都有一个执行线程 。
线程在进程内部运行，本质是在进程地址空间内运行。
在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化。
透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。

1-2 分页式存储管理

1-2-1 虚拟地址和页表的由来

思考一下，如果在没有虚拟内存和分页机制的情况下，每一个用户程序在物理内存上所对应的空间必须是连续的。
在这里插入图片描述

因为每一个程序的代码、数据长度都是不一样的，按照这样的映射方式，物理内存将会被分割成各种离散的、大小不同的块。经过一段运行时间之后，有些程序会退出，那么它们占据的物理内存空间可以被回收，导致这些物理内存都是以很多碎片的形式存在。
在这里插入图片描述

我们希望操作系统提供给用户的空间必须是连续的，但是物理内存最好不要连续。此时虚拟内存和分页便出现了。把物理内存按照一个固定的长度的页框进行分割，有时叫做物理页。每个页框包含一个物理页（page）。一个页的大小等于页框的大小。大多数32位体系结构支持4KB的页，而64位体系结构一般会支持8KB的页。区分页和页框很重要：

页框是一个存储区域；
页是一个数据块，可以存放在任何页框或磁盘中。

有了这种机制，CPU便并非是直接访问物理内存地址，而是通过虚拟地址空间来间接的访问物理内存地址。所谓的虚拟地址空间，是操作系统为每一个正在执行的进程分配的一个逻辑地址，在32位机上，其范围从0 ~ 4G-1。

操作系统通过将虚拟地址空间和物理内存地址之间建立映射关系，也就是页表，这张表上记录了每一个页和页框的映射关系，能让CPU间接的访问物理内存地址。

总结一下，其思想是将虚拟内存下的逻辑地址空间分为若干页，将物理内存空间分为若干页框，通过页表便能把连续的虚拟内存，映射到若干个不连续的物理内存。这样就解决了使用连续的物理内存造成的碎片问题。

1-2-2 物理内存管理

假设一个可用的物理内存有4GB的空间。按照一个页框的大小4KB进行划分，4GB的空间就是4GB / 4KB = 1048576个页框。有这么多的物理页，操作系统肯定是要将其管理起来的，操作系统需要知道哪些页正在被使用，哪些页空闲等等。

内核用struct page结构表示系统中的每个物理页，出于节省内存的考虑，struct page中使用了大量的联合体union。

/* include/linux/mm_types.h */
struct page {/* 原子标志，有些情况下会异步更新 */unsigned long flags;union {/* 换出页列表，例如由zone->lru_lock保护的active_list */struct list_head lru;/* 如果最低为0，则指向inode* address_space，或为NULL* 并且该页指向匿名_vma对象* 如果该指针指向anon_vma_mapping;*//* 在映射内的偏移量 */struct address_space *mapping;pgoff_t index;/* 由映射私有，不透明数据* 如果设置了PagePrivate，通常用于buffer_heads* 如果设置了PageSwapCache，则用于表示伙伴系统中的阶*/unsigned long private;};struct {union {struct list_head slab_list; /* uses lru */struct {struct page* next;
#ifdef CONFIG_64BITstruct page* partial;
#endifint pages; /* Nr of pages left */
#ifdef CONFIG_64BITint pobjects;
#elseshort int pages; /* Approximate count */short int pobjects;
#endif};};struct kmem_cache* slab_cache; /* not slab *//* Double-word boundary */void* freelist;    /* first free object */union {void* s_mem;   /* slab: first object */unsigned long counters;struct {unsigned inuse : 16;    /* 用于SLUB分配器: 对象的数目 */unsigned objects : 15;unsigned frozen : 1;};};};union {/* 内存管理子系统中映射的页表项数，用于表示页是否已经映射，还用于限制逆向映射搜索 */atomic_t _mapcount;unsigned int page_type;
#ifdef CONFIG_SLABunsigned int active;
#endif
#ifdef WANT_PAGE_VIRTUALvoid* virtual; /* 如果没有映射则为NULL，即高端内存 */
#endif};
}

其中比较重要的几个参数：

flags：用来存放页的状态，这些状态包括是不是脏的，是不是被锁定在内存中等。flags的每一位都代表一种状态。其中一些比特位非常重要，如PG_locked用于指定页是否锁定，PG_unuptodate表示在页表中的数据已经从设备读取并且没有出现错误。
_mapcount：表示在页表中有多少项指向该页，也就是这一页被引用了多少次。当计数变为-1时，就说明当前虚拟地址没有引用这一页，于是在新的分配中就可以使用它。
virtual：是页的虚拟地址。通常情况下，它就是页在虚拟内存中的地址。有些内存（即所谓的高端内存）并不映射到线性地址空间中。在这种情况下，这个域的值为NULL，需要的时候，必须动态地映射这些页。

在这种情况下，系统中的每个物理页都需要一个struct page，让我们来算算对所有这些页都这么做，到底要消耗掉多少内存。假设系统的物理页为4KB大小，系统有4GB物理内存。那么系统中共有页1048576个（1兆），所以描述这么多页的page结构体消耗的内存只不过40MB，并不算大。4GB内存而言，仅是很小的一部分罢了。因此，要管理系统中这么多物理页面这个代价并不算太大。

要知道的是，页的大小对于内存利用和系统开销来说非常重要，页太大，页必然会剩余较大不能利用的空间（页内碎片）。页太小，虽然可以减小页内碎片的大小，但是页太多，会使得页表太长而占用内存，同时系统频繁地进行页转化，加重系统开销。因此，页的大小应该适中，通常为512B - 8KB ，windows系统的页框大小为4KB。

1-2-3 页表

**页表的每一个表项，指向一个物理页的开始地址。**在32位系统中，虚拟内存的最大空间是4GB ，这是每一个用户程序都拥有的虚拟内存空间。既然需要让4GB的虚拟内存全部可用，那么页表中就需要能够表示这所有的4GB空间，那么就一共需要4GB / 4KB = 1048576个表项。
在这里插入图片描述

虚拟内存看上去被虚线“分割”成一个个单元，其实并不是真的分割，虚拟内存仍然是连续的。这个虚线上的单元仅仅表示它与页表中每一个表项的映射关系，并最终映射到相同大小的一个物理内存页上。

页表中的物理地址，与物理内存之间，是随机的映射关系，哪里可用就指向哪里（物理页）。虽然最终使用的物理内存是离散的，但是与虚拟内存对应的线性地址是连续的。处理器在访问数据、获取指令时，使用的都是线性地址，只要它是连续的就可以了，最终都能够通过页表找到实际的物理地址。

在32位系统中，地址的长度是4个字节，那么页表中的每一个表项就占用4个字节，所以页表占据的总空间大小就是：1048576 * 4 字节 = 4MB 的大小。也就是说映射表自己本身，就要占用4MB内存 / 4KB = 1024 个物理页。这会存在哪些问题呢？

回想一下，当初为什么使用页表，就是要将进程划分为一个个页可以不用连续的存放在物理内存中，但是此时页表就需要1024个连续的页框，似乎和当时的目标有点背道而驰了……
此外，根据局部性原理可知，很多时候进程在一段时间内只需要访问某几个页就可以正常运行了。因此也没有必要一次让所有的物理页都常驻内存。

解决需要大容量页表的最好方法是：把页表看成普通的文件，对它进行离散分配，即对页表再分页，由此形成多级页表的思想。

为了解决这个问题，可以把这个单一页表拆分成1024个体积更小的映射表。这样一来，1024(每个表中的表项个数) * 1024(表的个数)，仍然可以覆盖4GB的物理内存空间。
在这里插入图片描述

这里的每一个表，就是真正的页表，所以一共有1024个页表。一个页表自身占用4KB ，那么1024个页表一共就占用了4MB的物理内存空间，和之前没差别啊？

从总数上看是这样，但是一个应用程序是不可能完全使用全部的4GB空间的，也许只要几十个页表就可以了。例如：一个用户程序的代码段、数据段、栈段，一共就需要10MB的空间，那么使用3个页表就足够了。

计算过程：一个页表项指向一个4KB的物理页，那么一个页表中1024个页表项，一共能覆盖4MB的物理内存；那么10MB的程序，向上对齐取整之后（4MB的倍数，就是12MB），就需要3个页表就可以了。

1-2-4 页目录结构

到目前为止，每一个页框都被一个页表中的一个表项来指向了，那么这1024个页表也需要被管理起来。管理页表的表称之为页目录表，形成二级页表。
在这里插入图片描述

所有页表的物理地址被页目录表表项指向。
页目录的物理地址被CR3寄存器指向，这个寄存器中，保存了当前正在执行任务的页目录地址。

所以操作系统在加载用户程序的时候，不仅仅需要为程序内容来分配物理内存，还需要为用来保存程序的页表和页目录分配物理内存。

1-2-5 两级页表的地址转换

下面以一个逻辑地址为例。将逻辑地址（0000000000,000000001,1111111111）转换为物理地址的过程：

在32位处理器中，采用4KB的页大小，则虚拟地址中低12位为页偏移，剩下高20位给页表，分成两级，每个级别占10个bit（10 + 10）。
CR3 寄存器读取页目录起始地址，再根据一级页号查页目录表，找到下一级页表在物理内存中存放位置。
根据二级页号查表，找到最终想要访问的内存块号。
结合页内偏移量得到物理地址。
注：一个物理页的地址一定是4KB对齐的(最后的12位全部为0)，所以其实只需要记录物理页地址的高20位即可。
以上其实就是MMU的工作流程。MMU(Memory Manage Unit)是一种硬件电路，其速度很快，主要工作是进行内存管理，地址转换只是它承接的业务之一。

到这里其实还有个问题，MMU要先进行两次页表查询确定物理地址，在确认了权限等问题后，MMU再将这个物理地址发送到总线，内存收到之后开始读取对应地址的数据并返回。那么当页表变为N级时，就变成了N次检索 + 1次读写。可见，页表级数越多查询的步骤越多，对于CPU来说等待时间越长，效率越低。

总结一下：单级页表对连续内存要求高，于是引入了多级页表，但是多级页表也是一把双刃剑，在减少连续存储要求的同时降低了查询效率。

有没有提升效率的办法呢？计算机科学中的所有问题，都可以通过添加一个中间层来解决。MMU引入了新武器，江湖人称快表的TLB（其实，就是缓存）。

当CPU给MMU传递虚拟地址之后，MMU先去问TLB那边有没有，如果有就直接拿到物理地址发到总线，在页表中查到之后MMU除了把地址发到总线传给内存，还把这条映射关系给到TLB，让它记录一下刷新缓存；但TLB容量比较小，难免发生Cache Miss，这时候MMU还有保底的老武器页表，再去页表中找。

在这里插入图片描述

1-2-6 缺页异常

设想，CPU给MMU的虚拟地址，在TLB和页表都没有找到对应的物理页，该怎么办呢？其实这就是缺页异常（Page Fault），它是一个由硬件中断触发的可以由软件逻辑纠正的错误。

假如目标内存页在物理内存中没有对应的物理页或者存在但无对应权限，CPU就无法获取数据，这种情况下CPU就会报告一个缺页错误。

由于CPU没有数据就无法进行计算，CPU罢工了用户进程也就出现了缺页中断，进程会从用户态切换到内核态，并将缺页中断交给内核的Page Fault Handler处理。

缺页中断会交给PageFaultHandler处理，其根据缺页中断的不同类型会进行不同的处理：

Hard Page Fault：也被称为Major Page Fault，翻译为硬缺页错误/主要缺页错误，这时物理内存中没有对应的物理页，需要CPU打开磁盘设备读取到物理内存中，再让MMU建立虚拟地址和物理地址的映射。
Soft Page Fault：也被称为Minor Page Fault，翻译为软缺页错误/次要缺页错误，这时物理内存中是存在对应物理页的，只不过可能是其他进程调入的，发出缺页异常的进程不知道而已，此时MMU只需要建立映射即可，无需从磁盘读取写入内存，一般出现在多进程共享内存区域。
Invalid Page Fault：翻译为无效缺页错误，比如进程访问的内存地址越界访问，又比如对空指针解引用内核就会报segment fault错误中断进程直接挂掉。

1-3 线程的优点

创建一个新线程的代价要比创建一个新进程小得多。
与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多：
- 最主要的区别是线程的切换虚拟内存空间依然是相同的，但是进程切换是不同的。这两种上下文切换的处理都是通过操作系统内核来完成的。内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出。
- 另外一个隐藏的损耗是上下文的切换会扰乱处理器的缓存机制。简单的说，一旦去切换上下文，处理器中所有已经缓存的内存地址一瞬间都作废了。还有一个显著的区别是当你改变虚拟内存空间的时候，处理的页表缓冲TLB（快表）会被全部刷新，这将导致内存的访问在一段时间内相当的低效。但是在线程的切换中，不会出现这个问题，当然还有硬件cache。
线程占用的资源要比进程少很。
能充分利用多处理器的可并行数量。
在等待慢速I/O操作结束的同时，程序可执行其他的计算任务。
计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现。
I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

1-4 线程的缺点

性能损失：一个很少被外部事件阻塞的计算密集型线程往往无法与其它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。
健壮性降低：编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。
缺乏访问控制：进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。
编程难度提高：编写与调试一个多线程程序比单线程程序困难得多。

1-5 线程异常

单个线程如果出现除零，野指针问题导致线程崩溃，进程也会随着崩溃。
线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该进程内的所有线程也就随即退出。

1-6 线程用途

合理的使用多线程，能提高CPU密集型程序的执行效率。
合理的使用多线程，能提高IO密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具，就是多线程运行的一种表现）。

2. Linux进程VS线程

2-1 进程和线程

进程是资源分配的基本单位。
线程是调度的基本单位。
线程共享进程数据，但也拥有自己的一部分数据：
- 线程ID
- 一组寄存器
- 栈
- errno
- 信号屏蔽字
- 调度优先级

2-2 进程的多个线程共享

同一进程内的多个线程共享同一段地址空间，因此Text Segment、Data Segment都是共享的，如果定义一个函数，在各线程中都可以调用，如果定义一个全局变量，在各线程中都可以访问到，除此之外，各线程还共享以下进程资源和环境：

文件描述符表
每种信号的处理方式（SIG_IGN、SIG_DFL或者自定义的信号处理函数）
当前工作目录
用户id和组id

2-3 关于进程线程的问题

如何看待之前学习的单进程？具有一个线程执行流的进程。

3. Linux线程控制

3-1 POSIX线程库

与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的。
要使用这些函数库，要通过引入头文件<pthread.h> 。
链接这些线程函数库时要使用编译器命令的“-lpthread”选项。

3-2 创建线程

功能：创建一个新的线程
原型：

int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);

参数：
- thread：返回线程ID
- attr：设置线程的属性，attr为NULL表示使用默认属性
- start_routine：是个函数地址，线程启动后要执行的函数
- arg：传给线程启动函数的参数
返回值：成功返回0；失败返回错误码

错误检查：

传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。
pthreads函数出错时不会设置全局变量errno（而大部分其他POSIX函数会这样做），而是将错误代码通过返回值返回。
pthreads同样也提供了线程内的errno变量，以支持其它使用errno的代码。对于pthreads函数的错误，建议通过返回值判定，因为读取返回值要比读取线程内的errno变量的开销更小。

示例代码：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>void *rout(void *arg) {int i;for ( ; ; ) {printf("I am thread 1\n");sleep(1);}
}int main( void )
{pthread_t tid;int ret;if ( (ret=pthread_create(&tid, NULL, rout, NULL)) != 0 ) {fprintf(stderr, "pthread_create : %s\n", strerror(ret));exit(EXIT_FAILURE);}int i;for(; ; ) {printf("I am main thread\n");sleep(1);}
}

#include <pthread.h>
// 获取线程ID
pthread_t pthread_self(void);

打印出来的tid是通过pthread库中有函数pthread_self得到的，它返回一个pthread_t类型的变量，指代的是调用pthread_self函数的线程的“ID”。
在这里插入图片描述

这个“ID”是pthread库给每个线程定义的进程内唯一标识，是pthread库维持的。由于每个进程有自己独立的内存空间，故此“ID”的作用域是进程级而非系统级（内核不认识）。其实pthread库也是通过内核提供的系统调用（例如clone）来创建线程的，而内核会为每个线程创建系统全局唯一的“ID”来唯一标识这个线程。

使用PS命令查看线程信息
运行代码后执行：

$ ps -aL | head -1 && ps -aL | grep mythread

-L选项：打印线程信息
在这里插入图片描述

LWP得到的是真正的线程ID。之前使用pthread_self得到的这个数实际上是一个地址，在虚拟地址空间上的一个地址，通过这个地址，可以找到关于这个线程的基本信息，包括线程ID，线程栈，寄存器等属性。

在ps -aL得到的线程ID中，有一个线程ID和进程ID相同，这个线程就是主线程，主线程的栈在虚拟地址空间的栈上，而其他线程的栈是在共享区（堆栈之间），因为pthread系列函数都是pthread库提供给我们的。而pthread库是在共享区的。所以除了主线程之外的其他线程的栈都在共享区。

3-3 线程终止

如果需要只终止某个线程而不终止整个进程，可有三种方法：

从线程函数return。这种方法对主线程不适用，从main函数return相当于调用exit。
线程可以调用pthread_exit终止自己。
一个线程可以调用pthread_cancel终止同一进程中的另一个线程。

pthread_exit函数

功能：线程终止
原型：void pthread_exit(void *value_ptr);
参数：value_ptr不要指向一个局部变量。
返回值：无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）。

需注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函数已经退出了。

pthread_cancel函数

功能：取消一个执行中的线程
原型：int pthread_cancel(pthread_t thread);
参数：thread为线程ID
返回值：成功返回0；失败返回错误码

3-4 线程等待

为什么需要线程等待？

已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
创建新的线程不会复用刚才退出线程的地址空间。

pthread_join函数

功能：等待线程结束
原型：int pthread_join(pthread_t thread, void **value_ptr);
参数：
- thread：线程ID
- value_ptr：它指向一个指针，后者指向线程的返回值
返回值：成功返回0；失败返回错误码

调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下：

如果thread线程通过return返回，value_ptr所指向的单元里存放的是thread线程函数的返回值。
如果thread线程被别的线程调用pthread_cancel异常终掉，value_ptr所指向的单元里存放的常数PTHREAD_CANCELED。
如果thread线程是自己调用pthread_exit终止的，value_ptr所指向的单元存放的是传给pthread_exit的参数。
如果对thread线程的终止状态不感兴趣，可以传NULL给value_ptr参数。

样例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>void *thread1( void *arg )
{printf("thread 1 returning... \n");int *p = (int*)malloc(sizeof(int));*p = 1;return (void*)p;
}void *thread2( void *arg )
{printf("thread 2 exiting...\n");int *p = (int*)malloc(sizeof(int));*p = 2;pthread_exit((void*)p);
}void *thread3( void *arg )
{while ( 1){ printf("thread 3 is running...\n");sleep(1);}return NULL;
}int main( void )
{pthread_t tid;void *ret;// thread 1 returnpthread_create(&tid, NULL, thread1, NULL);pthread_join(tid, &ret);printf("thread return, thread id %X, return code:%d\n", tid, *(int*)ret);free(ret);// thread 2 exitpthread_create(&tid, NULL, thread2, NULL);pthread_join(tid, &ret);printf("thread return, thread id %X, return code:%d\n", tid, *(int*)ret);free(ret);// thread 3 cancel by otherpthread_create(&tid, NULL, thread3, NULL);sleep(3);pthread_cancel(tid);pthread_join(tid, &ret);if ( ret== PTHREAD_CANCELED )printf("thread return, thread id %X, return code:PTHREAD_CANCELED\n", tid);elseprintf("thread return, thread id %X, return code:NULL\n", tid);return 0;
}

运行结果：
在这里插入图片描述

3-5 分离线程

默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则不会释放线程资源，从而造成系统泄漏。
如果不关心线程的返回值，join是一种负担，这个时候，可以告诉系统，当线程退出时自动释放线程资源。

int pthread_detach(pthread_t thread);

可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离。

pthread_detach(pthread_self());

joinable和分离是冲突的，一个线程不能既是joinable又是分离的。

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>void *thread_run( void * arg )
{pthread_detach(pthread_self());printf("%s\n", (char*)arg);return NULL;
}int main( void )
{pthread_t tid;if ( pthread_create(&tid, NULL, thread_run, "thread1 run...") != 0 ) {printf("create thread error\n");return 1;}int ret = 0;sleep(1);//很重要，要让线程先分离，再等待if ( pthread_join(tid, NULL ) == 0 ) {printf("pthread wait success\n");ret = 0;} else {printf("pthread wait failed\n");ret = 1;}return ret;
}

4. 线程ID及进程地址空间布局

pthread_create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的线程ID不是一回事。
前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。
pthread_create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。
线程库NPTL提供了pthread_self函数，可以获得线程自身的ID：

pthread_t pthread_self(void);

pthread_t到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。
在这里插入图片描述

线程栈

虽然Linux将线程和进程不加区分的统一到了task_struct，但是对待其地址空间的stack还是有些区别的。

对于Linux进程或者说主线程，简单理解就是main函数的栈空间，在fork的时候，实际上就是复制了父亲的stack空间地址，然后写时拷贝(cow)以及动态增长。如果扩充超出该上限则栈溢出会报段错误（发送段错误信号给该进程）。进程栈是唯一可以访问未映射页而不一定会发生段错误——超出扩充上限才报。
然而对于主线程生成的子线程而言，其stack将不再是向下生长的，而是事先固定下来的。线程栈一般是调用glibc/uclibc等的pthread库接口pthread_create创建的线程，在文件映射区（或称之为共享区）。其中使用mmap系统调用，这个可以从glibc的nptl/allocatestack.c中的allocate_stack函数中看到：

mem = mmap (NULL, size, prot,MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);

此调用中的size参数的获取很是复杂，你可以手工传入stack的大小，也可以使用默认的，一般而言就是默认的8M。这些都不重要，重要的是，这种stack不能动态增长，一旦用尽就没了，这是和生成进程的fork不同的地方。在glibc中通过mmap得到了stack之后，底层将调用sys_clone系统调用：

int sys_clone(struct pt_regs *regs)
{unsigned long clone_flags;unsigned long newsp;int __user *parent_tidptr, *child_tidptr;clone_flags = regs->bx;//获取了mmap得到的线程的stack指针newsp = regs->cx;parent_tidptr = (int __user *)regs->dx;child_tidptr = (int __user *)regs->di;if (!newsp)newsp = regs->sp;return do_fork(clone_flags, newsp, regs, 0, parent_tidptr, child_tidptr);
}