Linux多线程——线程控制

Linux多线程——线程控制_第1张图片

本章Gitee仓库:线程控制

文章目录

    • 0. 前言
    • 1. 线程创建
    • 2. 线程等待
    • 3. 线程终止
    • 4. 线程取消
    • 5. 线程ID
    • 6. 线程局存储
    • 7. 线程分离

0. 前言

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

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

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

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

1. 线程创建

#include 
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字节

image-20240117104046807

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

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

Linux多线程——线程控制_第2张图片

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 
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;
}

Linux多线程——线程控制_第3张图片

3. 线程终止

#include 
void pthread_exit(void *retval);
  • void *retval:和线程等待的第二个参数一样,返回线程的退出信息

exit():用来终止进程,如果线程要终止,采用pthread_exit

4. 线程取消

#include 
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;
}

Linux多线程——线程控制_第4张图片

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

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

Linux多线程——线程控制_第5张图片

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

Linux多线程——线程控制_第6张图片

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

线程栈:

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

6. 线程局存储

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

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

7. 线程分离

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

#include 
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;
}

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

Linux多线程——线程控制_第7张图片
线程分离既可以主线程进行分离,也可以新线程自己分离。

你可能感兴趣的:(Linux,原创,linux,运维,服务器)