linux多线程控制详述

Posted 命由己造~

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了linux多线程控制详述相关的知识,希望对你有一定的参考价值。

文章目录

一、进程控制

1.1 POSIX线程库

这是由原生线程库提供的,遵守POSIX标准。这个标准就像前面学过的system V标准。
有以下特点:

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

1.2 创建线程pthread_create

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine) (void *), void *arg);
Compile and link with -pthread.// 链接的时候必须加上-lpthread

RETURN VALUE
On success, pthread_create() returns 0; 
on error, it returns an error number, and the contents of *thread are undefined.

参数说明:
thread:线程id
attr:线程属性,直接设为null
start_routine:函数指针
arg:这个参数会传递进start_routinevoid*参数中。

这里在链接的时候要注意link到系统给的原生线程库-lpthread

对于错误的检查:
像我们以前的函数基本都是设置进全局变量errno来指示错误,而pthreads函数出错时不会设置全局变量errno,因为全部变量会被多个线程共享。它会将错误代码通过返回值返回

1.2.1 创建一批线程

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

using std::cout;
using std::endl;

void* start_stream(void* str)

    std::string name = static_cast<const char*>(str);
    while(true)
    
        cout << "i am new thread: " << name << endl;
        sleep(1);
    


#define NUM 10

int main()

    // 创建一批线程
    for(int i = 0; i < NUM; i++)
    
        pthread_t tid;
        pthread_create(&tid, nullptr, start_stream, (void*)"new thread");
    

    // 创建完毕
    while(true)
    
        cout << "-----------create success-----------" << endl;
        sleep(1);
    
    return 0;



现在我们给每个线程传递进去的时候加上一个编号:

for(int i = 1; i <= NUM; i++)

    pthread_t tid;
    char buf[64];
    snprintf(buf, sizeof(buf), "%s:%d", "thread", i);
    pthread_create(&tid, nullptr, start_stream, (void*)buf);


为什么会出现这个现象呢?

那么真正的写法应该是什么呢?
我们主要目的是让每个线程都不会共享buf。

class ThreadData

public:
    pthread_t _tid;
    char _buf[64];
;

void* start_stream(void* args)

    ThreadData *ptd = static_cast<ThreadData *>(args);
    while(true)
    
        cout << "i am new thread: " << ptd->_buf << endl;
        sleep(1);
    


#define NUM 10

int main()

    // 创建一批线程
    for(int i = 1; i <= NUM; i++)
    
        ThreadData *ptd = new ThreadData();
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
    

    // 创建完毕
    while(true)
    
        cout << "-----------create success-----------" << endl;
        sleep(1);
    
    return 0;

这样每个线程所获得的buf都是不同的。

再加上一个计数器:

void* start_stream(void* args)

    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    
        // cout << "i am new thread: " << ptd->_buf << " cnt: " << cnt << endl;
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    
    delete ptd;
    return nullptr;


这里可以看到每个线程cnt的地址都不一样,所以每个线程都有不同的cnt,不会相互影响
这就证明了每一个线程都有自己独立的栈结构
这个调用方法函数就是一个可重入函数,每个线程都会形成独立的栈帧

1.3 终止线程pthread_exit

首先要知道最基本的终止方法:

这里要注意exit不能用来终止线程,使用exit整个进程都会退出,所以exit是用来终止进程的

POSIX线程库专门给了一个接口用来结束终止线程。

#include <pthread.h>

void pthread_exit(void *retval);

Compile and link with -pthread.

参数可以默认设置为nullptr

void* start_stream(void* args)

    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    
    delete ptd;
    //return nullptr;
    pthread_exit(nullptr);// 结束线程



可以看到把新建线程结束后,主线程还在继续运行。
当然也可以使用return来终止。

1.4 线程等待pthread_jion

跟进程一样线程也是要等待的,如果不等待,就会造成内存泄漏(类似僵尸进程)
而等待主要是要做:

  • 获取新线程的退出信息。
  • 回收新线程对应的PCB等内核资源,防止内存泄漏。
#include <pthread.h>

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

Compile and link with -pthread.

RETURN VALUE
On success, pthread_join() returns 0; 
on error, it returns an error number.

参数说明:

thread:要等待的线程。
retval:后面1.4.1线程的返回值详细说明。

class ThreadData

public:
    pthread_t _tid;
    char _buf[64];
;

void* start_stream(void* args)

    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    
    delete ptd;
    // return nullptr;
    pthread_exit(nullptr);// 结束线程


#define NUM 10

int main()

    // 创建一批线程
    std::vector<ThreadData*> tids;
    for(int i = 1; i <= NUM; i++)
    
        ThreadData *ptd = new ThreadData();
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
        tids.push_back(ptd);
    
    for(auto& e : tids)
    
        printf("creat thread: %s : 0x%x success\\n", e->_buf, e->_tid);
    
    return 0;

这是没有等待线程的代码

可以看到主线程运行完就直接结束了进程,所有新线程也全部结束

进行线程等待的代码:

class ThreadData

public:
    pthread_t _tid;
    char _buf[64];
;

void* start_stream(void* args)

    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 5;
    while(cnt)
    
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    
    // return nullptr;
    pthread_exit(nullptr);// 结束线程


#define NUM 10

int main()

    // 创建一批线程
    std::vector<ThreadData*> tids;
    for(int i = 1; i <= NUM; i++)
    
        ThreadData *ptd = new ThreadData();
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
        tids.push_back(ptd);
    
    for(auto& e : tids)
    
        printf("creat thread: %s : 0x%x success\\n", e->_buf, e->_tid);
    
    // 线程等待
    for(auto& e : tids)
    
        int n = pthread_join(e->_tid, nullptr);
        assert(n == 0);
        delete e;
    
    cout << "main thread quit" << endl;
    return 0;


可以看到新线程也都执行到了结尾。

1.4.1 线程的返回值(退出码)


这里的返回值究竟是干什么的呢?

这样我们就可以在pthread_jion的时候来获取线程结束的返回值。

class ThreadData

public:
    int _number;
    pthread_t _tid;
    char _buf[64];
;

void* start_stream(void* args)

    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 5;
    while(cnt)
    
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    
    // return nullptr;
     pthread_exit((void*)ptd->_number);// 结束线程


#define NUM 10

int main()

    // 创建一批线程
    std::vector<ThreadData*> tids;
    for(int i = 1; i <= NUM; i++)
    
        ThreadData *ptd = new ThreadData();
        ptd->_number = i;
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
        tids.push_back(ptd);
    
    for(auto& e : tids)
    
        printf("creat thread: %s : 0x%x success\\n", e->_buf, e->_tid);
    
    // 线程等待
    for(auto& e : tids)
    
        void* ret = nullptr;
        int n = pthread_join(e->_tid, &ret);
        assert(n == 0);
        printf("join success: %d\\n", (long long)(ret));
        delete e;
    
    cout << "main thread quit" << endl;
    return 0;


可以看到拿到了返回值(退出码)。

那么这个ret是怎么拿到数据的呢?

线程结束时会把返回值写入pthread库暂时保存,这时候其实我们设置的ret变量类型和库中临时保存的类型相同,但是由于这是个函数调用,我们没办法直接赋值

所以我们吧ret的地址传进去,函数内部自己帮我们实现(蓝色)

这里我们思考一个问题:线程退出的时候为什么没有跟进程退出那样有退出信号?

因为信号是发给进程的,整个进程都会被退出,要退出信号也没有意义了。
所以pthread_jion默认认为能够调用成功,不考虑异常问题,异常应该是进程考虑的问题。

1.5 取消线程pthread_cancel

想要取消线程的前提是线程得先跑起来。

#include <pthread.h>

int pthread_cancel(pthread_t thread);

Compile and link with -pthread.

RETURN VALUE
On success, pthread_cancel() returns 0; 
on error, it returns a nonzero error number.

我们可以取消一半的线程,观察这一半和剩余一半的区别:

class ThreadData

public:
    int _number;
    pthread_t _tid;
    char _buf[64];
;

void* start_stream(void* args)

    ThreadData *ptd = static_cast<ThreadData *>(args);
    int cnt = 5;
    while(cnt)
    
        printf("i am new thread: %s cnt: %d &cnt: 0x%x\\n", ptd->_buf, cnt, &cnt);
        cnt--;
        sleep(1);
    
    // return nullptr;
     pthread_exit((void*)100);// 结束线程


#define NUM 10

int main()

    // 创建一批线程
    std::vector<ThreadData*> tids;
    for(int i = 1; i <= NUM; i++)
    
        ThreadData *ptd = new ThreadData();
        ptd->_number = i;
        snprintf(ptd->_buf, sizeof(ptd->_buf), "%s:%d", "thread", i);
        pthread_create(&ptd->_tid, nullptr, start_stream, (void*)ptd);
        tids.push_back(ptd);
    
    for(auto& e : tids)
    
        printf("creat thread: %s : 0x%x success\\n", e->_buf, e->_tid);
    

    // 取消一半的线程
    for(int i = 0; i < tids.size() / 2; i++)
    
        pthread_cancel(tids[i]->_tid);
    
    // 线程等待
    for(auto& e : tids)
    
        void* ret = nullptr;
        int n = pthread_join(e->_tid, &ret);
        assert以上是关于linux多线程控制详述的主要内容,如果未能解决你的问题,请参考以下文章

关于WinSock编程的多线程控制

[C++多线程]1.3-多线程控制的另一种姿势-条件变量(condition_variable), 信号量(semaphore)

[C++多线程]1.3-多线程控制的另一种姿势-条件变量(condition_variable), 信号量(semaphore)

shell多线程控制

带有 std::cout 的多线程控制台文本动画

线程概念及多线程控制