线程与进程区别

进程是一个动态的实体，有自己的生命周期。线程是操作系统进程调度器可以调度的最小执行单位。

一个进程可能包含多个线程。

进程之间，彼此的地址空间是独立的，但同一个进程的多个线程共享内存地址空间，即全局内存区域，包括初始化数据段、未初始化数据段和动态分配的内存段。

这种共享给线程带来了更多的优势：

• 创建线程花费的时间要比创建进程花费的时间少
• 终止线程花费的时间要比终止进程花费的时间少
• 线程之间上下文切换的开销要比进程之间上下文切换的开销小
• 线程之间共享数据要比进程之间共享数据简单

线程共享地址空间的设计，让多个线程之间的通信变得非常简单。一个进程内的多个线程，就像一个软件研发小组内部的不同员工，共享代码、服务器、打印机、资料，彼此之间有分工协作，沟通协作成本比较低。进程之间的通信代价则要高很多。进程之间不得不采用一些进程间通信的手段（如管道、共享内存及信号量等）来协作。

需要强调的一点是，线程和进程不一样，进程有父进程的概念，但在线程组里，所有的线程都是对等的关系：

• 并不是只有主线程才能创建线程，被创建出来的线程同样可以创建线程。
• 不存在类似于fork函数那样的父子关系，大家都归属于同一个线程组，进程ID都相等，而且各有各的线程ID。
• 并非只有主线程才能调用pthread_join连接其他线程，同一线程组内的任意线程都可以对某线程执行pthread_join函数。
• 并非只有主线程才能调用pthread_detach函数，其实任意线程都可以对同一线程组内的线程执行分离操作。

pthread库接口介绍

POSIX函数	函数功能描述
pthread_create	创建一个线程
pthread_exit	退出线程
pthread_self	获取线程ID
pthread_equal	检查两个线程ID是否相等
pthread_join	等待线程退出
pthread_detach	设置线程状态为分离状态
pthread_cancel	线程的取消
pthread_setname_np	设置线程的名称
pthread_cleanup_push	线程退出，清理函数注册和执行
pthread_cleanup_pop	线程退出，清理函数注册和执行

pthread_create

程序开始启动的时候，产生的进程只有一个线程，我们称之为主线程或初始线程。对于单线程的进程而言，只存在主线程一个线程。如果想在主线程之外，再创建一个或多个线程，就需要用到这个接口了。

函数接口如下：

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

• pthread_create函数的第一个参数是pthread_t类型的指针，线程创建成功的话，会将分配的线程ID填入该指针指向的地址。线程的后续操作将使用该值作为线程的唯一标识。
• 第二个参数是pthread_attr_t类型，通过该参数可以定制线程的属性，比如可以指定新建线程栈的大小、调度策略等。如果创建线程无特殊的要求，该值也可以是NULL，表示采用默认属性。
• 第三个参数是线程需要执行的函数。创建线程，是为了让线程执行一定的任务。线程创建成功之后，该线程就会执行start_routine函数，该函数之于线程，就如同main函数之于主线程。
• 第四个参数是新建线程执行的start_routine函数的入参。

返回值：如果成功，则pthread_create返回0；如果不成功，则pthread_create返回一个非0的错误码。常见的错误码如表：

返回值	描述
EAGAIN	系统资源不够，或者创建线程的个数超过系统对一个进程中线程总数的限制
EINVAL	第二个参数attr不合法
EPERM	没有合适的权限来设置调度策略或参数

// pthread_create示例

#include <iostream>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>

void* ThreadFunc(void* _threadId)
{
    std::cout << "线程ID: " << pthread_self() << " hello world" << std::endl;

    pthread_exit(nullptr);
}

int main()
{
    // 创建五个线程
    pthread_t tid[5];

    for (int i = 0;i < 5;i++)
    {
        int rc = pthread_create(&tid[i], nullptr, ThreadFunc, (void*)tid[i]);
        if (rc != 0)
        {
            std::cout << "线程创建失败" << std::endl;;

            return -1;
        }
    }

    // 等待所有线程结束
    pthread_exit(nullptr);

    return 0;
}

pthread_self和syscall(SYS_gettid);

这两个函数都是获取自身的线程ID

 #include <pthread.h>
 
 pthread_t pthread_self();
 
 // --------------------------------- //
 
 int TID = syscall(SYS_gettid);

区别是：

• syscall(SYS_gettid)，属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一标识该线程。
• pthread_self()，属于NPTL线程库的范畴，线程库的后续操作，就是根据该线程ID来操作线程的。

// 示例

#include <iostream>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>

void* ThreadFunc(void* _threadId)
{
    int TID = syscall(SYS_gettid);

    std::cout << "TID: " << TID << std::endl;
    std::cout << "pthread_self: " << pthread_self() << std::endl;

    pthread_exit(nullptr);
}

int main()
{
    pthread_t tid;


    int rc = pthread_create(&tid, nullptr, ThreadFunc, (void*)tid);
    if (rc != 0)
    {
        std::cout << "线程创建失败" << std::endl;;

        return -1;
    }

    // 等待线程退出
    int res = pthread_join(tid, nullptr);
    if (res != 0)
    {
        std::cout << strerror(res) << std::endl;

        return -1;
    }

    std::cout << "线程已经退出" << std::endl;

    return 0;
}

[root@Zhn 线程]# g++ pthread_detach.cpp -o pthread_detach -lpthread
[root@Zhn 线程]# ./pthread_detach 
TID: 8718
pthread_self: 140005981333248
线程已经退出
[root@Zhn 线程]# 

pthread_equal

在同一个线程组内，线程库提供了接口，可以判断两个线程ID是否对应着同一个线程：

#include <pthread.h>

int pthread_equal(pthread_t t1, pthread_t t2);

返回值是0的时候，表示两个线程是同一个线程，非零值则表示不是同一个线程。

pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。

测试主线程的栈空间大概是多大

// 查看一个线程的栈最大占用多少内存空间

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

int i = 0;

void func()
{
    // int类型是4个字节，256个int类型是4 * 256 = 1024，也就是1kB
    // 每执行一次func函数就会占用1kB的栈空间，看看可以执行多少次这个函数
    int buffer[256];

    std::cout << "i = " << i << std::endl;

    i++;

    func();
}

int main()
{
    func();

    sleep(100);
}

可以执行8053次，每次是1kB，也就是8053 / 1024，大概是8MB。

pthread_setname_np

给线程设置名称

#include <pthread.h>

int pthread_setname_np(pthread_t thread, const char *name);

// pthread_setname_np示例

#include <iostream>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>

void* ThreadFunc(void* _threadId)
{
    // 设置线程名称
    pthread_setname_np(pthread_self(), std::to_string(pthread_self()).c_str());

    while (1)
    {
        std::cout << "线程ID: " << pthread_self() << " hello world" << std::endl;
        sleep(1);
    }

    pthread_exit(nullptr);
}

int main()
{
    pthread_t tid[5];

    for (int i = 0;i < 5;i++)
    {
        int rc = pthread_create(&tid[i], nullptr, ThreadFunc, (void*)tid[i]);
        if (rc != 0)
        {
            std::cout << "线程创建失败" << std::endl;;

            return -1;
        }
    }

    // 等待所有线程结束
    pthread_exit(nullptr);

    return 0;
}

创建了五个线程，给每个线程设置名称为自己线程ID。

CMD字段就是设置的线程名称。

pthread_exit

有生就有灭，线程执行完任务，也需要终止。

下面的三种方法中，线程会终止，但是进程不会终止（如果线程不是进程组里的最后一个线程的话）：

• 创建线程时的start_routine（线程执行函数）函数执行了return，并且返回指定值。
• 线程调用pthread_exit。
• 其他线程调用了pthread_cancel函数取消了该线程。如果线程组中的任何一个线程调用了exit函数，或者主线程在main函数中执行了return语句，那么整个线程组内的所有线程都会终止。

pthread_exit函数的定义：

#include <pthread.h>

void pthread_exit(void *value_ptr);

value_ptr是一个指针，存放线程的“临终遗言”。线程组内的其他线程可以通过调用pthread_join函数接收这个地址，从而获取到退出线程的临终遗言。如果线程退出时没有什么遗言，则可以直接传递NULL指针，如下所示：

pthread_exit(NULL);

但是这里有一个问题，就是不能将遗言存放到线程的局部变量里，因为如果用户写的线程函数退出了，线程函数栈上的局部变量可能就不复存在了，线程的临终遗言也就无法被接收者读到。

那我们应该如何正确地传递返回值呢？

• 如果是int型的变量，则可以使用“pthread_exit（（int*）ret）；”。
• 使用全局变量返回。
• 将返回值填入到用malloc在堆上分配的空间里。·使用字符串常量，如pthread_exit（“hello，world”）。

线程退出有一种比较有意思的场景，即线程组的其他线程仍在执行的情况下，主线程却调用pthread_exit函数退出了。这会发生什么事情？首先要说明的是这不是常规的做法，但是如果真的这样做了，那么主线程将进入僵尸状态，而其他线程则不受影响，会继续执行。

pthread_join

线程库提供了pthread_join函数，用来等待某线程的退出并接收它的返回值。这种操作被称为连接（joining）。

#include <pthread.h>

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

第一个参数表示要等待的线程ID，第二个参数代表线程退出的返回值。

根据等待的线程是否退出，可得到如下两种情况：

• 等待的线程尚未退出，那么pthread_join的调用线程就会陷入阻塞。
• 等待的线程已经退出，那么pthread_join函数会将线程的退出值（void*类型）存放到retval指针指向的位置。

线程的连接（join）操作有点类似于进程等待子进程退出的等待（wait）操作，但还是有不同之处：

• 第一点不同之处是进程之间的等待只能是父进程等待子进程，而线程则不然。线程组内的成员是对等的关系，只要是在一个线程组内，就可以对另外一个线程执行连接（join）操作。
• 第一点不同之处是进程之间的等待只能是父进程等待子进程，而线程则不然。线程组内的成员是对等的关系，只要是在一个线程组内，就可以对另外一个线程执行连接（join）操作。

返回值：

返回值	说明
ESRCH	传入的线程ID不存在，查无此线程
EINVAL	线程不是一个可连接的线程或者已经有其他线程连接
EDEADLK	死锁

pthread_join不能连接线程组内任意线程的做法，并不是NPTL线程库设计上的瑕疵，而是有意为之的。如果听任线程连接线程组内的任意线程，那么所谓的任意线程就会包括其他库函数私自创建的线程，当库函数尝试连接（join）私自创建的线程时，发现已经被连接过了，就会返回EINVAL错误。如果库函数需要根据返回值来确定接下来的流程，这就会引发严重的问题。正确的做法是，连接已知线程ID的那些线程，就像pthread_join函数那样。

pthread_join函数之所以能够判断是否死锁和连接操作是否被其他线程捷足先登，是因为目标线程的控制结构体struct pthread中，存在如下成员变量，记录了该线程的连接者：

struct pthread *joinid；

该指针存在三种可能，如下。

• NULL：线程是可连接的，但是尚没有其他线程调用pthread_join来连接它。
• 指向线程自身的struct pthread：表示该线程属于自我了断型，执行过分离操作，或者创建线程时，设置的分离属性为PTHREAD_CREATE_DETACHED，一旦退出，则自动释放所有资源，无需其他线程来连接。
• 指向线程组内其他线程的struct pthread：表示joinid对应的线程会负责连接。

为什么要连接退出的线程

如果不连接退出的线程，会导致资源无法释放

如果不执行连接操作，线程的资源就不能被释放，也不能被复用，这就造成了资源的泄漏。

值得一提的是，纵然调用了pthread_join，也并没有立即调用munmap来释放掉退出线程的栈，它们是被后建的线程复用了，这是NPTL线程库的设计。释放线程资源的时候，NPTL认为进程可能再次创建线程，而频繁地munmap和mmap会影响性能，所以NTPL将该栈缓存起来，放到一个链表之中，如果有新的创建线程的请求，NPTL会首先在栈缓存链表中寻找空间合适的栈，有的话，直接将该栈分配给新创建的线程。

始终不将线程栈归还给系统也不合适，所有缓存的栈大小有上限，默认是40MB，如果缓存起来的线程栈的空间总和大于40MB，NPTL就会扫描链表中的线程栈，调用munmap将一部分空间归还给系统。

// pthread_join示例

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

#define     Threads     5

void* ThreadFunc(void* _args)
{
    int thread_num = *((int*)_args);

    printf("Thread %d: Hello, World!\n", thread_num);

    int* retval = new int;
    *retval = thread_num * 2;

    pthread_exit(reinterpret_cast<void*>(retval));
}

int main()
{
    pthread_t tid[Threads];

    for (int i = 0;i < Threads;i++)
    {
        int* p = new int;
        *p = i;

        int rc = pthread_create(&tid[i], nullptr, ThreadFunc, reinterpret_cast<void*>(p));
        if (rc != 0)
        {
            std::cout << "线程" << i << "创建失败" << std::endl;

            return -1;
        }
    }

    // 等待线程结束并接收返回值
    for (int i = 0;i < Threads; i++)
    {
        void* retval;

        pthread_join(tid[i], &retval);

        std::cout << "线程" << i << "退出, 返回值是" << *reinterpret_cast<int*>(retval) << std::endl;
    }

    std::cout << "线程全部退出" << std::endl;

    return 0;
}

[root@Zhn 线程]# g++ pthread_join.cpp -o pthread_join -lpthread
[root@Zhn 线程]# ./pthread_join 
Thread 0: Hello, World!
Thread 1: Hello, World!
Thread 3: Hello, World!
Thread 2: Hello, World!
Thread 4: Hello, World!
线程0退出, 返回值是0
线程1退出, 返回值是2
线程2退出, 返回值是4
线程3退出, 返回值是6
线程4退出, 返回值是8
线程全部退出
[root@Zhn 线程]# 

可以看到，程序会阻塞在pthread_join，直到所有线程全部退出。

pthread_detach

默认情况下，新创建的线程处于可连接（Joinable）的状态，可连接状态的线程退出后，需要对其执行连接操作，否则线程资源无法释放，从而造成资源泄漏。

如果其他线程并不关心线程的返回值，那么连接操作就会变成一种负担：你不需要它，但是你不去执行连接操作又会造成资源泄漏。这时候你需要的东西只是：线程退出时，系统自动将线程相关的资源释放掉，无须等待连接。NPTL提供了pthread_detach函数来将线程设置成已分离（detached）的状态，如果线程处于已分离的状态，那么线程退出时，系统将负责回收线程的资源，如下：

#include <pthread.h>

int pthread_detach(pthread_t thread);

参数就是要分离的线程ID，可以是线程组内其他线程对目标线程进行分离，也可以是线程自己执行pthread_detach函数，将自身设置成已分离的状态，如下：

pthread_detach(pthread_self())

线程的状态之中，可连接状态和已分离状态是冲突的，一个线程不能既是可连接的，又是已分离的。因此，如果线程处于已分离的状态，其他线程尝试连接线程时，会返回EINVAL错误。

返回值：

返回值	说明
ESRCH	传入的线程ID不存在，查无此线程
EINVAL	线程不是一个可连接的线程，已经处于分离状态

// pthread_detach示例

#include <iostream>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>

void* ThreadFunc(void* _threadId)
{
    int TID = syscall(SYS_gettid);

    std::cout << "TID: " << TID << std::endl;
    std::cout << "pthread_self: " << pthread_self() << std::endl;

    pthread_exit(nullptr);
}

int main()
{
    pthread_t tid;

#ifdef USE_ATTR

    pthread_attr_t attr;

    // 将线程状态设置为分离状态
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    int rc = pthread_create(&tid, nullptr, ThreadFunc, (void*)tid);
    if (rc != 0)
    {
        std::cout << "线程创建失败" << std::endl;;

        return -1;
    }

#else

    int rc = pthread_create(&tid, nullptr, ThreadFunc, (void*)tid);
    if (rc != 0)
    {
        std::cout << "线程创建失败" << std::endl;;

        return -1;
    }

    int res = pthread_detach(tid);
    if (res != 0)
    {
        std::cout << strerror(res) << std::endl;

        return -1;
    }

#endif

    std::cout << "已设置线程分离" << std::endl;

    return 0;
}

[root@Zhn 线程]# g++ pthread_detach.cpp -o pthread_use_attr_detach -DUSE_ATTR -lpthread
[root@Zhn 线程]# g++ pthread_detach.cpp -o pthread_no_attr_detach -lpthread
[root@Zhn 线程]# ./pthread_no_attr_detach 
已设置线程分离TID: 
8428
pthread_self: pthread_self: 139697266493184 hello world
[root@Zhn 线程]# ./pthread_no_attr_detach 
已设置线程分离TID: 8485
pthread_self: 140716723963648 hello world

[root@Zhn 线程]# ./pthread_use_attr_detach 
已设置线程分离
[root@Zhn 线程]# 

我们使用两种方式设置线程分离，一种是通过属性设置，还有一种是调用pthread_detach设置分离，执行了三次程序，可以发现第三次线程没有输出，这是为什么？因为我们设置线程分离，那么主线程先抢到CPU执行之后就退出了，还没轮到子线程执行。