（四十一）线程——线程原语

一、准备工作

　　查看manpage关于pthread的函数

man -k pthread

　　安装pthread相关manpage

sudo apt-get install manpages-posix manpages-posix-dev

---

二、pthread_create

　　创建线程

#include <pthread.h>

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

pthread_t *thread：传递一个pthread_t变量地址进来，用于保存新线程的tid（线程ID）
const pthread_attr_t *attr：线程属性设置(eg:线程的优先级、线程的占空间大小)，如使用默认属性，则传NULL
void *(*start_routine) (void *)：函数指针，指向新线程应该加载执行的函数模块
void *arg：指定线程将要加载调用的那个函数的参数

返回值：成功返回0，失败返回错误号。
以前学过的系统函数都是成功返回0，失败返回-1，错误号保存在全局变量errno中，
而pthread库的函数都是通过返回值返回错误号，虽然每个线程也都有一个errno，
但这是为了兼容其它函数接口而提供的，pthread库本身并不使用它，通过返回值返回错误码更加清晰。

其中：
Compile and link with -lpthread.（即链接的时候要加-lpthread参数）
typedef unsigned long int pthread_t;

　　
　　在一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create()返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针start_routine决定。start_routine函数接收一个参数，是通过pthread_create的arg参数传递给它的，该参数的类型为void *，这个指针按什么类型解释由调用者自己定义。start_routine的返回值类型也是void *，这个指针的含义同样由调用者自己定义。start_routine返回时，这个线程就退出了，其它线程可以调用pthread_join得到start_routine的返回值，类似于父进程调用wait()得到子进程的退出状态，稍后详细介绍pthread_join。
　　pthread_create成功返回后，新创建的线程的id被填写到thread参数所指向的内存单元。我们知道进程id的类型是pid_t，每个进程的id在整个系统中是唯一的，调用getpid()可以获得当前进程的id，是一个正整数值。线程id的类型是thread_t，它只在当前进程中保证是唯一的，在不同的系统中thread_t这个类型有不同的实现，它可能是一个整数值，也可能是一个结构体，也可能是一个地址，所以不能简单地当成整数用printf打印，调用pthread_self()可以获得当前线程的id。
　　attr参数表示线程属性，本节不深入讨论线程属性（下节简单讨论），所有代码例子都传NULL给attr参数，表示线程属性取缺省值，感兴趣的读者可以参考[APUE2e]。
　　
　　

---

三、pthread_self

函数作用：获取调用线程tid

#include <pthread.h>

pthread_t pthread_self(void);

　　
　　
接下来看一个简单的例子（pthread_create和pthread_self使用）

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

pthread_t ntid;//定义线程号全局变量

void printids(const char *s)
{
    pid_t pid;
    pthread_t tid;
    pid = getpid();
    tid = pthread_self();
    printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid,
            (unsigned int)tid, (unsigned int)tid);
}
void *thr_fn(void *arg)
{
    printids(arg);
    return NULL;
}
int main(void)
{
    int err;
    err = pthread_create(&ntid, NULL, thr_fn, "new thread: ");
    if (err != 0) {
        fprintf(stderr, "can't create thread: %s\n", strerror(err));
        exit(1);
    }
    printids("main thread:");
    sleep(1);
    return 0;
}

　　由于pthread_create的错误码不保存在errno中，因此不能直接用perror()打印错误信息，可以先用strerror()把错误码转换成错误信息再打印。
　　如果任意一个线程调用了exit或_exit，则整个进程的所有线程都终止，由于从main函数return也相当于调用exit，为了防止新创建的线程还没有得到执行就终止，我们在main函数return之前延时1秒，这只是一种权宜之计，即使主线程等待1秒，内核也不一定会调度新创建的线程执行，下一节我们会看到更好的办法。
（注：在这里我们可以思考一个情况，pthread_self获得的tid和pthread_create函数里得到tid是否会出现不一致呢？看以下代码）

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

void *th_fun(void *arg)
{
    int *p = (int *)arg;
    printf("thread PID = %d\n", getpid());
    printf("thread ID = %x\n",(unsigned int)pthread_self());
    printf("thread *arg = %d\n", *p);
    sleep(1);//为防止下述例外产生
}

int main(void)
{
    pthread_t tid;
    int n = 10;
    //pthread_create执行过程: 1.创建线程 2.将线程号填写到tid 3.返回函数调用
    pthread_create(&tid, NULL, th_fun, (void *)&n);
    /*主线程中的pthread_create 返回值tid == 子线程中pthread_self()
     *但是有例外:
     *          若在上诉过程1与2之间cpu的时间片被该线程占用
     *          而创建的线程执行完毕后退出
     *          则主线程中的pthread_create 返回值tid为垃圾值
     *          不等于子线程中pthread_self()
     */

    printf("main PID = %d\n", getpid());
    printf("main thread ID = %x\n",(unsigned int)pthread_self());
    printf("main created thread = %x\n", (unsigned int)tid);
    sleep(2);//等待子线程完成,当主线程退出后,则该进程退出,子线程全部被回收

    return 0;
}

---

四、pthread_exit

　　pthread_exit为调用线程退出函数，注意和exit函数的区别，任何线程里exit导致进程退出，其他线程未工作结束，主控线程退出时不能return或exit。
　　需要注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函数已经退出了。
（注：如果在子线程中调用该函数，则子线程退出，如果在主线程中调用该函数则主线程会成为僵尸线程，然后等待所有子线程都退出之后再退出该线程）

#include <pthread.h>

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

---

五、pthread_join

#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);

pthread_t thread:回收线程的tid
void **retval:接收退出线程传递出的返回值
返回值：成功返回0，失败返回错误号

　　调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下：
　　如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返回值。
　　如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED。
　　如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给pthread_exit的参数。
　　如果对thread线程的终止状态不感兴趣，可以传NULL给retval参数。
　　

---

六、pthread_cancel

　　在进程内某个线程可以取消另一个线程。

#include <pthread.h>

int pthread_cancel(pthread_t thread);

被取消的线程，退出值，定义在Linux的pthread库中，常数THREAD_CANCELED的值是-1。
可以在头文件pthread.h中找到它的定义：

#define PTHREAD_CANCELED ((void *) -1)

　　
　　
　　
　　
例子：（pthread_join、pthread_exit和pthread_cancel的使用）

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
void *thr_fn1(void *arg)
{
    printf("thread 1 returning\n");
    return (void *)1;
}

void *thr_fn2(void *arg)
{
    printf("thread 2 exiting\n");
    pthread_exit((void *)2);//在这里的效果和上面的return一样
}

void *thr_fn3(void *arg)
{
    while(1) {
        printf("thread 3 writing\n");
        sleep(1);
    }
}

int main(void)
{
    pthread_t tid;
    void *tret;

    pthread_create(&tid, NULL, thr_fn1, NULL);
    pthread_join(tid, &tret);//阻塞回收
    printf("thread 1 exit code %d\n", (int)tret);

    pthread_create(&tid, NULL, thr_fn2, NULL);
    pthread_join(tid, &tret);
    printf("thread 2 exit code %d\n", (int)tret);

    pthread_create(&tid, NULL, thr_fn3, NULL);
    sleep(3);
    pthread_cancel(tid);//关闭线程
    pthread_join(tid, &tret);//回收
    printf("thread 3 exit code %d\n", (int)tret);

    return 0;
}

---

七、pthread_detach

#include <pthread.h>

int pthread_detach(pthread_t tid);

pthread_t tid：要被分的离线程的tid
返回值：成功返回0，失败返回错误号。

　　一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL。如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。
　　
　　
　　例子：（pthread_detach的使用）　

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
void *thr_fn(void *arg)
{
    int n = 3;
    while (n--) {
        printf("thread count %d\n", n);
        sleep(1);
    }
    return (void *)1;
}
int main(void)
{
    pthread_t tid;
    void *tret;
    int err;

    pthread_create(&tid, NULL, thr_fn, NULL);

    //第一次运行时注释掉下面这行，第二次再打开，分析两次结果
    pthread_detach(tid);//设置成分离态

    while (1)
    {
        err = pthread_join(tid, &tret);
        if (err != 0)//调用不成功,打印出信息
            fprintf(stderr, "thread %s\n", strerror(err));
        else
            fprintf(stderr, "thread exit code %d\n", (int)tret);
        sleep(1);
    }
    return 0;
}

　　当我们不关系线程的返回值的时候一般调用该函数做收尾处理，十分方便！
　　
　　
　　
　　
　　

---

八、线程终止方式

如果需要只终止某个线程而不终止整个进程，可以有三种方法：
1.从线程主函数return。这种方法对主控线程不适用，从main函数return相当于调用exit。
2.一个线程可以调用pthread_cancel终止同一进程中的另一个线程。
3.线程可以调用pthread_exit终止自己。

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

pthread_cancel函数需要注意的地方：


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

void *th_fun(void *arg)
{
    int i = 0;
    int *p = (int *)arg;
    printf("thread PID = %d\n", getpid());
    printf("thread ID = %x\n",(unsigned int)pthread_self());
    printf("thread *arg = %d\n", *p);
    while(1)
    {
        i++;
    }
}

int main(void)
{
    pthread_t tid;
    int n = 10;
    //过程: 1.创建线程 2.将线程号填写到tid 3.返回函数调用
    pthread_create(&tid, NULL, th_fun, (void *)&n);
    printf("main PID = %d\n", getpid());
    printf("main thread ID = %x\n",(unsigned int)pthread_self());
    printf("main created thread = %x\n", (unsigned int)tid);

    pthread_cancel(tid);
    // 同一进程的线程间,才能使用pthread_cancel向另一线程发终止信号
    // 系统并不会马上关闭被取消线程,只有在被取消线程下次系统调用时，才会真正结束线程
    // 执行后通过ps -eLf 和 ps -Lw pid可以查看


    while(1)
        sleep(5);
    return 0;
}

对于上述情况，使用pthread_testcancel函数进行修正：


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

void *th_fun(void *arg)
{
    int i = 0;
    int *p = (int *)arg;
    printf("thread PID = %d\n", getpid());
    printf("thread ID = %x\n",(unsigned int)pthread_self());
    printf("thread *arg = %d\n", *p);
    while(1)
    {
        i++;
        pthread_testcancel();
        //调用pthread_testcancel，让内核去检测是否需要取消当前线程
    }
}

int main(void)
{
    pthread_t tid;
    int n = 10;
    //过程: 1.创建线程 2.将线程号填写到tid 3.返回函数调用
    pthread_create(&tid, NULL, th_fun, (void *)&n);
    printf("main PID = %d\n", getpid());
    printf("main thread ID = %x\n",(unsigned int)pthread_self());
    printf("main created thread = %x\n", (unsigned int)tid);

    pthread_cancel(tid);
    //同一进程的线程间,pthread_cancel向另一线程发终止信号
    //系统并不会马上关闭被取消线程,只有在被取消线程下次系统调用时
    //才会真正结束线程,执行后通过ps -eLf 和 ps -Lw pid可以查看
    //或者在要被取消的线程中调用thread_testcancel()检测是否需要取消当前线程

    while(1)
        sleep(5);
    return 0;
}