Linux多线程——线程控制

本章Gitee仓库：线程控制

0. 前言

由于Linux内核当中，没有很明确的线程概念，它只有轻量级进程的概念。

所以这就注定了Linux操作系统，不会给我们直接提供线程的系统调用，指挥提供轻量级进程的系统调用。

而我们用户需要线程的接口，所以在用户和系统之间，Linux程序员给我们在应用层开发出了一个pthread线程库（第三方库），将轻量级线程的相关接口进行封装，为用户提供直接线程的接口。所有在Linux中编写多线程的代码时，需要使用这个第三方pthread库

虽然这是第三方库，但是几乎所有的Linux平台都是默认自带这个库的

1. 线程创建

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

• pthread_t *thread：输出型参数，返回创建的线程id

• const pthread_attr_t *attr：创建线程的属性，大部分情况不用管，设置为nullptr

• void *(*start_routine)(void *)：函数指针，返回值为void*，参数也为void*，传入一个函数进来，让线程执行该指针指向的函数处

  void*可以接收或者返回任意类型

• void *arg：输入型参数，创建线程成功，新线程回调函数的时候，需要参数，这个参数就是给线程函数传递的

  不仅可以传递参数，还可以传递对象

• 线程创建成功返回0，创建失败返回错误码。

指针大小根据平台，32位的为4字节，64位的位8字节

由于我们用的线程库是第三方库，所以在编译的时候，要带上-lpthread

ps axj是查看进程的，如果需要查看线程ps -aL：

LWP：light weight process就是轻量级进程，这就是我们线程的tid

不管是哪个线程因为异常被干掉了，其他线程（包括主线程）都会一同被干掉

void *threadRoutine(void *args)
{
    while(true)
    {
        cout << "[new thread] pid: " << getpid() << endl;
        //cout << (int*)args << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, nullptr);

    while(true)
    {
        printf("[main thread] pid:%d, new thread tid:%p\n", getpid(), tid);
        sleep(1);
    }
    return 0;
}

2. 线程等待

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);

• pthread_t thread：需要等待线程的tid

• void **retval：线程跑完退出的信息

  这里不考虑异常，因为线程一旦异常，全部的线程（包括主线程）就直接退出了

• 线程等待成功返回0，创建失败返回错误码。

• 等待方式是阻塞等待

void *threadRoutine(void *args)
{
    //新线程跑3秒后退出
    int cnt = 3;
    while(true)
    {
        cout << "[new thread] pid: " << getpid() << endl;
        cnt--;
        if(cnt == 0)    break;
        sleep(1);
    }
    return (void*)1;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, nullptr);

    //线程等待	默认阻塞等待
    void *retval;
    pthread_join(tid, &retval);
    cout << "main thread quit, ret:" << (long long int)retval<< endl;	//64位指针8个字节，用长整型接收
    return 0;
}

3. 线程终止

#include <pthread.h>
void pthread_exit(void *retval);

• void *retval：和线程等待的第二个参数一样，返回线程的退出信息

exit()：用来终止进程，如果线程要终止，采用pthread_exit。

4. 线程取消

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

• pthread_t thread：需要取消线程的tid

5. 线程ID

我们创建一个线程，这个线程想要拿到自己线程的tid，采用phtread_self()

string toHex(pthread_t tid)
{
    char hex[64];
    snprintf(hex, sizeof(hex), "%p", tid);
    return hex;
}

void *threadRoutine(void *args)
{
    while(true)
    {
        cout << "thread id:" << toHex(pthread_self()) << endl;
        sleep(1);
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void*)"Thread 1");
    cout << "[main thread] new thread id:" << toHex(tid) << endl;
    pthread_join(tid, nullptr);
    return 0;
}

我们这里得到的新线程的id，和我们监控脚本看到的线程id并不一样，我们获取到的更类似于一个地址。

这是因为Linux中并没有明确线程的概念，只有轻量级进程的概念，这个LWP是给操作系统自己看的。

这就是操作系统创建轻量级进程的接口，参数很多，使用很麻烦，所以pthead线程库就对其进行了封装，于是就有了我们上面所使用的这批接口。意思就是说线程的概念，是库来进行维护的，而这个库是一个动态库，需要加载到内存当中，库又是在共享区。clone函数的第二个参数void *child_stack，就是自定义一个栈，这个“栈”，就是在共享区当中。

所以我们拿到的tid，其实就是它tcb的起始地址

线程栈：

每个线程都有自己的调用链，main函数创建线程时可以调用一些函数，而这些线程内部也可以调用别的函数，所以他们必须要有自己独立的栈帧结构，这里面要存储执行流在执行过程中的临时变量。

6. 线程局存储

全局变量是能够被所以线程所看到的，如果想要有自己独立的全局变量，可以采用__thread进行修饰，这样能够让其进行局部存储，成为自己私有的。

__thread只能修饰内置类型，是编译器提供的一种编译选项

7. 线程分离

进程可以阻塞等待和非阻塞等待，如果想要线程进行非阻塞等待，可以采取线程分离，

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

#define NUM 5

string toHex(pthread_t tid)
{
    char hex[64];
    snprintf(hex, sizeof(hex), "%p", tid);
    return hex;
}

void *threadRoutine(void *args)
{
    int cnt = 5;
    string *s = static_cast<string*>(args);
    while(true)
    {
        cout << *s << " tid: " << toHex(pthread_self()) << " " << cnt << endl;
        cnt--;
        if(cnt == 0)    break;
        sleep(1); 
    }
    return nullptr;
}

int main()
{
    vector<pthread_t> tids;
    for(int i = 0; i < NUM; i++)
    {
        pthread_t tid;
        string *s = new string("[Thread " + to_string(i) + "]");
        pthread_create(&tid, nullptr, threadRoutine, (void*)s);
        tids.push_back(tid);
        usleep(100000);
    }

    //线程分离
    for(auto e : tids)
    {
        pthread_detach(e);
    }


    for(int i = 0; i< tids.size(); i++)
    {
        int n = pthread_join(tids[i], nullptr);
        
        printf("n = %d, who = %s, why:%s\n", n, toHex(tids[i]).c_str(), strerror(n));
    }
    return 0;
}

线程被分离之后，就不能进行等待了，如果等待就会返回错误信息：

线程分离既可以主线程进行分离，也可以新线程自己分离。