知识梳理------线程

一、 线程的概念
<1> 进程与线程的关系
1. 线程是轻量级进程，也有PCB。创建线程使用的底层函数和进程一样，都是clone().
2. 从内核来看，进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的。
3. 进程可以蜕变为线程
4. 在linux中，进程是资源分配的最小单位，线程是最小的执行单位。

<2> 线程间共享的资源
1. 文件描述符表
2. 每种信号的处理方式
3. 当前工作目录
4. 用户ID和组ID
5. 内存地址空间
6. text、data、bss、堆、共享库
(共享库如何被加载到内存 —> 通过mmap映射到地址空间，并要给读、执行权限。共享库在内存中只映射一份)

<3> 线程间不共享的资源

1. 线程ID(只在本进程内有效)
2. 处理器现场和栈指针(内核栈)
3. 线程自己的独立栈(用户空间栈)
4. errno变量
5. 信号屏蔽字
6. 调度优先级

二、线程原语
<1> 创建线程

#inlcude <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void* (*start_routine)(void*), void* arg);

<2> 获取调用线程的ID

pthread_t pthread_self(void);

// 注意：主线程里的pthread_create返回值tid并不一定等于子线程例pthread_self的返回值。
// 解答：pthread_create的完成步骤是
//  a.创建线程--->b.线程号填写到tid--->c.返回函数调用
// 当a执行完毕后，线程已经存在，若此时先去执行的是新线程直到其结束，那么返回的tid就没有意义了，

<3> 线程退出

调用线程退出函数，注意和exit函数的区别，任何线程里exit导致进程退出，其他线程未工作结束，主控线程退出时不能return或exit.
需要注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是 用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函 数已经退出了

// 
void pthread_exit(void *retval);
// void *retval 线程退出时传递出的参数，可以是退出值或地址，如是地址时，不能是线程内部申请的局部地址。

<4> 线程回收

int pthread_join(pthread_t thread, void **retval);
// thread           待回收线程的tid
// void **retval    接收退出线程传递的返回值(成功为0，失败为错误号)
// thread线程以不同的方法 终止，通过pthread_join得到的终止状态是不同的，包括:
//      1. 如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返回值.
//      2. 如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED
//      3. 如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给 pthread_exit的参数。 
// 若对线程结束状态不感兴趣，就将retval置为NULL

<5> 线程取消

int pthread_cancel(pthread_t thread);
// 同一进程内，一个线程去取消另一个线程。
// 被取消的线程的退出值是PTHREAD_CANCELED为-1.

<6> 分离态线程
分离态线程不需要主线程去回收，运行完后会自动消亡(此时不能再使用pthread_join回收)。一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取 它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用 pthread_join，这样的调用将返回EINVAL。如果已经对一个线程调用了pthread_detach就不 能再调用pthread_join了。

int pthread_detach(pthread_t thread);
// 用pthread_join去回收一个detach状态的线程，pthread_join会失败，返回EINVAL.

<7> 比较两个线程是否相等

int thread_equal(thread_t t1, thread_t t2);

三、线程的终止方式
一般由三种方式：
<1> 从线程主函数return。这种方法对主线程不适用，从main函数return相当于调用exit。
<2>一个线程可以调用pthread_cancel终止同一进程中的另一个线程。
<3>线程调用pthread_exit()终止自己。

同一进程的线程间，pthread_cancel向另一线程发终止信号。系统并不会马上关闭被取消线程，只有在被取消线程 下次系统调用时，才会真正结束线程。或调用pthread_testcancel，让内核去检测是否需要取消当前线程

四、线程属性

typedef struct{
    int etachstate;     //分离属性
    struct sched_parm schedparam;  //调度参数
    int scope;          //作用域
    int stackaddr_set;  //栈设置
    size_t stacksize;   //栈大小
    int schedpolicy;    //调度策略
    int inheritsched;   //继承性
    size_t guardsize;   //栈末尾警戒缓冲区大小
    void *stackaddr;    //栈位置
}pthread_attr_t;

<1>线程属性初始化

int pthread_arrt_init(pthread_arrt_t *attr);
// 初始化线程属性

int pthread_attr_destroy(pthread_attr_t *arrt);
// 销毁线程属性所占用资源

<2>线程分离状态

• 非分离态: 线程的默认属性，在此情况下，原有线程有必要等待创建的线程结束(只有pthread_join返回时，创建的线程才算终止，才能释放自己占有的系统资源).
• 分离状态: 分离线程没有被其它的线程所等待，自己运行结束了，线程也就终止了，并马上释放系统资源。

如果设置一个线程为分离线程，而这个线程运行又非常快， 它很可能在pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。 要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程 里调用pthread_cond_timedwait函数，让这个线程等待一会儿，留出足够的时间让函数 pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使 用诸如wait()之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
int pthread_attr_getdetachstate(pthread_attr_t *arrt, int detachstate);
// attr 已经初始化的线程属性
// detachstate      PTHREAD_CREATE_DETACHED     分离线程
//                  PTHREAD_CREATE_JOINABLE     非分离线程

<3>线程的栈大小和栈地址

int pthread_attr_setstack(pthread_attr_t* attr, void* stackaddr, size_t stacksize);
int pthread_attr_getstack(pthread_attr_t* attr, void* stackaddr, size_t* stacksize);
// attr 指向一个线程属性的指针
// stackaddr 返回获取的栈地址
// stacksize 返回获取的栈大小
// 返回值：若是成功返回0,否则返回错误的编号

五、注意事项
<1> 主线程退出其他线程不退出，主线程应调用ptrhed_exit .
<2> 避免僵线程 .

• 使用pthread_join回收线程
• 使用pthread_detach设置分离态线程
• 使用pthread_create时，预先设置线程的分离属性

<3> malloc和mmap申请的内存可以被其他线程释放 .
<4> 如果线程终止时没有释放加锁的互斥量，则该互斥量不能再被使用 .
<5> 应避免在多线程模型中调用fork除非马上exec，子进程中只有调用fork的线程存 在，其他线程在子进程中均pthread_exit .
<6> 信号的复杂语义很难和多线程共存，应避免在多线程引入信号机制.

六、例子

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>

#define SIZE 0x10000

int print(char *str){
    sleep(1);
    printf("%s\n", str);
    return 0;
}

void* thread_func(void* arg){
    int n = 3;
    while(n--){
        print("hello world!\n");
    }
}

int main()
{
    pthread_t tid;
    int err, detachstate, i = 1;
    pthread_attr_t attr;
    size_t stacksize;
    void* stackaddr;

    pthread_attr_init(&attr);   //初始化线程属性

    pthread_attr_getstack(&attr, &stackaddr, &stacksize); //获得线程栈地址和大小
    printf("stackaddr = %p\n", stackaddr);
    printf("stacksize = %x\n", (int)stacksize);

    pthread_attr_getdetachstate(&attr, &detachstate);  //获取线程分离状态
    if(detachstate == PTHREAD_CREATE_DETACHED)
        printf("thread detached.\n");
    else if(detachstate == PTHREAD_CREATE_JOINABLE)
        printf("thread join.\n");
    else 
        printf("thread unknow.\n");

    // 设置线程分离属性
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    while(1){//不断创建线程，直到堆被耗尽
        stackaddr = malloc(SIZE);
        if(stackaddr == NULL){
            perror("malloc");
            exit(1);
        }
        stacksize = SIZE;
        pthread_attr_setstack(&attr, stackaddr, stacksize); //设置线程栈的地址和大小
        err = pthread_create(&tid, &attr, thread_func, NULL);
        if(err != 0){
            printf("%s\n", strerror(err));
            exit(1);
        }
        printf("%d\n", i++);    
    }

    pthread_attr_destroy(&attr);
    return 0;
}