【Linux】多线程（上）

#include <pthread.h>

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

pthread_create函数用于创建一个新进程，成功返回0，失败返回错误码

其中：

thread：输出型参数，返回新线程的pthread_t（线程ID）
attr：设置线程的属性，一般设置为nullptr表示使用默认属性
start_routine：函数的地址，线程启动后将要执行的函数
arg：传给start_routine函数的参数，一般将对应参数强转为void*后传入

例子：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

using namespace std;

void* threadRoutine(void* arg) //新线程的例程
{
    while(true)
    {
        cout << "new thread, pid:" << getpid() << endl;
        sleep(2);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, nullptr); //创建线程
    while(true) //主线程
    {
        cout << "main thread, pid:" << getpid() << endl;
        sleep(2);
    }
    return 0;
}

运行结果：

可以看到主线程和新线程的PID是一样的，操作系统怎么区分呢？

运行程序，输入 ps -aL 可以看到当前所有线程的信息

可以看到同一进程内的线程虽然PID相同，但LWP是不同的，操作系统根据LWP对线程进行调度

主线程的PID与LWP相同

pthread_t及地址空间的布局

需要额外一提，pthread_t所说的线程ID与我们前面指的线程ID不是一回事，前面提到的线程ID属于线程调度的范畴，用于表示线程的唯一性。而pthread_t类型的参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID

线程是如何在进程地址空间中布局的？

我们的线程库需要被加载到内存中，线程库也需要维护我们创建的线程，因此在线程库中就需要对线程进行管理。因此，我们创建的线程，在线程库中还有库级别的TCB，其起始地址就是线程的tid

线程的独立栈结构是在线程库内部进行维护的，线程库是动态库，需要被加载到共享区

线程需要有自己独立的栈结构，因为每个线程都有自己独立的调用链。除了主线程，其他所有线程的独立栈结构都在共享区——准确来说是在pthread库中tid指向的用户TCB内部

4.3 线程终止

前面提到，线程如果被异常终止，那整个进程也会随之崩溃，那如何正常的使线程终止呢？

对于非主线程的线程，可以直接在线程的例程中return
线程调用pthread_exit终止自己
线程调用pthread_cancel终止同一进程中的其他线程

我们先来看pthread_exit函数

pthread_exit

#include <pthread.h>

void pthread_exit(void *retval);

retval是一个输出型参数，用于带出线程例程的返回值，pthread_exit函数本身无返回值

注意，调用pthread_exit时，retval指向的内存单元一定得是全局的或者是用malloc分配的，而不能是线程例程中的一个局部变量，否则线程终止后变量被销毁，retval就变成一个野指针了

包括如果我们在线程的例程中return了一个指针，这个指针指向的内存单元也必须符合上面的要求

例子：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

using namespace std;

void* threadRoutine(void* arg) //新线程的例程
{
    int cnt = 0;
    while(true)
    {
        if(cnt == 3)
        {
            cout << "new thread exit!" << endl;
            pthread_exit(nullptr);
        }
        cout << "new thread, pid:" << getpid() << endl;
        cnt++;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, nullptr); //创建线程
    while (true) // 主线程
    {
        cout << "main thread, pid:" << getpid() << endl;
        sleep(1);
    }
    return 0;
}

运行结果：

pthread_cancel

#include <pthread.h>

int pthread_cancel(pthread_t thread);

pthread_cancel函数用于取消一个执行中的线程，成功返回0，失败返回错误码，参数thread传入指定线程的ID

被取消的线程本身在例程中会返回PTHREAD_CANCELED的宏，其内容是(void*)-1

例子：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

using namespace std;

void* threadRoutine(void* arg) //新线程的例程
{
    while(true)
    {
        cout << "new thread, pid:" << getpid() << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, nullptr); //创建线程
    int cnt = 0;
    while (true) // 主线程
    {
        if(cnt == 3)
        {
            int n = pthread_cancel(tid);
            cout << "new thread cancel!" << endl;
            break;
        }
        cout << "main thread, pid:" << getpid() << endl;
        cnt++;
        sleep(1);
    }
    return 0;
}

运行结果：

4.4 线程等待

pthread_join

#include <pthread.h>

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

pthread_join函数用于阻塞式等待一个线程的结束，成功返回0，失败返回错误码

其中：

thread：要等待的线程ID
retval：指向一个指针，后者指向线程的返回值

pthread_join函数等待的线程必须是joinable的，即等待的线程不能已经分离（后面会提到）

调用该函数的线程将会阻塞式等待目标线程退出，其中又分为以下几种情况：

目标线程通过return返回，则retval指向的内存空间存放return的返回值
目标线程自己调用pthread_exit终止，则retval指向的内存单元存放pthread_exit的参数
目标线程被其他线程通过pthread_cancel取消，则retval指向的内存单元存放PTHREAD_CANCELED
如果对目标线程的返回值不感兴趣，可以将retval设置为nullptr

例子：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

using namespace std;

int cnt = 0;

void* threadRoutine(void* arg) //新线程的例程
{
    while(true)
    {
        if(cnt == 3)
        {
            cout << "new thread exit!" << endl;
            pthread_exit(&cnt);
        }
        cout << "new thread, pid:" << getpid() << endl;
        cnt++;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, nullptr); //创建线程
    int *retval;
    pthread_join(tid, (void**)&retval);
    cout << *retval << endl;
    return 0;
}

运行结果：

4.5 线程分离

pthread_detach

如果一个线程终止，而我们又没有对其进行线程等待，那么其资源没有被释放就会造成系统泄露。

有的时候，我们可能不需要线程返回一个值，或者不关注线程的返回值，那么对其进行线程等待是一种负担。此时我们就可以选择让线程分离，即线程退出时自己释放线程资源

#include <pthread.h>

int pthread_detach(pthread_t thread);

pthread_detach函数成功返回0，失败返回错误码，参数thread传入线程ID

可以是线程自己让自己分离，也可以是线程组内的其他线程对目标线程进行分离。问题：如果线程自己让自己分离，它怎么知道自己的线程ID呢？

pthread_self

#include <pthread.h>

pthread_t pthread_self(void);

pthread_self函数会返回调用该函数的线程的ID，搭配pthread_detach函数使用就能让线程自己分离

一个线程不能既是joinable的又是分离的，即线程如果分离就不能再被线程等待

例子：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

using namespace std;

void* threadRoutine(void* arg) //新线程的例程
{
    pthread_detach(pthread_self());
    int cnt = 0;
    while(true)
    {
        if(cnt == 3)
        {
            cout << "new thread exit!" << endl;
            pthread_exit(&cnt);
        }
        cout << "new thread, pid:" << getpid() << endl;
        cnt++;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, nullptr); //创建线程
    sleep(1);
    if(pthread_join(tid, nullptr) == 0)
        cout << "wait thread success" << endl;
    else
        cout << "wait thread failed" << endl;
    return 0;
}

运行结果：

如有错误，欢迎在评论区指出

【Linux】多线程（上）完.