精华内容
下载资源
问答
  • 关于线程栈与线程地址空间

    千次阅读 2018-04-11 09:30:23
    线程栈与地址空间Linux系统把所有线程都当做进程来实现,线程作为轻量级进程(LWP)。线程仅仅被视为一个与其他进程共享某些资源的进程,而是否共享地址空间几乎是进程和 Linux 中所谓线程的唯一区别。线程创建的...

    线程栈与地址空间
    Linux系统 把所有线程都当做进程来实现,线程作为轻量级进程(LWP)。
    线程仅仅被视为一个与其他进程共享某些资源的进程,而 是否共享地址空间几乎是进程和 Linux 中所谓线程的唯一区别 。线程创建的时候,加上了 CLONE_VM 标记,这样  线程的内存描述符 将直接指向 父进程的内存描述符 ,也就是说, 线程的mm_struct *mm指针变量和所属进程的mm指针变量相同。
    所有线程都共享一份地址空间,这不但包括text、heap和进程stack等, 甚至还包括了线程stack
    注意此处表达的字面意思: 所有线程共享包括线程栈在内的地址空间,并不意味着所有线程都共享一个栈地址,而是一个线程可以访问另一个线程的栈数据 (虽然并没什么用,但确实可行,通过实验可以验证)。显然, 不同线程有不同的函数调用关系所以不能使用同一个栈 。之所以能做到线程A能访问线程B的栈数据,正是因为内核为每个线程在不同地址处分配了栈空间,从进程的全局地址空间看(cat /proc/PID/maps),每个线程的stack都位于不同的地址段。

    虽然线程共享地址空间,但线程的私有数据,又是需要单独保存的,这包括了:
    • pthread属性相关,pthread_attr
    • 线程栈,thread stack
    • 线程本地存储,TLS(thread local storage)
    这三种数据位于同一块内存中,是在创建线程的时候,用mmap系统调用从heap分配出来的:
    这个可以从 glibc 的nptl/allocatestack.c 中的allocate_stack() 函数中看到:
    mem = mmap (NULL, size, prot, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);

    如何获取线程栈
    利用函数pthread_attr_getstack(pthread_t, void** stack_addr, size_t* stack_size);

    pid_t __gettid(void) //glibc没有实现gettid()函数,因此我们可以自己实现
    {
    return syscall(SYS_gettid);
    }
    void __show_stack(void)
    {
    size_t stack_size = 0;
    void* stackaddr = NULL;
    pthread_attr_t attr;
    pthread_t pid = pthread_self();
    pid_t tid = __gettid();

    pthread_attr_init(&attr);
    pthread_getattr_np(pid, &attr);//获取当前线程的属性
    if(pthread_attr_getstack(&attr, &stackaddr, &stack_size)){
    perror("fail to get pthread stack");
    }
    printf("tid:%d pid:%d stack_addr:%p stack_size:%d \n", tid, pid, stackaddr, stack_size);
    }
    void* __task(void*arg)
    {
    __show_stack();
    while(1){
    sleep(1);
    }
    }
    ====================================================================
    从如下例子看出,不同线程的stack地址是不一样的。

    [lubo@localhost proc]$ ./a.out
    tid:7576 pid:-111012032 stack_addr:0x7fff20b58000 stack_size:8380416
    tid:7577 pid:-111016192 stack_addr:0x7f55f8e20000 stack_size:8392704
    tid:7578 pid:-119408896 stack_addr:0x7f55f861f000 stack_size:8392704
    tid:7579 pid:-127801600 stack_addr:0x7f55f7e1e000 stack_size:8392704

    [lubo@localhost proc]$ cd /proc/7576
    [lubo@localhost 7576]$ cat maps
    00400000-00401000 r-xp 00000000 08:07 1848537 /media/work/docs/c_test/pthread/thread_stack/a.out
    00601000-00602000 r--p 00001000 08:07 1848537 /media/work/docs/c_test/pthread/thread_stack/a.out
    00602000-00603000 rw-p 00002000 08:07 1848537 /media/work/docs/c_test/pthread/thread_stack/a.out
    0175b000-0177c000 rw-p 00000000 00:00 0 [heap]
    3212800000-3212820000 r-xp 00000000 fd:00 1616273 /usr/lib64/ld-2.18.so
    3212a1f000-3212a20000 r--p 0001f000 fd:00 1616273 /usr/lib64/ld-2.18.so
    3212a20000-3212a21000 rw-p 00020000 fd:00 1616273 /usr/lib64/ld-2.18.so
    3212a21000-3212a22000 rw-p 00000000 00:00 0
    3212c00000-3212db4000 r-xp 00000000 fd:00 1616274 /usr/lib64/libc-2.18.so
    3212db4000-3212fb4000 ---p 001b4000 fd:00 1616274 /usr/lib64/libc-2.18.so
    3212fb4000-3212fb8000 r--p 001b4000 fd:00 1616274 /usr/lib64/libc-2.18.so
    3212fb8000-3212fba000 rw-p 001b8000 fd:00 1616274 /usr/lib64/libc-2.18.so
    3212fba000-3212fbf000 rw-p 00000000 00:00 0
    3213400000-3213418000 r-xp 00000000 fd:00 1616284 /usr/lib64/libpthread-2.18.so
    3213418000-3213617000 ---p 00018000 fd:00 1616284 /usr/lib64/libpthread-2.18.so
    3213617000-3213618000 r--p 00017000 fd:00 1616284 /usr/lib64/libpthread-2.18.so
    3213618000-3213619000 rw-p 00018000 fd:00 1616284 /usr/lib64/libpthread-2.18.so
    3213619000-321361d000 rw-p 00000000 00:00 0
    7f55e0000000-7f55e0021000 rw-p 00000000 00:00 0
    7f55e0021000-7f55e4000000 ---p 00000000 00:00 0
    7f55e8000000-7f55e8021000 rw-p 00000000 00:00 0
    7f55e8021000-7f55ec000000 ---p 00000000 00:00 0
    7f55f0000000-7f55f0021000 rw-p 00000000 00:00 0
    7f55f0021000-7f55f4000000 ---p 00000000 00:00 0
    7f55f7e1e000-7f55f7e1f000 ---p 00000000 00:00 0
    7f55f7e1f000-7f55f861f000 rw-p 00000000 00:00 0 [stack:7579]
    7f55f861f000-7f55f8620000 ---p 00000000 00:00 0
    7f55f8620000-7f55f8e20000 rw-p 00000000 00:00 0 [stack:7578]
    7f55f8e20000-7f55f8e21000 ---p 00000000 00:00 0
    7f55f8e21000-7f55f9624000 rw-p 00000000 00:00 0 [stack:7577]
    7f55f9650000-7f55f9652000 rw-p 00000000 00:00 0
    7fff21337000-7fff21358000 rw-p 00000000 00:00 0 [stack]
    7fff213fe000-7fff21400000 r-xp 00000000 00:00 0 [vdso]
    ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]


    例子代码(fedora22/x86及mips/uclibc都能跑通)见附件
    pthread_stack.c

    展开全文
  • 关于多线程栈空间的若干问题

    千次阅读 2012-03-30 22:36:33
    2. 而创建了多线程,各个线程要求有自己独立的,这些独立的是怎么分布的呢? 应当是一个动态地概念,只有在线程开始执行后,才为其分配资源.具体的分布是无法确定的.我觉得这就像 调用函数一样,当调用函数...
    1.一个进程应该有自己独立的进程空间。
    

    应当说每个进程各自拥有其独立的地址空间.都是虚地址,在32位机上都是0-4G

    2. 而创建了多线程,各个线程要求有自己独立的栈,这些独立的栈是怎么分布的呢?

    栈应当是一个动态地概念,只有在线程开始执行后,才为其分配栈资源.具体的分布是无法确定的.我觉得这就像
    调用函数一样,当调用函数时,进程通过调整栈基址指针寄存器和栈顶指针寄存器,为函数分配了一个栈空间.
    能够确定的是,这片空间肯定是在进程的栈区内划分出来的一片地址空间.

    单线程程序只不过是多线程的一种特殊形式,每创建一个线程时,为每一线程在进程内的栈空间上化分出一片区域,作为该线程的栈空间.并且在线程的描述结构里面应当有保存某些寄存器如esp,ebp之类的数据结构的定义.


    是否都是在一个线性地址空间内呢?

    在同一个进程内,就在同一线性地址空间内.


    但也因为线程共用栈空间,产生很多同步问题

    同步问题不是由此引入的.
    进程内的线程共享进程的栈空间,但在栈空间内,每一线程都有其独立的栈区.

    多线程编程时,需要进行同步访问的数据有三种,一种是全局变量,一种是动态分配的变量,还有一种是函数内的局部静态变量,这三种类型的变量都不存在于栈里面.
    展开全文
  • 原则山私有并是真的私有,因为大家都知道线程的特点就是共享地址空间,原则私有空间就是一般而言通过正常手段其它线程不会触及这些空间的数据。虽然Linux将线程和进程加区分的统一到了task_struct,但是对待其...
  • 线程 栈空间变量 可见性

    千次阅读 2015-05-08 22:23:18
    所以,如果一个线程以某种方式得到一个指向其他线程栈的指针,那么他就可以读写这个栈的任何部分” 下面是测试代码。 #include #include using namespace std; void func(int* pa) { cout ; ...

    今天看couchbase 回调代码的时候发现 callback 函数有一个参数是 cookie,相当于一个调用异步函数时的上下文。

    http://docs.couchbase.com/developer/c-2.4/c-intro.html

    我们代码里面是类似这样用的。


    // 回调函数

    static void get_callback(lcb_t instance,
            const void* cookie,
            lcb_error_t code,
            const lcb_get_resp_t* resp) {

    //....修改 cookie

    }


    // instance, install 回调函数

    lcb_t cb;

    lcb_set_get_callback(cb, get_callback);


    // 从couchbase取数据

    std::deque<int64_t> uids;

    lcb_get(cb, &uids, MAX_ITEMS, pcmds);


    因为取数据的线程和调用回调函数的线程是两个不同的线程,

    而uids是取数据的线程所在的栈上的,回调函数怎么可以直接操作这个变量呢?

    不是一直说同一个进程的多个线程共享堆,但是都有自己的栈么?


    恩,是的,这个说法是没错,线程有自己的栈,但是不代表它不能访问其他的线程的栈。


    深入理解计算机系统 P663 是这样说的:

    “各自独立的线程栈的存储器模型不是那么整齐清楚的。这些栈被保存在虚拟地址空间的栈区域中,并且通常是被相应的线程独立访问的。

    我们说通常而不是总是,是因为不同的线程栈是不对其他线程设防的。所以,如果一个线程以某种方式得到一个指向其他线程栈的指针,那么他就可以读写这个栈的任何部分”


    下面是测试代码。


    #include <thread>
    #include <iostream>
    
    using namespace std;
    
    void func(int* pa) {
      cout << pa << endl;
      cout << *pa << endl;
      *pa = 15;
    }
    
    int main() {
      int a = 5;
      cout << "main, &a: " << &a << endl;
      thread thrd(func, &a);
    
      thrd.join();
      cout << "main, &a: " << &a << endl;
      cout << "main, a: " << a << endl;
    }

    [root@licchen-test-dev001-bjdxt tests]# g++ -std=c++11 -lpthread thread_2.cpp 
    [root@licchen-test-dev001-bjdxt tests]# ./a.out 
    main, &a: 0x7ffff5ae9564
    0x7ffff5ae9564
    5
    main, &a: 0x7ffff5ae9564
    main, a: 15


    a 的值被另外的线程修改。



    展开全文
  • 目录(?)[-] 一Linux虚拟地址空间布局1 内核空间2 ...8 保留区二Linux 中的各种栈进程栈 线程栈 内核栈 中断栈 Linux 中有几种栈各种栈的内存位置 一进程栈二线程栈三进程内核栈四中断栈 Linux 为什么需要区分这些栈

    1. 一 Linux虚拟地址空间布局
    2. 1 内核空间
    3. 2 栈stack
    4. 3 内存映射段mmap
    5. 4 堆heap
    6. 5 BSS段
    7. 6 数据段Data
    8. 7 代码段text
    9. 8 保留区
    10. 二 Linux 中的各种栈进程栈 线程栈 内核栈 中断栈
      1. Linux 中有几种栈各种栈的内存位置
        1. 一进程栈
        2. 二线程栈
        3. 三进程内核栈
        4. 四中断栈
      2. Linux 为什么需要区分这些栈
    11. 三 自己的总结


    一:Linux虚拟地址空间布局

     在多任务操作系统中,每个进程都运行在属于自己的内存沙盘中。这个沙盘就是虚拟地址空间(Virtual Address Space),在32位模式下它是一个4GB的内存地址块。在Linux系统中, 内核进程和用户进程所占的虚拟内存比例是1:3,而Windows系统为2:2(通过设置Large-Address-Aware Executables标志也可为1:3)。这并不意味着内核使用那么多物理内存,仅表示它可支配这部分地址空间,根据需要将其映射到物理内存。

         虚拟地址通过页表(Page Table)映射到物理内存,页表由操作系统维护并被处理器引用。内核空间在页表中拥有较高特权级,因此用户态程序试图访问这些页时会导致一个页错误(page fault)。在Linux中,内核空间是持续存在的,并且在所有进程中都映射到同样的物理内存。内核代码和数据总是可寻址,随时准备处理中断和系统调用。与此相反,用户模式地址空间的映射随进程切换的发生而不断变化。

         Linux进程在虚拟内存中的标准内存段布局如下图所示:

         其中,用户地址空间中的蓝色条带对应于映射到物理内存的不同内存段,灰白区域表示未映射的部分。这些段只是简单的内存地址范围,与Intel处理器的段没有关系。

         上图中Random stack offset和Random mmap offset等随机值意在防止恶意程序。Linux通过对栈、内存映射段、堆的起始地址加上随机偏移量来打乱布局,以免恶意程序通过计算访问栈、库函数等地址。execve(2)负责为进程代码段和数据段建立映射,真正将代码段和数据段的内容读入内存是由系统的缺页异常处理程序按需完成的。另外,execve(2)还会将BSS段清零。

         用户进程部分分段存储内容如下表所示(按地址递减顺序):

    名称

    存储内容

    局部变量、函数参数、返回地址等

    动态分配的内存

    BSS段

    未初始化或初值为0的全局变量和静态局部变量

    数据段

    已初始化且初值非0的全局变量和静态局部变量

    代码段

    可执行代码、字符串字面值、只读变量

         在将应用程序加载到内存空间执行时,操作系统负责代码段、数据段和BSS段的加载,并在内存中为这些段分配空间。栈也由操作系统分配和管理;堆由程序员自己管理,即显式地申请和释放空间。

         BSS段、数据段和代码段是可执行程序编译时的分段,运行时还需要栈和堆。

     

         以下详细介绍各个分段的含义。

     

    1 内核空间

         内核总是驻留在内存中,是操作系统的一部分。内核空间为内核保留,不允许应用程序读写该区域的内容或直接调用内核代码定义的函数。

     

    2 栈(stack)

         栈又称堆栈,由编译器自动分配释放,行为类似数据结构中的栈(先进后出)。堆栈主要有三个用途:

    • 为函数内部声明的非静态局部变量(C语言中称“自动变量”)提供存储空间。
    • 记录函数调用过程相关的维护性信息,称为栈帧(Stack Frame)或过程活动记录(Procedure Activation Record)。它包括函数返回地址,不适合装入寄存器的函数参数及一些寄存器值的保存。除递归调用外,堆栈并非必需。因为编译时可获知局部变量,参数和返回地址所需空间,并将其分配于BSS段。
    • 临时存储区,用于暂存长算术表达式部分计算结果或alloca()函数分配的栈内内存。

         持续地重用栈空间有助于使活跃的栈内存保持在CPU缓存中,从而加速访问。进程中的每个线程都有属于自己的栈。向栈中不断压入数据时,若超出其容量就会耗尽栈对应的内存区域,从而触发一个页错误。此时若栈的大小低于堆栈最大值RLIMIT_STACK(通常是8M),则栈会动态增长,程序继续运行。映射的栈区扩展到所需大小后,不再收缩。

         Linux中ulimit -s命令可查看和设置堆栈最大值,当程序使用的堆栈超过该值时, 发生栈溢出(Stack Overflow),程序收到一个段错误(Segmentation Fault)。注意,调高堆栈容量可能会增加内存开销和启动时间。

         堆栈既可向下增长(向内存低地址)也可向上增长, 这依赖于具体的实现。本文所述堆栈向下增长。

         堆栈的大小在运行时由内核动态调整。

     

    3 内存映射段(mmap)

         此处,内核将硬盘文件的内容直接映射到内存, 任何应用程序都可通过Linux的mmap()系统调用或Windows的CreateFileMapping()/MapViewOfFile()请求这种映射。内存映射是一种方便高效的文件I/O方式, 因而被用于装载动态共享库。用户也可创建匿名内存映射,该映射没有对应的文件, 可用于存放程序数据。在 Linux中,若通过malloc()请求一大块内存,C运行库将创建一个匿名内存映射,而不使用堆内存。”大块” 意味着比阈值 MMAP_THRESHOLD还大,缺省为128KB,可通过mallopt()调整。

         该区域用于映射可执行文件用到的动态链接库。在Linux 2.4版本中,若可执行文件依赖共享库,则系统会为这些动态库在从0x40000000开始的地址分配相应空间,并在程序装载时将其载入到该空间。在Linux 2.6内核中,共享库的起始地址被往上移动至更靠近栈区的位置。

         从进程地址空间的布局可以看到,在有共享库的情况下,留给堆的可用空间还有两处:一处是从.bss段到0x40000000,约不到1GB的空间;另一处是从共享库到栈之间的空间,约不到2GB。这两块空间大小取决于栈、共享库的大小和数量。这样来看,是否应用程序可申请的最大堆空间只有2GB?事实上,这与Linux内核版本有关。在上面给出的进程地址空间经典布局图中,共享库的装载地址为0x40000000,这实际上是Linux kernel 2.6版本之前的情况了,在2.6版本里,共享库的装载地址已经被挪到靠近栈的位置,即位于0xBFxxxxxx附近,因此,此时的堆范围就不会被共享库分割成2个“碎片”,故kernel 2.6的32位Linux系统中,malloc申请的最大内存理论值在2.9GB左右。

     

    4 堆(heap)

         堆用于存放进程运行时动态分配的内存段,可动态扩张或缩减。堆中内容是匿名的,不能按名字直接访问,只能通过指针间接访问。当进程调用malloc(C)/new(C++)等函数分配内存时,新分配的内存动态添加到堆上(扩张);当调用free(C)/delete(C++)等函数释放内存时,被释放的内存从堆中剔除(缩减) 。

         分配的堆内存是经过字节对齐的空间,以适合原子操作。堆管理器通过链表管理每个申请的内存,由于堆申请和释放是无序的,最终会产生内存碎片。堆内存一般由应用程序分配释放,回收的内存可供重新使用。若程序员不释放,程序结束时操作系统可能会自动回收。

         堆的末端由break指针标识,当堆管理器需要更多内存时,可通过系统调用brk()和sbrk()来移动break指针以扩张堆,一般由系统自动调用。

         使用堆时经常出现两种问题:1) 释放或改写仍在使用的内存(“内存破坏”);2)未释放不再使用的内存(“内存泄漏”)。当释放次数少于申请次数时,可能已造成内存泄漏。泄漏的内存往往比忘记释放的数据结构更大,因为所分配的内存通常会圆整为下个大于申请数量的2的幂次(如申请212B,会圆整为256B)。

         注意,堆不同于数据结构中的”堆”,其行为类似链表。

    【扩展阅读】栈和堆的区别

    管理方式:栈由编译器自动管理;堆由程序员控制,使用方便,但易产生内存泄露。

    生长方向:栈向低地址扩展(即”向下生长”),是连续的内存区域;堆向高地址扩展(即”向上生长”),是不连续的内存区域。这是由于系统用链表来存储空闲内存地址,自然不连续,而链表从低地址向高地址遍历。

    空间大小:栈顶地址和栈的最大容量由系统预先规定(通常默认2M或10M);堆的大小则受限于计算机系统中有效的虚拟内存,32位Linux系统中堆内存可达2.9G空间。

    存储内容:栈在函数调用时,首先压入主调函数中下条指令(函数调用语句的下条可执行语句)的地址,然后是函数实参,然后是被调函数的局部变量。本次调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的指令地址,程序由该点继续运行下条可执行语句。堆通常在头部用一个字节存放其大小,堆用于存储生存期与函数调用无关的数据,具体内容由程序员安排。

    分配方式:栈可静态分配或动态分配。静态分配由编译器完成,如局部变量的分配。动态分配由alloca函数在栈上申请空间,用完后自动释放。堆只能动态分配且手工释放。

    分配效率:栈由计算机底层提供支持:分配专门的寄存器存放栈地址,压栈出栈由专门的指令执行,因此效率较高。堆由函数库提供,机制复杂,效率比栈低得多。Windows系统中VirtualAlloc可直接在进程地址空间中分配一块内存,快速且灵活。

    分配后系统响应:只要栈剩余空间大于所申请空间,系统将为程序提供内存,否则报告异常提示栈溢出。

         操作系统为堆维护一个记录空闲内存地址的链表。当系统收到程序的内存分配申请时,会遍历该链表寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点空间分配给程序。若无足够大小的空间(可能由于内存碎片太多),有可能调用系统功能去增加程序数据段的内存空间,以便有机会分到足够大小的内存,然后进行返回。,大多数系统会在该内存空间首地址处记录本次分配的内存大小,供后续的释放函数(如free/delete)正确释放本内存空间。

         此外,由于找到的堆结点大小不一定正好等于申请的大小,系统会自动将多余的部分重新放入空闲链表中。

    碎片问题:栈不会存在碎片问题,因为栈是先进后出的队列,内存块弹出栈之前,在其上面的后进的栈内容已弹出。而频繁申请释放操作会造成堆内存空间的不连续,从而造成大量碎片,使程序效率降低。

         可见,堆容易造成内存碎片;由于没有专门的系统支持,效率很低;由于可能引发用户态和内核态切换,内存申请的代价更为昂贵。所以栈在程序中应用最广泛,函数调用也利用栈来完成,调用过程中的参数、返回地址、栈基指针和局部变量等都采用栈的方式存放。所以,建议尽量使用栈,仅在分配大量或大块内存空间时使用堆。

         使用栈和堆时应避免越界发生,否则可能程序崩溃或破坏程序堆、栈结构,产生意想不到的后果。

     

    5 BSS段

         BSS(Block Started by Symbol)段中通常存放程序中以下符号:

    • 未初始化的全局变量和静态局部变量
    • 初始值为0的全局变量和静态局部变量(依赖于编译器实现)
    • 未定义且初值不为0的符号(该初值即common block的大小)

         C语言中,未显式初始化的静态分配变量被初始化为0(算术类型)或空指针(指针类型)。由于程序加载时,BSS会被操作系统清零,所以未赋初值或初值为0的全局变量都在BSS中。BSS段仅为未初始化的静态分配变量预留位置,在目标文件中并不占据空间,这样可减少目标文件体积。但程序运行时需为变量分配内存空间,故目标文件必须记录所有未初始化的静态分配变量大小总和(通过start_bss和end_bss地址写入机器代码)。当加载器(loader)加载程序时,将为BSS段分配的内存初始化为0。在嵌入式软件中,进入main()函数之前BSS段被C运行时系统映射到初始化为全零的内存(效率较高)。

         注意,尽管均放置于BSS段,但初值为0的全局变量是强符号,而未初始化的全局变量是弱符号。若其他地方已定义同名的强符号(初值可能非0),则弱符号与之链接时不会引起重定义错误,但运行时的初值可能并非期望值(会被强符号覆盖)。因此,定义全局变量时,若只有本文件使用,则尽量使用static关键字修饰;否则需要为全局变量定义赋初值(哪怕0值),保证该变量为强符号,以便链接时发现变量名冲突,而不是被未知值覆盖。

         某些编译器将未初始化的全局变量保存在common段,链接时再将其放入BSS段。在编译阶段可通过-fno-common选项来禁止将未初始化的全局变量放入common段。

         此外,由于目标文件不含BSS段,故程序烧入存储器(Flash)后BSS段地址空间内容未知。U-Boot启动过程中将U-Boot的Stage2代码(通常位于lib_xxxx/board.c文件)搬迁(拷贝)到SDRAM空间后必须人为添加清零BSS段的代码,而不可依赖于Stage2代码中变量定义时赋0值。

    【扩展阅读】BSS历史

         BSS(Block Started by Symbol,以符号开始的块)一词最初是UA-SAP汇编器(United Aircraft Symbolic Assembly Program)中的伪指令,用于为符号预留一块内存空间。该汇编器由美国联合航空公司于20世纪50年代中期为IBM 704大型机所开发。

         后来该词被作为关键字引入到了IBM 709和7090/94机型上的标准汇编器FAP(Fortran Assembly Program),用于定义符号并且为该符号预留指定字数的未初始化空间块。

         在采用段式内存管理的架构中(如Intel 80x86系统),BSS段通常指用来存放程序中未初始化全局变量的一块内存区域,该段变量只有名称和大小却没有值。程序开始时由系统初始化清零。

         BSS段不包含数据,仅维护开始和结束地址,以便内存能在运行时被有效地清零。BSS所需的运行时空间由目标文件记录,但BSS并不占用目标文件内的实际空间,即BSS节段应用程序的二进制映象文件中并不存在。

     

    6 数据段(Data)

         数据段通常用于存放程序中已初始化且初值不为0的全局变量和静态局部变量。数据段属于静态内存分配(静态存储区),可读可写。

         数据段保存在目标文件中(在嵌入式系统里一般固化在镜像文件中),其内容由程序初始化。例如,对于全局变量int gVar = 10,必须在目标文件数据段中保存10这个数据,然后在程序加载时复制到相应的内存。

         数据段与BSS段的区别如下: 

         1) BSS段不占用物理文件尺寸,但占用内存空间;数据段占用物理文件,也占用内存空间。

         对于大型数组如int ar0[10000] = {1, 2, 3, ...}和int ar1[10000],ar1放在BSS段,只记录共有10000*4个字节需要初始化为0,而不是像ar0那样记录每个数据1、2、3...,此时BSS为目标文件所节省的磁盘空间相当可观。

         2) 当程序读取数据段的数据时,系统会出发缺页故障,从而分配相应的物理内存;当程序读取BSS段的数据时,内核会将其转到一个全零页面,不会发生缺页故障,也不会为其分配相应的物理内存。

         运行时数据段和BSS段的整个区段通常称为数据区。某些资料中“数据段”指代数据段 + BSS段 + 堆。

     

    7 代码段(text)

         代码段也称正文段或文本段,通常用于存放程序执行代码(即CPU执行的机器指令)。一般C语言执行语句都编译成机器代码保存在代码段。通常代码段是可共享的,因此频繁执行的程序只需要在内存中拥有一份拷贝即可。代码段通常属于只读,以防止其他程序意外地修改其指令(对该段的写操作将导致段错误)。某些架构也允许代码段为可写,即允许修改程序。

         代码段指令根据程序设计流程依次执行,对于顺序指令,只会执行一次(每个进程);若有反复,则需使用跳转指令;若进行递归,则需要借助栈来实现。

         代码段指令中包括操作码和操作对象(或对象地址引用)。若操作对象是立即数(具体数值),将直接包含在代码中;若是局部数据,将在栈区分配空间,然后引用该数据地址;若位于BSS段和数据段,同样引用该数据地址。

         代码段最容易受优化措施影响。

     

    8 保留区

         位于虚拟地址空间的最低部分,未赋予物理地址。任何对它的引用都是非法的,用于捕捉使用空指针和小整型值指针引用内存的异常情况。

         它并不是一个单一的内存区域,而是对地址空间中受到操作系统保护而禁止用户进程访问的地址区域的总称。大多数操作系统中,极小的地址通常都是不允许访问的,如NULL。C语言将无效指针赋值为0也是出于这种考虑,因为0地址上正常情况下不会存放有效的可访问数据。

         在32位X86架构的Linux系统中,用户进程可执行程序一般从虚拟地址空间0x08048000开始加载。该加载地址由ELF文件头决定,可通过自定义链接器脚本覆盖链接器默认配置,进而修改加载地址。0x08048000以下的地址空间通常由C动态链接库、动态加载器ld.so和内核VDSO(内核提供的虚拟共享库)等占用。通过使用mmap系统调用,可访问0x08048000以下的地址空间。

         通过cat /proc/self/maps命令查看加载表如下:

     

    【扩展阅读】分段的好处

         进程运行过程中,代码指令根据流程依次执行,只需访问一次(当然跳转和递归可能使代码执行多次);而数据(数据段和BSS段)通常需要访问多次,因此单独开辟空间以方便访问和节约空间。具体解释如下:

         当程序被装载后,数据和指令分别映射到两个虚存区域。数据区对于进程而言可读写,而指令区对于进程只读。两区的权限可分别设置为可读写和只读。以防止程序指令被有意或无意地改写。

         现代CPU具有极为强大的缓存(Cache)体系,程序必须尽量提高缓存命中率。指令区和数据区的分离有利于提高程序的局部性。现代CPU一般数据缓存和指令缓存分离,故程序的指令和数据分开存放有利于提高CPU缓存命中率。

         当系统中运行多个该程序的副本时,其指令相同,故内存中只须保存一份该程序的指令部分。若系统中运行数百进程,通过共享指令将节省大量空间(尤其对于有动态链接的系统)。其他只读数据如程序里的图标、图片、文本等资源也可共享。而每个副本进程的数据区域不同,它们是进程私有的。

         此外,临时数据及需要再次使用的代码在运行时放入栈区中,生命周期短。全局数据和静态数据可能在整个程序执行过程中都需要访问,因此单独存储管理。堆区由用户自由分配,以便管理。



    二:Linux 中的各种栈:进程栈 线程栈 内核栈 中断栈

    (转自:Linux 中的各种栈:进程栈 线程栈 内核栈 中断栈,不过我只转了他的部分内容,感兴趣可以去看)

    Linux 中有几种栈?各种栈的内存位置?

    介绍完栈的工作原理和用途作用后,我们回归到 Linux 内核上来。内核将栈分成四种:

    • 进程栈
    • 线程栈
    • 内核栈
    • 中断栈

    一、进程栈

    进程栈是属于用户态栈,和进程 虚拟地址空间 (Virtual Address Space) 密切相关。那我们先了解下什么是虚拟地址空间:在 32 位机器下,虚拟地址空间大小为 4G。这些虚拟地址通过页表 (Page Table) 映射到物理内存,页表由操作系统维护,并被处理器的内存管理单元 (MMU) 硬件引用。每个进程都拥有一套属于它自己的页表,因此对于每个进程而言都好像独享了整个虚拟地址空间。

    Linux 内核将这 4G 字节的空间分为两部分,将最高的 1G 字节(0xC0000000-0xFFFFFFFF)供内核使用,称为内核空间。而将较低的3G字节(0x00000000-0xBFFFFFFF)供各个进程使用,称为 用户空间。每个进程可以通过系统调用陷入内核态,因此内核空间是由所有进程共享的。虽然说内核和用户态进程占用了这么大地址空间,但是并不意味它们使用了这么多物理内存,仅表示它可以支配这么大的地址空间。它们是根据需要,将物理内存映射到虚拟地址空间中使用。

    Linux虚拟地址空间

    Linux 对进程地址空间有个标准布局,地址空间中由各个不同的内存段组成 (Memory Segment),主要的内存段如下: 
    - 程序段 (Text Segment):可执行文件代码的内存映射 
    - 数据段 (Data Segment):可执行文件的已初始化全局变量的内存映射 
    - BSS段 (BSS Segment):未初始化的全局变量或者静态变量(用零页初始化) 
    - 堆区 (Heap) : 存储动态内存分配,匿名的内存映射 
    - 栈区 (Stack) : 进程用户空间栈,由编译器自动分配释放,存放函数的参数值、局部变量的值等 
    - 映射段(Memory Mapping Segment):任何内存映射文件

    Linux标准进程内存段布局

    而上面进程虚拟地址空间中的栈区,正指的是我们所说的进程栈。进程栈的初始化大小是由编译器和链接器计算出来的,但是栈的实时大小并不是固定的,Linux 内核会根据入栈情况对栈区进行动态增长(其实也就是添加新的页表)。但是并不是说栈区可以无限增长,它也有最大限制 RLIMIT_STACK (一般为 8M),我们可以通过 ulimit 来查看或更改 RLIMIT_STACK 的值。

    【扩展阅读】:如何确认进程栈的大小

    我们要知道栈的大小,那必须得知道栈的起始地址和结束地址。栈起始地址 获取很简单,只需要嵌入汇编指令获取栈指针 esp 地址即可。栈结束地址 的获取有点麻烦,我们需要先利用递归函数把栈搞溢出了,然后再 GDB 中把栈溢出的时候把栈指针 esp 打印出来即可。代码如下:

    /* file name: stacksize.c */
    
    void *orig_stack_pointer;
    
    void blow_stack() {
        blow_stack();
    }
    
    int main() {
        __asm__("movl %esp, orig_stack_pointer");
    
        blow_stack();
        return 0;
    }
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    $ g++ -g stacksize.c -o ./stacksize
    $ gdb ./stacksize
    (gdb) r
    Starting program: /home/home/misc-code/setrlimit
    
    Program received signal SIGSEGV, Segmentation fault.
    blow_stack () at setrlimit.c:4
    4       blow_stack();
    (gdb) print (void *)$esp
    $1 = (void *) 0xffffffffff7ff000
    (gdb) print (void *)orig_stack_pointer
    $2 = (void *) 0xffffc800
    (gdb) print 0xffffc800-0xff7ff000
    $3 = 8378368    // Current Process Stack Size is 8M
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    上面对进程的地址空间有个比较全局的介绍,那我们看下 Linux 内核中是怎么体现上面内存布局的。内核使用内存描述符来表示进程的地址空间,该描述符表示着进程所有地址空间的信息。内存描述符由 mm_struct 结构体表示,下面给出内存描述符结构中各个域的描述,请大家结合前面的 进程内存段布局 图一起看:

    struct mm_struct {
        struct vm_area_struct *mmap;           /* 内存区域链表 */
        struct rb_root mm_rb;                  /* VMA 形成的红黑树 */
        ...
        struct list_head mmlist;               /* 所有 mm_struct 形成的链表 */
        ...
        unsigned long total_vm;                /* 全部页面数目 */
        unsigned long locked_vm;               /* 上锁的页面数据 */
        unsigned long pinned_vm;               /* Refcount permanently increased */
        unsigned long shared_vm;               /* 共享页面数目 Shared pages (files) */
        unsigned long exec_vm;                 /* 可执行页面数目 VM_EXEC & ~VM_WRITE */
        unsigned long stack_vm;                /* 栈区页面数目 VM_GROWSUP/DOWN */
        unsigned long def_flags;
        unsigned long start_code, end_code, start_data, end_data;    /* 代码段、数据段 起始地址和结束地址 */
        unsigned long start_brk, brk, start_stack;                   /* 栈区 的起始地址,堆区 起始地址和结束地址 */
        unsigned long arg_start, arg_end, env_start, env_end;        /* 命令行参数 和 环境变量的 起始地址和结束地址 */
        ...
        /* Architecture-specific MM context */
        mm_context_t context;                  /* 体系结构特殊数据 */
    
        /* Must use atomic bitops to access the bits */
        unsigned long flags;                   /* 状态标志位 */
        ...
        /* Coredumping and NUMA and HugePage 相关结构体 */
    };
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    mm_struct 内存段

    【扩展阅读】:进程栈的动态增长实现

    进程在运行的过程中,通过不断向栈区压入数据,当超出栈区容量时,就会耗尽栈所对应的内存区域,这将触发一个 缺页异常 (page fault)。通过异常陷入内核态后,异常会被内核的 expand_stack() 函数处理,进而调用 acct_stack_growth() 来检查是否还有合适的地方用于栈的增长。

    如果栈的大小低于 RLIMIT_STACK(通常为8MB),那么一般情况下栈会被加长,程序继续执行,感觉不到发生了什么事情,这是一种将栈扩展到所需大小的常规机制。然而,如果达到了最大栈空间的大小,就会发生 栈溢出(stack overflow),进程将会收到内核发出的 段错误(segmentation fault) 信号。

    动态栈增长是唯一一种访问未映射内存区域而被允许的情形,其他任何对未映射内存区域的访问都会触发页错误,从而导致段错误。一些被映射的区域是只读的,因此企图写这些区域也会导致段错误。

    二、线程栈

    从 Linux 内核的角度来说,其实它并没有线程的概念。Linux 把所有线程都当做进程来实现,它将线程和进程不加区分的统一到了 task_struct 中。线程仅仅被视为一个与其他进程共享某些资源的进程,而是否共享地址空间几乎是进程和 Linux 中所谓线程的唯一区别。线程创建的时候,加上了 CLONE_VM 标记,这样 线程的内存描述符 将直接指向 父进程的内存描述符。

      if (clone_flags & CLONE_VM) {
        /*
         * current 是父进程而 tsk 在 fork() 执行期间是共享子进程
         */
        atomic_inc(&current->mm->mm_users);
        tsk->mm = current->mm;
      }
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    虽然线程的地址空间和进程一样,但是对待其地址空间的 stack 还是有些区别的。对于 Linux 进程或者说主线程,其 stack 是在 fork 的时候生成的,实际上就是复制了父亲的 stack 空间地址,然后写时拷贝 (cow) 以及动态增长。然而对于主线程生成的子线程而言,其 stack 将不再是这样的了,而是事先固定下来的,使用 mmap 系统调用,它不带有 VM_STACK_FLAGS 标记。这个可以从 glibc 的nptl/allocatestack.c 中的 allocate_stack() 函数中看到:

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

    由于线程的 mm->start_stack 栈地址和所属进程相同,所以线程栈的起始地址并没有存放在 task_struct 中,应该是使用 pthread_attr_t 中的 stackaddr 来初始化 task_struct->thread->sp(sp 指向 struct pt_regs 对象,该结构体用于保存用户进程或者线程的寄存器现场)。这些都不重要,重要的是,线程栈不能动态增长,一旦用尽就没了,这是和生成进程的 fork 不同的地方。由于线程栈是从进程的地址空间中 map 出来的一块内存区域,原则上是线程私有的。但是同一个进程的所有线程生成的时候浅拷贝生成者的 task_struct 的很多字段,其中包括所有的vma,如果愿意,其它线程也还是可以访问到的,于是一定要注意。

    三、进程内核栈

    在每一个进程的生命周期中,必然会通过到系统调用陷入内核。在执行系统调用陷入内核之后,这些内核代码所使用的栈并不是原先进程用户空间中的栈,而是一个单独内核空间的栈,这个称作进程内核栈。进程内核栈在进程创建的时候,通过 slab 分配器从 thread_info_cache 缓存池中分配出来,其大小为 THREAD_SIZE,一般来说是一个页大小 4K;

    union thread_union {                                   
            struct thread_info thread_info;                
            unsigned long stack[THREAD_SIZE/sizeof(long)];
    };                                                     
      
    • 1
    • 2
    • 3
    • 4
    • 1
    • 2
    • 3
    • 4

    thread_union 进程内核栈 和 task_struct 进程描述符有着紧密的联系。由于内核经常要访问 task_struct,高效获取当前进程的描述符是一件非常重要的事情。因此内核将进程内核栈的头部一段空间,用于存放 thread_info 结构体,而此结构体中则记录了对应进程的描述符,两者关系如下图(对应内核函数为 dup_task_struct()):

    进程内核栈与进程描述符

    有了上述关联结构后,内核可以先获取到栈顶指针 esp,然后通过 esp 来获取 thread_info。这里有一个小技巧,直接将 esp 的地址与上 ~(THREAD_SIZE - 1) 后即可直接获得 thread_info 的地址。由于 thread_union 结构体是从thread_info_cache 的 Slab 缓存池中申请出来的,而 thread_info_cache 在 kmem_cache_create 创建的时候,保证了地址是 THREAD_SIZE 对齐的。因此只需要对栈指针进行 THREAD_SIZE 对齐,即可获得 thread_union 的地址,也就获得了 thread_union 的地址。成功获取到 thread_info 后,直接取出它的 task 成员就成功得到了task_struct。其实上面这段描述,也就是 current 宏的实现方法:

    register unsigned long current_stack_pointer asm ("sp");
    
    static inline struct thread_info *current_thread_info(void)  
    {                                                            
            return (struct thread_info *)                        
                    (current_stack_pointer & ~(THREAD_SIZE - 1));
    }                                                            
    
    #define get_current() (current_thread_info()->task)
    
    #define current get_current()                       
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    四、中断栈

    进程陷入内核态的时候,需要内核栈来支持内核函数调用。中断也是如此,当系统收到中断事件后,进行中断处理的时候,也需要中断栈来支持函数调用。由于系统中断的时候,系统当然是处于内核态的,所以中断栈是可以和内核栈共享的。但是具体是否共享,这和具体处理架构密切相关。

    X86 上中断栈就是独立于内核栈的;独立的中断栈所在内存空间的分配发生在 arch/x86/kernel/irq_32.c 的irq_ctx_init() 函数中(如果是多处理器系统,那么每个处理器都会有一个独立的中断栈),函数使用 __alloc_pages在低端内存区分配 2个物理页面,也就是8KB大小的空间。有趣的是,这个函数还会为 softirq 分配一个同样大小的独立堆栈。如此说来,softirq 将不会在 hardirq 的中断栈上执行,而是在自己的上下文中执行。

    中断栈

    而 ARM 上中断栈和内核栈则是共享的;中断栈和内核栈共享有一个负面因素,如果中断发生嵌套,可能会造成栈溢出,从而可能会破坏到内核栈的一些重要数据,所以栈空间有时候难免会捉襟见肘。



    Linux 为什么需要区分这些栈?

    为什么需要区分这些栈,其实都是设计上的问题。这里就我看到过的一些观点进行汇总,供大家讨论:

    1. 为什么需要单独的进程内核栈?

      • 所有进程运行的时候,都可能通过系统调用陷入内核态继续执行。假设第一个进程 A 陷入内核态执行的时候,需要等待读取网卡的数据,主动调用 schedule() 让出 CPU;此时调度器唤醒了另一个进程 B,碰巧进程 B 也需要系统调用进入内核态。那问题就来了,如果内核栈只有一个,那进程 B 进入内核态的时候产生的压栈操作,必然会破坏掉进程 A 已有的内核栈数据;一但进程 A 的内核栈数据被破坏,很可能导致进程 A 的内核态无法正确返回到对应的用户态了;
    2. 为什么需要单独的线程栈?

      • Linux 调度程序中并没有区分线程和进程,当调度程序需要唤醒”进程”的时候,必然需要恢复进程的上下文环境,也就是进程栈;但是线程和父进程完全共享一份地址空间,如果栈也用同一个那就会遇到以下问题。假如进程的栈指针初始值为 0x7ffc80000000;父进程 A 先执行,调用了一些函数后栈指针 esp 为 0x7ffc8000FF00,此时父进程主动休眠了;接着调度器唤醒子线程 A1: 
        • 此时 A1 的栈指针 esp 如果为初始值 0x7ffc80000000,则线程 A1 一但出现函数调用,必然会破坏父进程 A 已入栈的数据。
        • 如果此时线程 A1 的栈指针和父进程最后更新的值一致,esp 为 0x7ffc8000FF00,那线程 A1 进行一些函数调用后,栈指针 esp 增加到 0x7ffc8000FFFF,然后线程 A1 休眠;调度器再次换成父进程 A 执行,那这个时候父进程的栈指针是应该为 0x7ffc8000FF00 还是 0x7ffc8000FFFF 呢?无论栈指针被设置到哪个值,都会有问题不是吗?
    3. 进程和线程是否共享一个内核栈?

      • No,线程和进程创建的时候都调用 dup_task_struct 来创建 task 相关结构体,而内核栈也是在此函数中 alloc_thread_info_node 出来的。因此虽然线程和进程共享一个地址空间 mm_struct,但是并不共享一个内核栈。
    4. 为什么需要单独中断栈?

      • 这个问题其实不对,ARM 架构就没有独立的中断栈。


    三:自己的总结


    上面的图都很好,但我觉得这张图更形象,32位进程栈大小是8M,理论上堆区最大大小约为2.9G,所以还是蛮大的。

    从上面两篇文章,我知道的线程栈是使用mmap系统调用分配的空间,但是mmap分配的系统空间是什么呢?也就是上图中的mmap区域或者说共享的内存映射区域是什么呢?它的方向是向上生长还是向下生长的?

    下面两幅图给出了答案:


    图一:


    图二:


    所以,mmap其实和堆一样,实际上可以说他们都是动态内存分配,但是严格来说mmap区域并不属于堆区,反而和堆区会争用虚拟地址空间。

    这里要提到一个很重要的概念,内存的延迟分配,只有在真正访问一个地址的时候才建立这个地址的物理映射,这是Linux内存管理的基本思想。Linux内核在用户申请内存的时候,只是给它分配了一个线性区(也就是虚拟内存),并没有分配实际物理内存;只有当用户使用这块内存的时候,内核才会分配具体的物理页面给用户,这时候才占用宝贵的物理内存。内核释放物理页面是通过释放先行区,找到其对应的物理页面,将其全部释放的过程。

    这篇文章关于mmap生长方向说的也挺详细的: 进程地址空间的布局(整理)


    最后还有一个mmap机制的源代码分析博客,我水平暂时不够,只能看懂意思,待日后阅读内核源码再来回顾一遍:Linux用户空间线程管理介绍之二:创建线程堆栈


    补充文章:
    转载来源:
    展开全文
  • 【Linux系统编程】线程栈大小

    千次阅读 2019-11-07 18:12:11
    00. 目录 文章目录00. 目录01. 概述02. 设置线程栈函数03....01. 概述 先来讲说线程内存相关的东西,主要有下面几条: ...线程栈可以通过暴露栈地址的方式与其它线程进行共享。 有大数据量处理的应用中,有时...
  • Linux 中的各种栈:进程栈 线程栈 内核栈 中断栈

    万次阅读 多人点赞 2016-09-01 21:52:02
    是什么?有什么作用?首先, (stack) 是一种串列形式的 数据结构。这种数据结构的特点是 后入先出 (LIFO, Last In First Out),数据只能在串列的一端 (称为:栈顶 top) 进行 推入 (push) 和 弹出 (pop) 操作...
  • 线程栈和进程栈 区别

    2014-09-18 16:40:14
    要搞清线程栈和进程栈的区别,首先要弄清线程和进程之间的关系。 线程和进程有很多类似的地方,人们习惯上把线程称为轻量级进程,这个所谓的轻量级是指线程并拥有自己的系统资源,线程依附于创建自己的...
  • Linux 进程栈和线程栈的区别

    万次阅读 2012-11-05 11:31:14
    这里有如下几个问题,线程栈空间是开辟在那里的? 线程栈之间可以互访吗?为什么在使用pthread_attr_setstack函数时,需要设置栈的大小,而进程task_struct的 mm_struct *mm 成员中却并没有却并没有stack_size
  • 进程栈与线程栈的关系

    千次阅读 2018-05-24 13:33:49
    可以看到pthread库是通过调用mmap()来为新的线程创建栈空间的,可以在细看一下它的参数,它使用了flag MAP_ANONYMOUS和MAP_PRIVATE,而且fd参数中用了-1,这样调用的结果是在进程空间中创建一个匿名的 线性区,...
  • linux线程栈与进程栈

    千次阅读 2018-07-07 17:09:00
    1 线程使用方法 pthread_create用于创建一个线程,pthread_join用于等待线程执行完毕,简单应用如下: #include&amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;gt; #include&amp;amp;...
  • 内核栈空间和用户栈空间

    千次阅读 2017-05-01 11:20:18
    内核栈空间和用户栈空间 kernel stack and user space stack简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程,使得多线程程序的并发性高。 另外,进程在执行过程中拥有独立的内存...
  • 关于java多线程堆和共享问题

    千次阅读 2018-07-19 13:40:27
    在多线程环境下,每个线程拥有一个和一个程序计数器。和程序计数器用来保存线程的执行历史和线程的执行状态,是线程私有的资源。其他的资源(比如堆、地址空间、全局变量)是由同一个进程内的多个线程共享...
  • 线程的数据共享不共享

    千次阅读 2017-04-08 21:42:51
    我们都知道java会为每一个对象都会创建自己的局部变量和堆空间,所以要想线程的数据不共享,最直接的方式就是在每个线程中运行的代码都不是同一个实例对象就好了
  • 线程栈的说明、使用及解析

    千次阅读 2014-07-22 00:12:27
    线程栈:  线程包含了表示进程内执行环境必需的信息,其中包括进程中标示线程的线程ID,一组寄存器值,栈,调度优先级和策略, 信号屏蔽字,errno变量以及线程私有数据。进程的所有信息对该进程的所有线程都是...
  • 看来其他人的几篇文章,可能理解也不是很到位 内核、用户 32位linux系统上,进程的地址空间为4G,包括1G的内核地址空间-----内核,和3G的用户地址空间-----用户
  • 测试环境: Linux centos-7.shared 3.10.0-693.5.2.el7.x86_64 #1 SMP Fri ...一个进程的虚拟地址空间一般可以大致划分为代码区(text)、只读数据区(rodata)、初始化数据区(data)、为初始化数据区(bss)、堆(heap)、共...
  • 《windows核心编程系列》十五谈谈windows线程栈

    千次阅读 多人点赞 2011-11-21 22:51:06
    谈谈windows线程栈。 当系统创建线程时会为线程预订一块地址空间区域,注意仅仅是预订。默认情况下预定的这块区域的大小是1MB,虽然预订这么多,但是系统并不会给全部区域调拨物理存储器。默认情况下,仅仅为两个...
  • 共享栈(多线程

    千次阅读 2016-08-07 22:51:33
    线程互斥共享”资源public class myStack { //共享栈:先进后出 int idx=0; char[] c=new char[9]; void put(char ch){ //同步块:对象锁是指定的 synchronized (this) { c[idx++] = ch;
  • 由于堆是在进程空间中开辟出来的,所以它是理所当然地被共享的;因此new出来的都是共享的(16位平台上分全局堆和局部堆,局部堆是独享的) 全局变量 。它是与具体某一函数无关的,所以也与特定线程无关;因此也是...
  • 在TLAB上分配对象时需要加锁,因此JVM在给线程的对象分配内存时会尽量的在TLAB上分配,在这种情况下JVM中分配对象内存的性能和C基本是一样高效的,但如果对象过大的话则仍然是直接使用堆空间分配 TLAB仅作用于...
  • 多线程 - 你知道线程栈

    万次阅读 2013-06-20 22:48:38
    问题 ...系统中有一个栈顶指针,每次分配和回收local 变量时,其实就是移动指针。 2. static local变量的分配风险 void func2(){  static int a = 0; } 这个变量a可能会被分配多次,因为如果
  • 多线程 - 你知道线程栈吗(私有栈)

    千次阅读 2014-02-17 17:48:36
    问题 ...系统中有一个栈顶指针,每次分配和回收local 变量时,其实就是移动指针。 2. static local变量的分配风险 void func2(){  static int a = 0; } 这个变量a可能会被分配多次,因为如果

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 132,308
精华内容 52,923
关键字:

线程栈空间不共享