1. POSIX线程库

• 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的
• 要使用这些函数库，要通过引入头文<pthread.h>
• 链接这些线程函数库时要使用编译器命令的
  “-lpthread”选项

2. 创建线程

   #include <pthread.h>
   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；失败返回错误码。

• 测试代码

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

using namespace std;

void* threadRoutine(void* args)
{
    //pthread_self() 获取该线程的id
    while(true)
    {
        sleep(1);
        cout<<"这是一个新线程: "<<(char*)args<<"runing..."<<pthread_self()<<endl;
    }
}
int main()
{
    //创建一个线程
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void*)"thread 1");

    while(1)
    {
        cout<<"main thread"<<endl;
        sleep(1);
    }
    return 0;
}

• 结果展示：线程创建成功
  

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

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

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

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

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

  • pthread_t pthread_self(void);

• 对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。
  
  —图片来源于资料

4. 线程等待

• 为什么需要线程等待？
  • 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
  • 创建新的线程不会复用刚才退出线程的地址空间。

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

• 我们可以利用value_ptr；返回我们想要在线程中收集的信息
• 测试代码：

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

using namespace std;

void *threadRoutine(void *args)
{
    // pthread_self() 获取该线程的id
    int *data = new int[10];
    int count = 0;
    while (true)
    {
        sleep(1);
        cout << "这是一个新线程: " << (char *)args << "runing..." << pthread_self() << endl;

        data[count] = count;
        ++count;
        if (count == 2)
            break;
        // return (void *)10;  //强转为void*
    }

    return data;
}
int main()
{
    // 创建一个线程
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    int count = 0;
    while (1)
    {
        cout << "main thread" << endl;
        ++count;
        if (count == 3)
        {
            int *ret = nullptr; // ret指针变量
            pthread_join(tid, (void **)&ret);
            // cout << "ret: " << (long long)ret << endl;  //Linux下机器是64位
            for (int i = 0; i < 2; ++i)
            {
                cout << "ret: " << (long long)(ret + i) << endl; // Linux下机器是64位
            }
            break;
        }
    }
    return 0;
}

• 结果视图：
  

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

  • 1. 如果thread线程通过return返回,value_ ptr所指向的单元里存放的是thread线程函数的返回值。
  • 2. 如果thread线程被别的线程调用pthread_ cancel异常终掉,value_ ptr所指向的单元里存放的是常数
       PTHREAD_ CANCELED。
  • 3. 如果thread线程是自己调用pthread_exit终止的,value_ptr所指向的单元存放的是传给pthread_exit的参
       数。
  • 4. 如果对thread线程的终止状态不感兴趣,可以传NULL给value_ ptr参数

5. 线程终止

• 如果需要只终止某个线程而不终止整个进程,可以有三种方法:
  • 1. 从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit(它是进程退出了)。
  • 2. 线程可以调用pthread_ exit终止自己。
  • 3. 一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。

pthread_ exit

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

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

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

using namespace std;


void *threadRoutine(void *args)
{
    // pthread_self() 获取该线程的id
    int count = 0;
    while (true)
    {
        sleep(1);
        cout << "这是一个新线程: " << (char *)args << "runing..." << pthread_self() << endl;

        ++count;
        if (count == 2) pthread_exit((void*)11); 
    }
}
int main()
{
    // 创建一个线程
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    int count = 0;
    while (1)
    {
        cout << "main thread" << endl;
        ++count;
        if (count == 3)
        {
            int *ret = nullptr; // ret指针变量
            pthread_join(tid, (void **)&ret);
            cout << "ret: " << (long long)ret << endl;  //Linux下机器是64位
            break;
        }
    }
    return 0;
}

• 结果视图：
  

pthread_ cancel

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

• 代码块：

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

using namespace std;


void *threadRoutine(void *args)
{
    // pthread_self() 获取该线程的id
    while (true)
    {
        sleep(1);
        cout << "这是一个新线程: " << (char *)args << "runing..." << pthread_self() << endl; 
    }
}
int main()
{
    // 创建一个线程
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");

    int count = 0;
    while (1)
    {
        cout << "main thread" << endl;
        sleep(3);
        ++count;
        pthread_cancel(tid); //取消一个线程
        if(count==4) break;
    }
    return 0;
}

• 结果视图：
  

6. 分离线程

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

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

   #include <pthread.h>
   int pthread_detach(pthread_t thread);
  

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

    pthread_detach(pthread_self());
  

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

7. 总结

• 1. 线程谁先运行与调度器相关
• 2. 线程一旦异常，都可能导致整个进程整体退出
• 3. 线程的输入和返回值问题
• 4. 线程异常退出的理解
• 5. _ _thread : 修饰全局变量，带来的结果就是让每一个线程各自拥有一个全局的变量 – 线程的局部存储。
• 线程在创建并执行的时候，线程也是需要进行等待的，如果主线程如果不等待，即会引起类似于进程的僵尸问题，导致内存泄漏。