C++之多线程(一)

简介: C++进阶之多线程上

导读

终于,在万众期待之下,C++11有了自己的线程库,实现了真正意义上的跨平台,今天在了解C++11线程库的同时,也来温习下POSIX线程。

POSIX线程

在C++11之前因为没有C++语言没有语言级别的线程库,所以在Linux上用的都是POSIX线程,POSIX的相关API大概如下:

POSIX函数 功能
pthread_create 创建线程
pthread_exit 退出线程
pthread_join 等待线程退出
pthread_cancel 取消线程
pthread_detach 线程分离
pthread_self 获取线程id
pthread_equal 对比是否是同一线程,返回0是同一个线程

1、创建线程
创建线程的原型是:

int pthread_create(pthread_t _Nullable * _Nonnull __restrict,
        const pthread_attr_t * _Nullable __restrict,
        void * _Nullable (* _Nonnull)(void * _Nullable),
        void * _Nullable __restrict);

其中pthread_t是线程id,传入一个指针即可,如果创建成功会赋值为所创建线程的id。

pthread_attr_t是创建线程所需的参数,通过这些参数可以定制线程的属性,比如可以指定新建线程栈的大小、调度策略等,如果不需要传NULL即可。

第三个参数是一个函数指针,是线程创建成功所需要具体执行的任务函数。

第四个是线程携带参数,这个参数会在线程的函数指针执行时传递过去。

例如:


class Task{
public:
    void doSomeThing(){
        std::cout << "子线程的线程id:" << pthread_self() << std::endl;
        std::cout << "执行点什么任务吧" << std::endl;
    }
};

void* doWork(void * args){
    Task *task = static_cast<Task*>(args);
    if(nullptr != task){
        task->doSomeThing();
    }
}

int main() {
    std::cout << "主线程的线程id:" << pthread_self() << std::endl;
    // 创建线程
    pthread_t pthread;
    Task task;
    pthread_create(&pthread,nullptr,doWork,&task);
    pthread_join(pthread, nullptr); // 线程等待执行完毕
    return 0;
}

2、线程退出

正确的线程退出方式是在退出线程之后,再连接线程,
因为如果在线程退出后不执行连接操作,线程的资源就不能被释放,也不能被复用,这就造成了资源的泄漏。
所谓的连接操作就是在线程退出后使用pthread_join即可。

更多其他的线程函数这里就不展开细说了,因为今天的主要内容还是C++11的线程知识。

更多关于POSIX线程的知识,笔者之前看过《Linux环境编程XXXX》(为避免广告就不写完整书名了)这本书讲的就不错。

C++11的线程

先来看一个C++11多线程的例子:

void doWork() {
    std::cout << "执行点什么任务吧" << std::endl;
}

int main() {
    thread thread(doWork);
    std::cout << "thread.joinable:" << thread.joinable()<< std::endl;
    thread.join();
    std::cout << "thread.joinable:" << thread.joinable()<< std::endl;
    return 0;
}

是不是比POSIX线程简洁得多?

1、线程分离
如果在上面的例子中,我们将join改成detach则表示我们不再接管这个线程了,相当于驻留在后台,完全被C++运行时库所接管了,当线程运行结束后,由C++运行库清理相关的线程资源。

需要说明的是上面的例子如果把join改成detach的话很大可能就看不到输出了,但是这是正常的,而且一旦线程被detach之后就不能再被join了。

对于一个线程我们可以通过joinable函数判断是否可以join或者detach,如果一个线程已经被join或者detach的,那么joinable则会返回false。

2、线程传参

如果在线程执行的时候,我们想给线程传递参数那该怎么办呢?

如果需要给线程传递参数,那么我们只需要在线程执行函数后增加参数,然后将实参传入线程的构造函数中即可,例如:

void doWork(int a) {
    std::cout << "我是传递过来的参数a:" << a << std::endl;
    std::cout << "执行点什么任务吧" << std::endl;
}

int main() {
    thread thread(doWork,100); // 传参数的例子
    thread.join();
    return 0;
}

既然涉及到传参,那么又回到了C++老生常谈的问题了,给线程传递参数,到底是按照值传参呢还是按照指针传参呢还是按照引用传参呢?

首先来看看以下的这个例子:

void doWork(const int &a) {
    this_thread::sleep_for(std::chrono::seconds(1)); // 休眠
    std::cout << "我是传递过来的参数a的地址:" << a << std::endl;
    std::cout << "我是传递过来的参数a:" << a << std::endl;
}

void threadTest(){
    int a = 130;
    std::cout << "a的地址:" << &a << std::endl;
    thread thread(doWork,a);
}

int main() {
    threadTest();
    this_thread::sleep_for(std::chrono::seconds(3)); // 休眠3s,让子线程执行
    return 0;
}

理论上来说上面的这个例子是有问题的,为什么呢?线程是在函数threadTest内开启的,但是函数返回时就销毁了栈变量thread,所以运行的时候我们是看到会报错的,以下是输出:

libc++abi: terminating // 注释,这是报错
a的地址:0x16f2fb7cc

所以如果我们想要在一个函数内部开启一个线程,需要在线程的任务执行结束之前线程变量thread不要被销毁,需要使用堆指针或者局部变量的方式。

首先我们来测试一下值传递的方式:


class Task {
public:

    Task(){
        std::cout << "构造函数,线程id:" << this_thread::get_id() << std::endl;
    }

    Task(const Task &task):a(task.a){
        std::cout << "拷贝构造,线程id:" << this_thread::get_id() << std::endl;
    }

    ~Task(){
        std::cout << "析构函数,线程id:" << this_thread::get_id() << std::endl;
    }

    void doSomeThing() const{
        std::cout << "-------------执行点什么任务吧,现在a是多少:" << a  << std::endl;
    }

public:
    int a;
};

void doWork(Task task) {
    std::cout << "----doWork   线程id:" << this_thread::get_id() << std::endl;
    this_thread::sleep_for(std::chrono::seconds(1)); // 休眠
    std::cout << "我是传递过来的参数地址:" << &task << std::endl;
    // 执行任务
    task.doSomeThing();
}

void threadTest(){
    Task task;
    task.a = 100;
    std::cout << "原始的地址:" << &task << std::endl;
    // 为了不让线程变量销毁,这里用堆指针测试,暂时不考虑指针释放
    thread *th = new thread(doWork,task);
    std::cout << "线程id:" << th->get_id() << std::endl;
    th->join();
}

int main() {
    std::cout << "主线程id:" << std::this_thread::get_id() << std::endl;
    threadTest();
    this_thread::sleep_for(std::chrono::seconds(3)); // 休眠3s,让子线程执行
    return 0;
}

下面是输出:

主线程id:0x1050a4580
构造函数,线程id:0x1050a4580
原始的地址:0x16af237bc
拷贝构造,线程id:0x1050a4580
拷贝构造,线程id:0x1050a4580
析构函数,线程id:0x1050a4580
线程id:0x16afab000
拷贝构造,线程id:0x16afab000
----doWork   线程id:0x16afab000
我是传递过来的参数地址:0x16afaaf3c
-------------执行点什么任务吧,现在a是多少:100
析构函数,线程id:0x16afab000
析构函数,线程id:0x16afab000
析构函数,线程id:0x1050a4580

在上面的测试中我们发现如果是通过值传递的方式的话,如果需要使用多线程,则会经历三次拷贝的过程,这着实是有点性能的消耗了。

不是说通过引用可以减少拷贝吗?那我们来测试下引用的传递的情况是怎么样子的,还是以上的程序,我们修改一下函数doWork

void doWork(const Task &task) {
    std::cout << "----doWork   线程id:" << this_thread::get_id() << std::endl;
    this_thread::sleep_for(std::chrono::seconds(1)); // 休眠
    std::cout << "我是传递过来的参数地址:" << &task << std::endl;
    // 执行任务
    task.doSomeThing();
}

看看输出:

主线程id:0x1041f0580
构造函数,线程id:0x1041f0580
原始的地址:0x16bcc77bc
拷贝构造,线程id:0x1041f0580
拷贝构造,线程id:0x1041f0580
析构函数,线程id:0x1041f0580
线程id:0x16bd4f000
----doWork   线程id:0x16bd4f000
我是传递过来的参数地址:0x6000016c1110
-------------执行点什么任务吧,现在a是多少:100
析构函数,线程id:0x16bd4f000
析构函数,线程id:0x1041f0580

对比前面的值传递我们发现是少了一次拷贝,但是不是说值传递调用函数不拷贝吗?这里怎么还是进行了拷贝,而且是两次拷贝呢?
其实说引用传递不拷贝是对于直接调用来说的,这里的多线程调用,系统并不会马上给你调用任务函数,而是内部经历了n次的封装才调用到开发者制定的任务函数,所谓的没有中间商赚差价也是相对而言的...

注意:虽然是使用了引用,但是内部还是经历了拷贝,那么如果希望通过传递引用,然后在线程函数内部修改值然后在线程函数外起作用这个想法就行不通了哦。

再来看看指针的传递,我们修改下函数threadTestdoWork

void doWork(Task *task) {
    std::cout << "----doWork   线程id:" << this_thread::get_id() << std::endl;
    this_thread::sleep_for(std::chrono::seconds(1)); // 休眠
    std::cout << "我是传递过来的参数地址:" << task << std::endl;
    // 执行任务
    task->doSomeThing();
}

void threadTest(){
    Task *task = new Task;
    task->a = 100;
    std::cout << "原始的地址:" << task << std::endl;
    // 为了不让线程变量销毁,这里用堆指针测试,暂时不考虑指针释放
    thread *th = new thread(doWork,task);
    std::cout << "线程id:" << th->get_id() << std::endl;
}

输出:

主线程id:0x1009fc580
构造函数,线程id:0x1009fc580
原始的地址:0x6000033ac030
线程id:0x16f63b000
----doWork   线程id:0x16f63b000
我是传递过来的参数地址:0x6000033ac030
-------------执行点什么任务吧,现在a是多少:100

厉害了,居然没有发生对象的拷贝,虽然内部还是发生了指针的拷贝,但是这个损耗是可以忽略不计的,看来如果要给多线程传参还是得指针呀。

既然是指针,又要陷入谁维护,谁释放的漩涡了。。。

试下智能指针?还是修改下函数threadTestdoWork

void doWork(const shared_ptr<Task> &ptr) {
    std::cout << "----doWork   线程id:" << this_thread::get_id() << std::endl;
    this_thread::sleep_for(std::chrono::seconds(1)); // 休眠
    std::cout << "我是传递过来的参数地址:" << ptr << std::endl;
    // 执行任务
    ptr->doSomeThing();
}

void threadTest(){
    shared_ptr<Task> ptr = make_shared<Task>();
    ptr->a = 100;
    std::cout << "原始的地址:" << ptr.get() << std::endl;
    // 为了不让线程变量销毁,这里用堆指针测试,暂时不考虑指针释放
    thread *th = new thread(doWork,ptr);
    std::cout << "线程id:" << th->get_id() << std::endl;
}

输出:

主线程id:0x10502c580
构造函数,线程id:0x10502c580
原始的地址:0x6000000d9118
线程id:0x16b033000
----doWork   线程id:0x16b033000
我是传递过来的参数地址:0x6000000d9118
-------------执行点什么任务吧,现在a是多少:100
析构函数,线程id:0x16b033000

小结

1、给线程任务传递参数的话如果是一般的数据类型,比如int等的建议直接使用值传递即可。
2、如果是传递复杂的类的参数的话,建议使用智能指针。

推荐阅读

《C++之指针扫盲》
《C++之智能指针》
《C++之指针与引用》
《C++之右值引用》

目录
相关文章
|
3月前
|
存储 Java 程序员
C++多线程编程基础
C++多线程编程基础
35 2
|
4天前
|
Java 调度
基于C++11的线程池
基于C++11的线程池
|
26天前
|
算法 编译器 C++
开发与运维线程问题之在C++的原子操作中memory_order如何解决
开发与运维线程问题之在C++的原子操作中memory_order如何解决
20 2
|
4天前
|
Dart 编译器 API
Dart ffi 使用问题之在C++线程中无法直接调用Dart函数的问题如何解决
Dart ffi 使用问题之在C++线程中无法直接调用Dart函数的问题如何解决
|
4天前
|
Dart API C语言
Dart ffi 使用问题之想在C/C++中创建异步线程来调用Dart方法,如何操作
Dart ffi 使用问题之想在C/C++中创建异步线程来调用Dart方法,如何操作
|
26天前
|
Rust 安全 程序员
Rust与C++的区别及使用问题之Rust解决多线程下的共享的问题如何解决
Rust与C++的区别及使用问题之Rust解决多线程下的共享的问题如何解决
|
26天前
|
Rust 编译器 程序员
Rust与C++的区别及使用问题之Rust避免多线程中的lifetime的问题如何解决
Rust与C++的区别及使用问题之Rust避免多线程中的lifetime的问题如何解决
|
2月前
|
存储 设计模式 安全
C++一分钟之-并发编程基础:线程与std::thread
【6月更文挑战第26天】C++11的`std::thread`简化了多线程编程,允许并发执行任务以提升效率。文中介绍了创建线程的基本方法,包括使用函数和lambda表达式,并强调了数据竞争、线程生命周期管理及异常安全等关键问题。通过示例展示了如何用互斥锁避免数据竞争,还提及了线程属性定制、线程局部存储和同步工具。理解并发编程的挑战与解决方案是提升程序性能的关键。
52 3
|
2月前
|
安全 程序员 C++
C++一分钟之-原子操作与线程安全
【6月更文挑战第27天】**C++的`std::atomic`提供线程安全的原子操作,解决多线程数据竞争。涵盖原子操作概念、应用、问题与对策。例如,用于计数器、标志位,但选择数据类型、内存顺序及操作组合需谨慎。正确使用能避免锁,提升并发性能。代码示例展示自旋锁和线程安全计数。了解并恰当运用原子操作至关重要。**
46 1
|
2月前
|
存储 Linux C语言
c++进阶篇——初窥多线程(二) 基于C语言实现的多线程编写
本文介绍了C++中使用C语言的pthread库实现多线程编程。`pthread_create`用于创建新线程,`pthread_self`返回当前线程ID。示例展示了如何创建线程并打印线程ID,强调了线程同步的重要性,如使用`sleep`防止主线程提前结束导致子线程未执行完。`pthread_exit`用于线程退出,`pthread_join`用来等待并回收子线程,`pthread_detach`则分离线程。文中还提到了线程取消功能,通过`pthread_cancel`实现。这些基本操作是理解和使用C/C++多线程的关键。