线程概念&&控制

目录

1.linux线程概念

1.1啥是线程

1.2分页式存储管理

1.2.1虚拟地址和页表的由来

1.2.2物理内存管理

1.2.3页表

1.2.4页目录结构

1.2.5两级页表的地址转换

1.2.6缺页异常

1.3线程的优点

1.4线程的缺点

1.5线程异常

1.6线程用途

1.7其他

2.linux进程vs线程

2.1进程和线程

2.2进程的多个线程共享

3.Linux线程控制

3.1POSIX线程库

3.2创建线程

3.3线程终止

3.3.1pthread_exit函数

3.3.2pthread_cancel函数

3.4线程等待

3.5分离线程

3.6例子

3.7c++多线程

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

5.线程封装

5.v1:

Thread.hpp

Thread.cc

makefile

[5. v2](#5. v2)

Thread.hpp

Thread.cc

[5. v3:](#5. v3:)

Thread.cc

Thread.hpp

---

1.linux线程概念

从书上，我们可以发现，进程和线程在理论上其实是要分开单独设计的（进程PCB，线程TCB）。

但实际我们可以发现，进程和线程很多结构、算法都是相似的，而且还多了额外的维护内容（进程和所属线程）。因此，linux的设计者认为，进程和线程没必要单独设计，而是直接复用代码。也就是用进程模拟线程。

题外话，windows就是采用书上的这里理论设计来实现的，有单独的线程数据结构。

1.1啥是线程

在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是"一个进程内部的控制序列"

一切进程至少都有一个执行线程

线程在进程内部运行，本质是在进程地址空间内运行

在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化

透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流

网图：

很好理解，最简单的就是把代码区划分起来，让不同的线程执行不同区域的代码，其他进程地址空间的数据共享。

我们前面说了，进程模拟线程，代码复用的事情。最典型的就是调度问题，我们之前一直说进程的调度算法，但实际上，linux系统不需要分清线程和进程，因为linux的调度算法是以task_struct为单位的，不需要分清这个task_struct究竟是进程还是线程，因为不影响执行（有了task_struct就有优先级等等东西）。

像是虚拟机，里面的系统其实就是一个进程，只是分配了很多物理内存和磁盘空间。

1.2分页式存储管理

多个执行流是如何进行代码划分？如下

1.2.1虚拟地址和页表的由来

思考一下，如果在没有虚拟内存和分页机制的情况下，每一个用户程序在物理内存上所对应的空间必须是连续的，但是：

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

怎么办呢？我们希望操作系统提供给用户的空间必须是连续的，但是物理内存最好不要连续。此时拟内存和分页便出现了，如下图所示：

把物理内存按照一个固定的长度的页框进行分割，有时叫做物理页。每个页框包含一个物理页(page）。一个页的大小等于页框的大小。大多数 32位体系结构支持 4KB的页，而64位体系结构一般会支持8KB的页。区分一页和一个页框是很重要的：

页框/页帧是一个存储区域 ；

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

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

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

另外，我们前面讲文件系统的时候也说了，一个文件有很多数据块而一个数据块的带下，通常是4KB，这就是对应了页的大小，可以直接填入 。

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

1.2.2物理内存管理

假设一个可用的物理内存有4GB的空间。按照一个页框的大小4KB进行划分(所以os进行内存管理的基本单位通常是4KB,写时拷贝也基本是4KB位单位拷贝的)，4GB的空间就是4GB/4KB=1048576个页框。有这么多的物理页，操作系统肯定是要将其管理起来的，操作系统需要知道哪些页正在被使用，哪些页空闲等等。

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

/* include/linux/mm_types.h */
struct page {
    /* 原子标志，有些情况下会异步更新 */
    unsigned long flags;
    union {
        struct {
            /* 换出页列表，例如由zone->lru_lock保护的active_list */
            struct list_head lru;
            /* 如果最低为0，则指向inode
             * address_space, 或为NULL
             * 如果页映射为匿名内存，最低为位置
             * 而且该指针指向anon_vma对象
             */
            struct address_space* mapping;
            /* 在映射内的偏移量 */
            pgoff_t index;
            /*
             * 由映射私有，不透明数据
             * 如果设置了PagePrivate，通常用于buffer_heads
             * 如果设置了PageSwapCache，则用于swp_entry_t
             * 如果设置了PG_buddy，则用于表示伙伴系统中的阶
             */
            unsigned long private;
        };
        struct {
            /* slab, slob and slub */
            union {
                struct list_head slab_list; /* uses lru */
            }
        }
#ifdef CONFIG_64BIT
        int pages; /* Nr of pages left */
        int pobjects; /* Approximate count */
#else
        short int pages;
        short int pobjects;
#endif
    };
    struct kmem_cache* slab_cache; /* not slob */
    /* Double-word boundary */
    void* freelist; /* first free object */
    union {
        void* s_mem; /* slab: first object */
        unsigned long counters; /* SLUB */
        struct {
            /* SLUB */
            unsigned inuse: 16; /* 用于SLUB分配器:对象的数目 */
            unsigned objects: 15;
            unsigned frozen: 1;
        };
    };
    union {
        /* 内存管理子系统中映射的页表项计数，用于表示页是否已经映射，还用于限制逆向映射
        捞素 */
        atomic_t _mapcount;
        unsigned int page_type;
        unsigned int active; /* SLAB */
        int units; /* SLOB */
    };
#if defined(WANT_PAGE_VIRTUAL)
    /* 内核虚拟地址（如果没有映射则为NULL，即高端内存） */
    void* virtual;
#endif /* WANT_PAGE_VIRTUAL */
...

flags：用来存放页的状态。这些状态包括页是不是脏的，是不是被锁定在内存中等。flag的每一位单独表示一种状态，所以它至少可以同时表示出32种不同的状态。这些标志定义在<linux/page-flags.h>中。其中一些比特位非常重要，如PG_locked用于指定页是否锁定，PG_uptodate用于表示页的数据已经从块设备读取并且没有出现错误。

#define PG_locked       0       /* Page is locked. Don't touch. */
#define PG_error        1
#define PG_referenced   2
#define PG_uptodate     3

#define PG_dirty        4
#define PG_lru          5
#define PG_active       6
#define PG_slab         7       /* slab debug (Suparna wants this) */
#define PG_checked      8       /* kill me in 2.5.<early>. */
#define PG_arch_1       9
#define PG_reserved     10
#define PG_private      11      /* Has something at ->private */
#define PG_writeback    12      /* Page is under writeback */
#define PG_nosave       13      /* Used for system suspend/resume */
#define PG_compound     14      /* Part of a compound page */
#define PG_swapcache    15      /* Swap page: swp_entry_t in private */
#define PG_mappedtodisk 16      /* Has blocks allocated on-disk */
#define PG_reclaim      17      /* To be reclaimed asap */
#define PG_nosave_free  18      /* Free, should not be written */
#define PG_buddy        19      /* Page is free, on buddy lists */

_mapcount ：表示在页表中有多少项指向该页，也就是这一页被引用了多少次（就是前面说文件系统的时候，所谓的sturct file删除一个文件，是引用计数--）。当计数值变为-1时，就说明当前内核并没有引用这一页，于是在新的分配中就可以使用它。

virtual：是页的虚拟地址。通常情况下，它就是页在虚拟内存中的地址。有些内存（即所谓的高端内存）并不永久地映射到内核地址空间上。在这种情况下，这个域的值为NULL，需要的时候，必须动态 地映射这些页。

---

要注意的是struct page 与物理页相关，而并非与虚拟页相关。而系统中的每个物理页都要分配一个这样的结构体(通过struct page 数组来管理这些page,下标就是第几块内存块 )，让我们来算算对所有这些页都这么做，到底要消耗掉多少内存。

算 struct page 占40个字节的内存吧，假定系统的物理页为 4KB 大小，系统有 4GB 物理内存。那么系统中共有页面1048576个（1兆个），所以描述这么多页面的page结构体消耗的内存只不过40MB，相对系统4GB 内存而言，仅是很小的一部分罢了。因此，要管理系统中这么多物理页面，这个代价并不算太大。

要知道的是，页的大小对于内存利用和系统开销来说非常重要，页太大，页内必然会剩余较大不能利用的空间（页内碎片）。页太小，虽然可以减小页内碎片的大小，但是页太多，会使得页表太长而占用内存，同时系统频繁地进行页转化，加重系统开销。因此，页的大小应该适中，通常为512B-8KB，windows/Linux系统的页框大小为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空间的，也许只要几十个页表就可以了。例如：一个用户程序的代码段、数据段、栈段，一共就需要1θMB 的空间，那么使用3个页表就足够了。

另外，页表里除了RWX权限，还有就是U/K权限，说明这个物理内存块是由什么态才能访问的，与cpu里的标志位结合，就能判断当前态是否能访问这个物理内存块。

1.2.4页目录结构

到目前为止，每一个页框都被一个页表中的一个表项来指向了，那么这1024个页表也需要被管理起来。管理页表的表称之为页目录表，形成二级页表。如下图所示：

所有页表的物理地址被页目录表项指向

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

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

1.2.5两级页表的地址转换

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

在32位处理器中，采用4KB的页大小，则虚拟地址中低12位(2^12==4KB)为页偏移，剩下高20位给页表，分成两级，每个级别占10个bit（10+10,2^10==1024）。

CR3寄存器读取页目录起始地址，再根据一级页号查页目录表，找到下一级页表在物理内存中存放位置。

根据二级页号查表，找到最终想要访问的内存块号。

结合页内偏移量得到物理地址。

一个物理页的地址一定是4KB对齐的(最后的12位全部为0），所以其实只需要记录物理

页地址的高20位即可。

以上其实就是MMU的工作流程。MMU(MemoryManageUnit)是一种硬件电路，其速度很快，主要工作是进行内存管理，地址转换只是它承接的业务之一。

另外，我们平时比如一个int变量4个字节，这4个字节是连续的，我们上面的转换是只能转换一个字节，但是我们知道变量的类型，变量的大小是固定的，所以只要有变量的第一个字节的地址，就可以一次连续读完整个变量的所有字节。

---

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

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

有没有提升效率的办法呢？计算机科学中的所有问题，都可以通过添加一个中间层来解决。**MMU引入了新武器，俗称快表的TLB3（其实，就是缓存TranslationLookasideBuffer，学名转译后备缓冲器）**当CPU给MMU 传新虚拟地址之后，MMU先去问TLB 那边有没有，如果有就直接拿到物理地址发到总线给内存，齐活。但TLB 容量比较小，难免发CacheMiss，这时候 MMU 还有保底的老武器页表，在页表中找到之后MMU除了把地址发到总线传给内存，还把这条映射关系给到TLB，让它记录一下刷新缓存。

1.2.6缺页异常

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

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

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

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

Hard Page Fault 也被称为 Major Page Fault，翻译为硬缺页错误/主要缺页错误，这

时物理内存中没有对应的物理页，需要CPU打开磁盘设备读取到物理内存中，再让MMU建立虚拟地址和物理地址的映射。

Soft Page Fault 也被称为 Minor Page Fault，翻译为软缺页错误/次要缺页错误，这

时物理内存中是存在对应物理页的，只不过可能是其他进程调入的，发出缺页异常的进程不知道而已，此时MMU只需要建立映射即可，无需从磁盘读取写入内存，一般出现在多进程共享内存区域。

Invalid PageFault 翻译为无效缺页错误，比如进程访问的内存地址越界访问，又比如对

空指针解引用，内核就会报segment fault 错误，中断进程直接挂掉。

如何理解我们之前的new和malloc？

如何理解我们之前学习的写时拷贝？

申请内存，究竟是在干什么？

如何区分是缺页了，还是真的越界了？

一个问题，越界了一定会报错吗？

1．页号合法性检查 ：操作系统在处理中断或异常时，首先检查触发事件的虚拟地址的页号是否合法。如果页号合法但页面不在内存中，则为缺页中断；如果页号非法，则为越界访问。

2.内存映射检查 ：操作系统还可以检查触发事件的虚拟地址是否在当前进程的内存映射范围内。如果地址在映射范围内但页面不在内存中，则为缺页中断；如果地址不在映射范围

内，则为越界访问。

线程资源划分的真相：只要将虚拟地址空间进行划分，进程资源就天然被划分好了。

给不同的线程分配不同的区域，本质就是给不同的线程，各自看到全部页表的子集。

1.3线程的优点

创建一个新线程的代价要比创建一个新进程小得多

与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多

最主要的区别是线程的切换，虚拟内存空间依然是相同的，但是进程切换是不同的 。这两种上下文切换的处理都是通过操作系统内核来完成的。内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出(但实际上进程切换和线程切换在寄存器切换上虽然消耗后者比前者低一点，但低的其实不多，对于cpu来说是很快的，真正大幅度减少开销的是下面) 。

另外一个隐藏的损耗是上下文的切换会扰乱处理器的缓存机制 。简单的说，一旦去切换上下文，处理器中所有已经缓存的内存地址一瞬间都作废了（硬件cache，高速缓冲存储器）。还有一个显著的区别是当你改变虚拟内存空间的时候，处理的页表缓冲TLB（快表）会被全部刷新，这将导致内存的访问在一段时间内相当的低效。这些缓存机制的切换开销是很大的，而线程切换是不需要作废这些缓存数据的（因为线程的进程地址空间资源是共享的，不需要放弃已缓存内容的），这样就减少了系统开销 。

线程占用的资源要比进程少

能充分利用多处理器的可并行数量

在等待慢速I/O操作结束的同时，程序可执行其他的计算任务

计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现

I/O密集型应用，为了提高性能，将I/O操作重叠（比如下10g数据，一个线程下1g，同时等待IO操作，这样就可以提高效率）。多线程可以同时等待不同的I/O操作。

1.4线程的缺点

性能损失

一个很少被外部事件阻塞的计算密集型线程往往无法与其它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变，所以建议计算密集型程序的线程数量控制在跟cpu核的数量一样（如果是单进程的话，多进程还要考虑更多）。
健壮性降低

编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。
缺乏访问控制

进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。(比如当一个线程执行exit函数，会终止整个进程，导致该进程内所有线程一起结束。)
编程难度提高

编写与调试一个多线程程序比单线程程序困难得多

1.5线程异常

单个线程如果出现除零，野指针问题导致线程崩溃，进程也会随着崩溃

线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该进程内的所有线程也就随即退出

1.6线程用途

合理的使用多线程，能提高CPU密集型程序的执行效率

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

1.7其他

凡是这类一个线程出问题（可能是异常也可能是其他原因，比如不小心调用了exit，修改其他线程本不该修改数据等待）导致其他线程出问题，最后整个进程退出，统称为-----线程安全问题

多线程中，公共函数如果被多个线程同时进入---该函数被重入了。所以我们也能发现，像printf这些函数，都是不可重入的（最典型的就是输出到屏幕的时候混乱）

2.linux进程vs线程

进程间具有独立性

线程共享地址空间，也就共享进程资源

进程是内核数据结构+代码数据，单单一个task_struct只能称为一个线程或者一个执行流。

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

2.1进程和线程

进程是资源分配的基本单位

线程是调度的基本单位

线程共享进程数据，但也拥有自己的一部分"私有"数据 ：

线程ID

一组寄存器，线程的上下文数据

栈

errno

信号屏蔽字

调度优先级

2.2进程的多个线程共享

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

文件描述符表

每种信号的处理方式(SIG_IGN、SIG_DFL或者自定义的信号处理函数）

当前工作目录

用户id和组id

总结下，多线程下，同一个进程的资源所有线程共享。

3.Linux线程控制

linux没有真正意义上的线程，只有轻量级进程。

用户不知道轻量级进程的概念，只知道进程和线程。

linux系统不会有线程相关的系统调用，只有轻量级进程的系统调用

3.1POSIX线程库

只要是linux系统，都会自带一个pthread库，原生线程库，这个库就是将轻量级进程的系统调用封装成线程相关的接口语义提供给用户。

但这个库并不是内核里的，而是用户层实现的封装，所以有时候也叫用户级线程。

与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以"pthread_"打头的

要使用这些函数库，要通过引入头文件<pthread.h>

因为pthread本质就是一个动态库，所以链接这些线程函数库时要使用编译器命令的"-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；失败返回错误码

这个底层是用了linux提供的轻量级进程的接口clone

错误检查：

传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。

pthreads函数出错时不会设置全局变量errno（而大部分其他POSIX函数会这样做）。而是将错误代码通过返回值返回

pthreads同样也提供了线程内的errno变量，以支持其它使用errno的代码。对于pthreads函数的错误，建议通过返回值来判定，因为读取返回值要比读取线程内的errno变量的开销更小

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include<cstring>
using namespace std;


void *rout(void *arg){
    int i;
    for(;;){
        cout<<"'I'am thread 1"<<endl;
        sleep(1);
    }
}

int main()
{
    pthread_t tid;
    int ret;
    if((ret=pthread_create(&tid,NULL,rout,NULL))!=0){
        cerr<<"pthread_create : "<<strerror(ret)<<endl;
        exit(EXIT_FAILURE);
    }
    int i;
    for(;;){
        cout<<"'I'am main thread"<<endl;
        sleep(1);
    }
}

返回线程ID：pthread_t pthread_self(void);

打印出来的 tid 是通过 pthread 库中有函数 pthread_self 得到的，它返回一个 pthread_t 类型的变量，指代的是调用pthread_self函数的线程的"ID"。

怎么理解这个"ID"呢？这个"ID"是pthread 库给每个线程定义的进程内唯一标识，是pthread库维持的 。

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

-L选项，打印线程信息。

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

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

os在调度的时候，看的是LWP，注意，前面我们讲进程时候，说看PID，正是因为主线程的PID和LWP是一样的，所以才没区别，现在是多线程了，所以要区分下。

函数编译完成后是若干行代码块，每行代码都有虚拟地址，函数名是该代码块的入口地址，不同线程执行不同函数，就是分给不同线程不同的代码，以达到并行的目的。

注意，线程之间谁先执行，我们无法确定，只有调度器能够决定。 基于此，我们前面的例子代码中，同时向屏幕打印，会出现混在一起的现象，因为屏幕在此时就是一个共享资源，且是没有保护的共享资源，那么就如同共享内存一样，同时写入会出现错乱**。**

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include<cstring>
#include<string>
using namespace std;

string ToHex(pthread_t id){
    char ret[100];
    snprintf(ret,sizeof(ret),"0x%lx",id);
    return ret;
}

void* run(void*arg){
    int cnt=5;
    string threadname=(char*)arg;
    while(cnt--){
        cout<<threadname<<" is runing: "<<cnt<<",pid: "<<getpid()
        <<" mythread id: "<<ToHex(pthread_self())<<endl;
    }
    return nullptr;
} 

int main()
{
    pthread_t tid;
    pthread_create(&tid,nullptr,run,(void*)"thread-1");
    
    int cnt=5;
    while(cnt--){
        cout<<" main thread is running "<<cnt<<",pid: "<<getpid()<<
        " new thread id: "<<ToHex(tid)<<" "<<"main thread id: "
        <<ToHex(pthread_self())<<endl;
        sleep(1);
    }
    return 0;
}

3.3线程终止

任何一个线程出现异常，整个进程都会退出！--意味着多线程代码的健壮性不好

不能用exit来终止特定线程，因为exit是直接终止进程，所有线程都会退出。

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

1.从线程函数return。这种方法对主线程不适用，从main函数return相当于调用exit。

2.线程可以调用pthread_exit终止自己。

3.一个线程可以调用pthread_cancel终止同一进程中的另一个线程。

3.3.1pthread_exit函数

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

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

3.3.2pthread_cancel函数

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

3.4线程等待

主线程退出==进程退出，意味着所有分配的资源被释放，所以所有线程也应该退出。

因此我们需要让主线程最后结束。

已经退出的线程，其空间没有被释放，仍然在进程的地址空间内（也就是说线程也需要被wait ，避免跟进程类似的内存泄漏的问题）。

创建新的线程不会复用刚才退出线程的地址空间。

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

该函数不考虑异常，因为线程如果出了异常，整个进程都会退出，这个函数压根就不会继续执行也就没有退出码什么的了，这也就意味着需要让父进程来处理获取异常。

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

1.如果thread线程通过return返回,value_ptr所指向的单元里存放的是thread线程函数的返回值 。

2.如果thread线程被别的线程调用pthread_cancel异常终掉,value_ptr所指向的单元里存放的是常数PTHREAD_CANCELED(是个宏，其实是(void*)-1) 。

3.如果thread线程是自己调用pthread_exit终止的,value_ptr所指向的单元存放的是传给pthread_exit的参数 。

4.如果对thread线程的终止状态不感兴趣,可以传NULL给value_ptr参数。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include<cstring>
#include<stdlib.h>
using namespace std;

void * thread1(void *arg){
    cout<<"thread 1 returning ..."<<endl;
    int*p=new int();
    *p=1;
    return (void*)p;
}

void *thread2(void*arg)
{
    cout<<"thread 2 exiting..."<<endl;
    int*p=new int();
    *p=2;
    pthread_exit((void*)p);
}

void *thread3(void*arg){
    while(true){
        cout<<"thread 3 is running..."<<endl;
        sleep(1);
    }
    return nullptr;
}
int main()
{
    pthread_t tid;
    void*ret;
    //thread return
    pthread_create(&tid,nullptr,thread1,nullptr);
    pthread_join(tid,&ret);
    cout<<"thread return,thread id "<<tid<<" return,code:"<<*(int*)ret<<endl;
    delete((int*)ret);

    //thread exit
    pthread_create(&tid,nullptr,thread2,nullptr);
    pthread_join(tid,&ret);
    cout<<"thread return,thread id "<<tid<<" return,code:"<<*(int*)ret<<endl;
    delete((int*)ret);

    //thread cancel by other
    pthread_create(&tid,nullptr,thread3,nullptr);
    sleep(3);
    pthread_cancel(tid);
    pthread_join(tid,&ret);
    if(ret==PTHREAD_CANCELED){
        cout<<"thread return, thread is id "<<tid<<" return code:PTHREAD_CANCELED"<<endl;
    }
    else{
        cout<<"thread return,thread id "<<tid<<" return code:NULL"<<endl;
    }



}

其实有个偷懒的做法，如果我们只是返回数字的话，那可以直接把数字当做地址。比如我们想返回10，那么让线程结束的时候（return和pthread_exit传参的时候），可以直接返回(void*)10。这样想要获取数字就直接cout<<(long long)ret即可(把地址强转成long long类型，注意不同系统地址长度不一样，所以要根据情况来看，32位系统就是8个字节，可以用longlong)

3.5分离线程

默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。

如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

本质就是设置了相应的状态

int pthread_detach(pthread_t thread);

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

pthread_detach(pthread_self());

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

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include<cstring>
#include<stdlib.h>
using namespace std;

void *thread_run(void*arg){
    pthread_detach(pthread_self());
    cout<<(char*)arg<<endl;
    return nullptr;
}

int main()
{
    pthread_t tid;
    char str[1024]="thread 1 run...";
    if(pthread_create(&tid,nullptr,thread_run,&str)!=0)
    {
        cout<<"create thread error"<<endl;
        return 1;
    }

    int ret=0;
    sleep(1);//先让子线程分离，主线程这里要sleep。

    if(pthread_join(tid,nullptr)==0){
        cout<<"pthread wait success"<<endl;
        ret=0;
    }
    else{
        cout<<"pthread wait failed"<<endl;
        ret=1;
    }
    return ret;
}

可以发现，等待失败了，因为分离之后，资源回收的工作交给了操作系统。

注意！分离只是不需要等待，资源自动释放，但资源还是要与整个进程的其他线程共享的，所以主线程如果退出了，分离的线程也会退出（进程退出，所有线程都退出），分离线程产生异常也会导致整个进程退出。

注意，分离线程比较难控制让main thread最后退出。

我们平时的各种软件，主程序基本都是死循环形式，这样不管是分离线程还是joinable线程，都会比main thread早结束，达成让main thread线程最后退出的目的。

这种形式的程序，在进程里就是常驻进程

3.6例子

1.多线程创建

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include<vector>
#include<cstring>
#include<string>
using namespace std;

const int threadnum=5;

void* handlerTask(void*args){
    string threadname=static_cast<char*>(args);
    while(true){
        sleep(1);
        cout<<"I am "<<threadname<<endl;
    }
    delete [](char*)args;
    return nullptr;
}


//多线程创建
int main()
{
    //char threadnames[64];不能放外面，因为参数传过去是地址
    //而这里是固定了一个地址，也就是说每个线程拿到的都是同一个地址
    //但这样的话，每次snprintf都会重新在该地址重新写入内容
    //而线程5是最后一个创建的，这样就导致最后每个线程打印出来都是Thread-5
    vector<pthread_t>threads;
    for(int i=0;i<threadnum;i++){
        //char threadnames[64];也不能这样写，因为每次循坏都会重新创建数组
        //而局部变量是存在栈里的，短时间内循坏快速创建，会导致地址被重新覆盖
        //导致随机的让部分线程获取的参数是一致的（相比上面那个更加随机)

        char*threadnames=new char[64];
        //只有这样写，每次都是从堆里开辟新的空间，而堆空间不会随着循坏结束而释放
        //这样就保证了每个线程获取的地址都是不一样的，只要线程执行的函数里记得释放即可。

        snprintf(threadnames,64,"Thread-%d",i+1);
        pthread_t tid;
        pthread_create(&tid,nullptr,handlerTask,(void*)threadnames);
        threads.push_back(tid);
    }

    for(auto&tid:threads){
        pthread_join(tid,nullptr);
    }
    return 0;
}

2.采取自定义类的形式，大量传参

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include<vector>
#include<cstring>
#include<string>
using namespace std;

const int threadnum=5;

class Task{
public:
    Task(int x,int y):data(x),target(y)
    {}
    Task(){}
    int Excute(string &name){
        int x=stoi(name.substr(name.size()-1,1));
        return data+target+x;
    }
    ~Task(){}
private:
    int data,target;
};

class ThreadData{
public:
    ThreadData(int _x,int _y,string _threadname):
    threadname(_threadname),t(_x,_y)
    {}
    string TName(){
        return threadname;
    }
    int run(string&name){
        return t.Excute(name);
    }
private:
    string threadname;
    Task t;
};

void* handlerTask(void*args){
    ThreadData*td=static_cast<ThreadData*>(args);

    string name=td->TName();
    int result=td->run(name);

    cout<<name<<" run result: "<<result<<endl;
    delete td;
    
    sleep(2);
    return nullptr;
}


//多线程创建
int main()
{

    vector<pthread_t>threads;
    for(int i=0;i<threadnum;i++){

        char threadnames[64];
        snprintf(threadnames,64,"Thread-%d",i+1);
        ThreadData*td=new ThreadData(10,20,threadnames);

        pthread_t tid;
        pthread_create(&tid,nullptr,handlerTask,(void*)td);
        threads.push_back(tid);
    }

    for(auto&tid:threads){
        pthread_join(tid,nullptr);
    }
    return 0;
}

3.以自定义类的方式获取线程返回信息

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include<vector>
#include<cstring>
#include<string>
using namespace std;

const int threadnum=5;

class Task{
public:
    Task(int x,int y):data(x),target(y)
    {}
    Task(){}
    int Excute(string &name){
        int x=stoi(name.substr(name.size()-1,1));
        return data+target+x;
    }
    ~Task(){}
private:
    int data,target;
};

class ThreadData{
public:
    ThreadData(int _x,int _y,string _threadname):
    threadname(_threadname),t(_x,_y)
    {}
    string TName(){
        return threadname;
    }
    int run(string&name){
        return t.Excute(name);
    }
private:
    string threadname;
    Task t;
};

class Result{
public:
    Result(int _r,const string&name):
    result(_r),threadname(name)
    {}
    void Print(){
        cout<<threadname<<" run result: "<<result<<endl;
        return;
    }
    ~Result(){}
private:
    string threadname;
    int result;
};

void* handlerTask(void*args){
    ThreadData*td=static_cast<ThreadData*>(args);

    string name=td->TName();
    int result=td->run(name);

    //cout<<name<<" run result: "<<result<<endl;
    delete td;
    
    Result *ret=new Result(result,name);
    sleep(2);
    return (void*)ret;
}


//多线程创建
int main()
{

    vector<pthread_t>threads;
    for(int i=0;i<threadnum;i++){

        char threadnames[64];
        snprintf(threadnames,64,"Thread-%d",i+1);
        ThreadData*td=new ThreadData(10,20,threadnames);

        pthread_t tid;
        pthread_create(&tid,nullptr,handlerTask,(void*)td);
        threads.push_back(tid);
    }
    vector<Result*>results;
    void*ret=nullptr;
    for(auto&tid:threads){
        pthread_join(tid,&ret);
        results.push_back((Result*)ret);
    }

    for(auto&res:results){
        res->Print();
        delete res;
    }
    return 0;
}

3.7c++多线程

详细的内容，我会专门出一篇文章或者放在准备发布的c++IO流文章里。这里是体会一下，因为c++多线程库本质就是对原生线程库，也就是pthread库的封装(所以编译选项里必须加-lpthread)。

关于封装，我们可以发现前面的接口，是linux系统会自带的库，但是windows是有自己一套线程数据结构、算法和接口的，因此基于跨平台性，很多语言都是需要对不同系统提供的原生线程库进行封装，以达到跨平台性，像是C++的这套多线程，放在windows环境下，只要底层是用的windows环境的c++标准库，那么代码上就不会有差异，可以直接移植。

下面会专门封装一次，这里先举几个例子。

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

pthread_create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的线程ID不是一回事。

前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。

linux线程的管理工作，由库来进行管理

pthread_create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。

线程库NPTL提供了pthread_self函数，可以获得线程自身的ID：

pthread_t pthread_self(void);

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

pthread_t类型的线程ID，就是进程地址空间中共享区中pthread库映射的空间中 对应该线程的数据结构对象（可以理解为tcb，线程控制块）的首地址。库在这块空间中对线程进行管理，存储线程控制块以及存储tcb的数据结构，管理就是对这个数据结构做增删查改。

而根据图，我们也可以发现，我们以前说的栈，现在可以更新为是说主线程栈了，而其他线程的栈，是在共享区里被库维护的，这样不同线程的临时数据不会互相影响而是都在各自的栈里压入。

另外，因为资源是共享的，线程间在实际操作上，是可以访问其他线程的栈数据的，只是稍微麻烦点。

由于pthread是动态库，所以所有映射了这个库的进程，都可以创建线程，因为动态库在内存里只有一份，所以所有进程的tcb都是被同一个库（代码）一起维护的。

注意，像是我们c语言的FILE对象，其实也是c语言库维护的。
我们再来看看这个线程局部存储。我们知道全局数据是被线程共享的。如下：

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include<string>
using namespace std;

int g_val=10;

void* run1(void*arg){
    string name=static_cast<const char*>(arg);
    int cnt=5;
    while(cnt--){
        sleep(1);
        cout<<name<<", g_val: "<<g_val<<", &g_val: "<<&g_val<<endl;
    }
    return nullptr;
}
void* run2(void*arg){
        string name=static_cast<const char*>(arg);
    int cnt=5;
    while(cnt--){
        cout<<name<<", g_val: "<<g_val<<", &g_val: "<<&g_val<<endl;
        sleep(1);
        g_val++;
    }
    return nullptr;
}

int main()
{
    pthread_t tid1,tid2;
    pthread_create(&tid1,nullptr,run1,(void*)"thread-1");
    pthread_create(&tid2,nullptr,run2,(void*)"thread-2");

    pthread_join(tid1,nullptr);
    pthread_join(tid2,nullptr);
    return 0;
}

可以发现，g_val变量的地址是一样的，确实是共享的。

我们给变量改下

__thread int g_val=10;

可以发现，变量的地址是不一致的，也就是说并不是同一个变量，并且因为线程1的run1函数没有对变量做修改，所以变量值一直是10，而线程2的run2函数有修改，导致了变量的内容一直变化。

这就是线程的局部存储，将有__thread修饰的全局变量考一份到自己的线程局部存储空间中，各线程访问各自线程局部存储空间里变量，自然地址不一样，访问的也不是同一个变量了。

这种技术通常用来对所有线程都需要定义的对象进行修饰，这样不用每个线程都定义一遍，修改之后都是各自的数据，减少重复代码等。

唯一的缺陷是不能局部存储非内置类型（比如stl容器或自己定义的类对象）

5.线程封装

5.v1:

Thread.hpp

#ifndef __THREAD_HPP__
#define __THREAD_HPP__

#include<iostream>
#include<string>
#include<unistd.h>
#include<pthread.h>
#include<functional>

namespace ThreadModule{
    template<class T>
    using func_t =std::function<void(const T&)>;

    using std::cout;
    using std::cin;
    using std::endl;
    using std::string;
    template<class T>
    class Thread{
    public:
        Thread(func_t<T> func,const T&data,const string&name="default")
            :_func(func),_data(data),_threadname(name),_stop(true)
        {}
        static void *threadrun(void*arg)//注意，类成员函数有this指针，跟线程库的要求冲突了
        //这里采取静态函数的方式，这样就没有this指针了，另外也可以放在类外面
        {
            while(true){
                cout<<"I am new thread ..."<<endl;
                sleep(1);
            }
        }
        bool Start(){
            int n=pthread_create(&_tid,nullptr,threadrun,nullptr);
            if(!n){
                _stop=false;
                return true;
            }
            else{
                return false;
            }
        }
        void Detach(){
            if(!_stop){
                pthread_detach(_tid);
            }
        }
        void Join(){
            if(!_stop){
                pthread_join(_tid,nullptr);
            }
        }
        void Stop(){_stop=true;}

        ~Thread(){}
    private:
        pthread_t _tid;
        string _threadname;
        T _data;
        func_t<T> _func;
        bool _stop;
    };
}

#endif

Thread.cc

#include"Thread.hpp"

using namespace ThreadModule;

void print(const int &data){

}

int main(){
    Thread<int> t1(print,10);
    t1.Start();
    t1.Join();
    return 0;
}

makefile

thread:Thread.cc
	g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
	rm -f thread

这个版本是非常基础，只有个架子。

5. v2

Thread.hpp

#ifndef __THREAD_HPP__
#define __THREAD_HPP__

#include<iostream>
#include<string>
#include<unistd.h>
#include<pthread.h>
#include<functional>

namespace ThreadModule{
    template<class T>
    using func_t =std::function<void(T&)>;

    using std::cout;
    using std::cin;
    using std::endl;
    using std::string;
    template<class T>
    class Thread{
    public:
        Thread(func_t<T> func,const T&data,const string&name="default")
            :_func(func),_data(data),_threadname(name),_stop(true)
        {}
        void Excute(){
            _func(_data);
        }

        static void *threadrun(void*arg)//注意，类成员函数有this指针，跟线程库的要求冲突了
        //这里采取静态函数的方式，这样就没有this指针了，另外也可以放在类外面
        {
            //注意，因为_func和_data都是成员函数，访问需要this指针
            //但静态函数又没有this指针，那么就只能把this指针当参数传进threadrun函数。
            //然后将方法的调用封装在Excute这个成员函数里
            //这里就只需要用this指针直接调用Excute函数即可。
            Thread<T> *self=static_cast<Thread*>(arg);
            self->Excute();
            return nullptr;
        }
        bool Start(){
            int n=pthread_create(&_tid,nullptr,threadrun,this);
            if(!n){
                _stop=false;
                return true;
            }
            else{
                return false;
            }
        }
        void Detach(){
            if(!_stop){
                pthread_detach(_tid);
            }
        }
        void Join(){
            if(!_stop){
                pthread_join(_tid,nullptr);
            }
        }
        void Stop(){_stop=true;}
        string name(){return _threadname;}
        ~Thread(){}
    private:
        pthread_t _tid;
        string _threadname;
        T _data;
        func_t<T> _func;
        bool _stop;
    };
}

#endif

Thread.cc

#include"Thread.hpp"
#include<vector>
using namespace ThreadModule;

void print(int &data){
    while(data--){
        cout<<"I am myself thread,data: "<<data<<endl;
        sleep(1);
    }
}

const int num=5;

int main(){
    std::vector<Thread<int>>threads;
    //创建一批线程
    for(int i=0;i<num;i++){
        string name="thread-"+std::to_string(i+1);
        threads.emplace_back(print,5,name);
    }

    //启动一批线程
    for(auto &thread:threads){
        thread.Start();
    }

    //等待一批线程
    for(auto &thread:threads){
        thread.Join();
        cout<<"wait thread done,thread is: "<<thread.name()<<endl;
    }

    return 0;
}

5. v3:

加入了前面的自定义类参数，自定义类返回值（要改的地方挺多的，算是比较综合了）

Thread.cc

#include "Thread.hpp"
#include <vector>
using namespace ThreadModule;

Result* handlerTask(ThreadData &td)
{
    string name = td.TName();
    int result = td.run(name);

    delete &td;

    Result *ret = new Result(result, name);
    sleep(2);
    return ret;
}
const int num = 5;

int main()
{
    std::vector<Thread<ThreadData,Result*>> threads;
    // 创建一批线程
    for (int i = 0; i < num; i++)
    {
        string name = "thread-" + std::to_string(i + 1);
        ThreadData*td=new ThreadData(10,20,name);
        threads.emplace_back(handlerTask, *td, name);
    }

    // 启动一批线程
    for (auto &thread : threads)
    {
        thread.Start();
    }
    std::vector<Result*>results;
    void*ret=nullptr;
    // 等待一批线程
    for (auto &thread : threads)
    {
        thread.Join(&ret);
        results.emplace_back((Result*)ret);
    }
    
    //打印线程执行情况
    for(auto&res:results){
        res->Print();
        delete res;
    }

    return 0;
}

Thread.hpp

#ifndef __THREAD_HPP__
#define __THREAD_HPP__

#include <iostream>
#include <string>
#include <unistd.h>
#include <pthread.h>
#include <functional>

namespace ThreadModule
{
    template <class T,class C>
    using func_t = std::function<C(T &)>;

    using std::cin;
    using std::cout;
    using std::endl;
    using std::string;
    template <class T,class C>
    class Thread
    {
    public:
        Thread(func_t<T,C> func, T &data, const string &name = "default")
            : _func(func), _data(data), _threadname(name), _stop(true)
        {
        }
        C Excute()
        {
            return _func(_data);
        }

        static void *threadrun(void *arg) // 注意，类成员函数有this指针，跟线程库的要求冲突了
        // 这里采取静态函数的方式，这样就没有this指针了，另外也可以放在类外面
        {
            // 注意，因为_func和_data都是成员函数，访问需要this指针
            // 但静态函数又没有this指针，那么就只能把this指针当参数传进threadrun函数。
            // 然后将方法的调用封装在Excute这个成员函数里
            // 这里就只需要用this指针直接调用Excute函数即可。
            Thread<T,C> *self = static_cast<Thread *>(arg);

            return (void *)self->Excute();
        }
        bool Start()
        {
            int n = pthread_create(&_tid, nullptr, threadrun, this);
            if (!n)
            {
                _stop = false;
                return true;
            }
            else
            {
                return false;
            }
        }
        void Detach()
        {
            if (!_stop)
            {
                pthread_detach(_tid);
            }
        }
        void Join(void** ret)
        {
            if (!_stop)
            {
                pthread_join(_tid, ret);
            }
        }
        void Stop() { _stop = true; }
        string name() { return _threadname; }
        ~Thread() {}

    private:
        pthread_t _tid;
        string _threadname;
        T &_data;
        func_t<T,C> _func;
        bool _stop;
    };

    class Task
    {
    public:
        Task(int x, int y) : data(x), target(y)
        {
        }
        Task() {}
        int Excute(string &name)
        {
            int x = stoi(name.substr(name.size() - 1, 1));
            return data + target + x;
        }
        ~Task() {}

    private:
        int data, target;
    };

    class ThreadData
    {
    public:
        ThreadData(int _x, int _y, string _threadname) : threadname(_threadname), t(_x, _y)
        {
        }
        string TName()
        {
            return threadname;
        }
        int run(string &name)
        {
            return t.Excute(name);
        }

    private:
        string threadname;
        Task t;
    };

    class Result
    {
    public:
        Result(int _r, const string &name) : result(_r), threadname(name)
        {
        }
        void Print()
        {
            cout << threadname << " run result: " << result << endl;
            return;
        }
        ~Result() {}

    private:
        string threadname;
        int result;
    };

}

#endif