C++ thread编程（Linux系统为例）—thread成员函数与thread的创建方法

已于 2023-05-22 13:12:14 修改
阅读量1.6k 收藏 2
点赞数 2
分类专栏： C++知识 文章标签： c++ 开发语言
于 2023-05-21 20:11:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qaaaaaaz/article/details/130794725
版权

c++ 11 之后有了标准的线程库：std::thread。
参考thread库的使用

成员函数

构造函数

thread的构造函数有下面四个重载

默认构造函数

thread() noexcept

初始化构造函数

template <class Fn, class... Args>
explicit thread (Fn&& fn, Args&&... args);

该函数使用可变参数模板来构造一个线程对象，用来代表一个新的可join的执行线程。这个执行线程通过可变参数传入线程函数对象fn，以及函数的参数列表（可以简单理解为通过传值的方式将参数传给该构造函数）

拷贝构造函数

thread (const thread&) = delete;

线程不支持拷贝构造

移动构造

thread(thread&&x) noexcept;

转移参数x所代表的可执行指令的所有权，而不会影响线程的执行，转移后，参数x不再代表任何执行线程。

析构函数

析构函数用于销毁线程，如果这个线程是可以join的，那么析构函数会调用terminate()函数来终止线程。在thread对象被销毁之前应该尽可能将其join或者detach，以防止执行线程因为对象销毁而终止。

#include<iostream>
#include<thread>
#include<unistd.h>
using namespace std;
void printtHelloWorld(){
    while(true){
        cout<<"hello world"<<endl;
        sleep(1);
    }
}

int main(){
    thread t1(printtHelloWorld);
    sleep(3);
    t1.~thread();
    return 0;
}

在这里插入图片描述

operator=

thread& operator= (thread&& rhs) noexcept;
thread& operator= (const thread&) = delete;

thread对象不允许拷贝构造，同样的对于赋值操作符的重载实质是移动赋值。


#include<iostream>
#include<thread>
using namespace std;
void printHelloWorld(){
    cout<<"Hello World!"<<endl;
}
int main(){
    thread t1;
    t1 = thread(printHelloWorld);
    t1.join();
    return 0;
}

编译g++ test.cpp -std=c++11 -lpthread - o test
在这里插入图片描述

joinable

如果thread对象代表了一个执行线程，那么可以joinable。
C++中有几种情况不能joinable

  • 默认构造
  • 执行过move操作
  • 执行过join或者detach
#include<iostream>
#include<thread>
using namespace std;
void printHelloWorld(){
    cout<<"Hello World!"<<endl;
}
int main(){
    thread t1;
    if(!t1.joinable()){
        cout<<"Thread is not joinable! (default constructor)"<<endl;
    }
    t1 = thread(printHelloWorld);
    if(t1.joinable()){
        cout<<"Thread is joinable! (represents a thread of execution)"<<endl;
        t1.join();
        if(!t1.joinable()){
            cout<<"Thread is not joinable! (after call join())"<<endl;
        }
    }
    thread t3;
    thread t2(printHelloWorld);
    t3 = move(t2);
    if(!t2.joinable()){
        cout<<"Thread is not joinable! (after move)"<<endl;
    }
    t3.join();
    return 0;
}


Thread is not joinable! (default constructor)
Thread is joinable! (represents a thread of execution)
Hello World!
Thread is not joinable! (after call join())
Thread is not joinable! (after move)
Hello World!

join

线程执行完毕后函数返回，join函数可以用来阻塞调用此函数的线程，调用这个函数之后，线程对象将变成非joinable并且可以被安全销毁。

#include<iostream>
#include<thread>
#include<unistd.h>
using namespace std;
void pauseThread(int n){
    sleep(n);
    std::cout<<"pause of "<<n<<" seconds ended"<<std::endl;
}
int main(){
    cout<<"spawing 3 threads..."<<endl;
    std::thread t1(pauseThread,1);
    std::thread t2(pauseThread,2);
    std::thread t3(pauseThread,3);
    cout<<"Done spawning threads. Now wait for them to join: "<<endl;
    t1.join();
    t2.join();
    t3.join();
    cout<<"All threads joined!"<<endl;
    return 0;
}

在这里插入图片描述

detach

这个函数会将执行线程与调用线程分离，允许它们彼此独立运行，任意一个线程结束之后会释放拥有的资源。调用之后，线程对象会变成非joinable并且可以安全销毁。

#include<iostream>
#include<thread>
#include<unistd.h>
using namespace std;
void pauseThread(int n){
    this_thread::sleep_for(chrono::seconds(n));
    std::cout<<"pause of "<<n<<" seconds ended"<<std::endl;
}
int main(){
    cout<<"spawing 3 threads..."<<endl;
    std::thread (pauseThread,1).detach();
    std::thread (pauseThread,2).detach();
    std::thread (pauseThread,3).detach();
    cout<<"Done spawning threads. (the main thread will now pause for 5 seconds)"<<endl;
    pauseThread(5);
    return 0;
}

在这里插入图片描述

创建方法

一般函数创建

#include<iostream>
#include<thread>
#include<unistd.h>
using namespace std;
void printtHelloWorld(){
    while(true){
        cout<<"hello world"<<endl;
        sleep(1);
    }
}

int main(){
    thread t1(printtHelloWorld);
    sleep(3);
    t1.~thread();
    return 0;
}

类的成员函数创建

类外创建

#include<iostream>
#include<thread>
#include<unistd.h>
using namespace std;
class SaySomething{
public:
    void sayHello(){
        cout<<"Hello World!\n";
    }
    void saySomething(string str){
        cout<<str;
    }
    static void sayHelloStatic(){
        cout<<"Hello static!\n";
    }
};
int main(){
    SaySomething sh;
    thread t(&SaySomething::sayHello,&sh);                      //需要传入对象的地址
    thread t1(&SaySomething::saySomething,&sh,"Hello cpp!\n");  //需要传入对象的地址和参数
    thread t2(&SaySomething::sayHelloStatic);                   //静态成员函数不需要传入对象的地址,因为静态成员函数不属于对象
    t.join();
    t1.join();
    t2.join();
    return 0;
}

在这里插入图片描述

类内创建thread对象

#include<iostream>
#include<thread>
#include<unistd.h>
using namespace std;
class SaySomething{
private:
    thread workThread;
    void sayHello(){
        cout<<"Hello world!\n";
    }
public:
    SaySomething(){
        workThread=thread(&SaySomething::sayHello,this);  //需要传入对象的地址
    }
    ~SaySomething(){
        workThread.join();                                //等待线程结束,防止主线程退出时子线程被强制结束
    }
};
int main(){
    SaySomething saySomething; //Hello World!
    return 0;
}

使用函数类创建

使用函数类创建

重载operator()来实现类似于函数的操作

#include<iostream>
#include<thread>
#include<unistd.h>
using namespace std;
class FunctionObject{
public:
    void operator()(string str){
        cout << str << endl;
    }
    void operator()(){
        cout << "Hello World!\n";
    }
};
int main(){
    FunctionObject fo;
    thread t(fo);                       //无参数版本
    thread t1(fo, "Hello parameter!\n");    //有参数版本
    t.join();
    t1.join();
    return 0;
}

在这里插入图片描述

lambda函数创建

#include<bits/stdc++.h>
using namespace std;
int main(){
    thread t([]{
        cout << "Hello from thread!" << endl;
    });
    t.join();
    return 0;
}

function类创建

function类实例化的对象可以包装以下任何类型的可调用对象：函数、函数指针、指向成员函数的指针或者任何类型的函数对象（即，其类定义 operator()的对象，包括闭包）

#include<iostream>
#include<thread>
#include<unistd.h>
#include<functional>
using namespace std;
void add(int a,int b){
    cout<<"Sum is: "<<a+b<<"\n";
}
int main(){
    function<void(int,int)> f=add;                          //function类包装add函数
    function<void(void)> f1 = bind(add,15,25);              //function包装一个闭包
    function<void(void)> f2 = [](){cout<<"from lambda"<<endl;};//function类包装一个lambda函数
    thread t(f,10,20); 
    sleep(1);                                     //需要传递参数，输出Sum is: 30
    thread t1(f1);      
    sleep(1);                                    //无需传参，输出Sum is: 40
    thread t2(f2);                                          //无需传参
    t.join();
    t1.join();
    t2.join();
    return 0;
}

在这里插入图片描述

bind的返回值创建

bind可以将函数和参数绑定为一个函数对象。

#include<iostream>
#include<thread>
#include<unistd.h>
#include<functional>
using namespace std;
void add(int a,int b){
    cout<<"Sum is: "<<a+b<<"\n";
}
int main(){
    auto f1 = bind(add,5,10);
    f1();                           // Sum is: 15
    auto f2 = bind(add,placeholders::_1,placeholders::_2);
    f2(10,20);                      // Sum is: 30
    thread t1(f1);
    thread t2(f2,20,30);
    t1.join();                      // Sum is: 15 来自线程的执行结果
    t2.join();                      // Sum is: 50 来自线程的执行结果
    return 0;
}

在这里插入图片描述

qaaaaaaz
关注
专栏目录
C++11thread实现类成员函数线程的三种方法
m0_60352504的博客
05-17 2065
回调函数是通过指针调用的函数
c++多线程编程--thread成员函数
大海中的游鱼
10-25 1549
thread成员函数 thread类提供了丰富的成员函数帮助用户实现多线程编程。我们把构造函数单独拎出来作为一章来介绍。如下 thread构造函数 非构造函数的成员函数介绍： 序号 函数格式 返回值 意义 1 join() void 让当前线程等待线程t执行完成 2 joinable() bool 判断当前线程是否可以join 3 detach() void 继续执行当前线程，不必等待线程t执行完成 4 get_id() std::thread::id 获取线程id 5 st
c++ 学习之 多线程（三） thread类的成员函数
weixin_45074185的博客
02-19 2606
c++ 学习之 多线程（三） thread类的成员函数 前言 thread类提供了几个成员函数，由于构造函数之前有讲过，所以本文着重分析一下其他函数的用法。 正文 1.~thread() 析构函数，用来销毁thread对象，但是调用析构函数的前提必须是该thread对象是不可连接的，否则不可以。 2.joinable() 调用这个函数来判断该thread对象是否可连接，可以返回真，否则返回假。...
C++ Thread线程
最新发布
sssxlxwbwz的博客
09-29 1582
x += 1;// 传递临时变量t.join();return 0;上面的例子中，线程入口函数foo接受一个整数引用作为参数，并将该引用加1。然后，创建了一个名为`t`的线程，将`foo`函数以及一个临时变量`1`作为参数传递给它。这样会导致在线程函数执行时，临时变量`1`被销毁，从而导致未定义行为。解决方案是将变量复制到一个持久的对象中，然后将该对象传递给线程。例如，我们可以将`1`复制到一个`int`类型的变量中，然后将该变量的引用传递给线程。x += 1;int x = 1;
C++ 线程函数是类的成员函数
05-09
C++ 线程函数是类的成员函数 C++ 线程函数是类的成员函数
Solaris 多线程[转]
rzexin的专栏
07-28 560
http://blog.chinaunix.net/u2/70445/showart.php?id=1018785 1.         线程 创建一个缺省的线程 缺省的线程的属性： l         非绑定 l         未分离 l         一个缺省大小的堆栈 l         具有和父线程一样的优先级   用 phread_attr
C++ std::thread使用类成员函数作为线程的入口
guoxuxing的博客
12-21 5766
C++ std::thread使用类成员函数作为线程的入口
c++ 多线程 类成员函数_C++11并发编程：多线程std::thread
weixin_39737831的博客
11-28 1196
一：概述C++11引入了thread类，大大降低了多线程使用的复杂度，原先使用多线程只能用系统的API，无法解决跨平台问题，一套代码平台移植，对应多线程代码也必须要修改。现在在C++11中只需使用语言层面的thread可以解决这个问题。所需头文件二：构造函数1.默认构造函数thread() noexcept一个空的std::thread执行对象2.初始化构造函数templateexplicit t...
C++11并发编程:多线程std::thread
08-26
thread类提供了多种构造函数、成员函数和静态函数，以满足不同的多线程编程需求。 二、构造函数 1. 默认构造函数 thread() noexcept：创建一个空的std::thread执行对象。 2. 初始化构造函数 template, class......
Linux c++多线程串口编程demo
01-26
在Linux系统中，C++是一种常用的编程语言，用于开发高效且复杂的软件，特别是在涉及系统级编程和硬件交互时。本示例"Linux c++多线程串口编程demo"聚焦于利用多线程技术实现串口通信，这是一种常见的硬件接口，用于...
C++ Thread使用类成员函数
kh815的博客
03-25 9811
C++ Thread使用类成员函数示例代码编译运行结果 示例代码 #include <thread> #include <iostream> using std::cout; using std::endl; using std::thread; class Job { public: Job(int m) : _m(m){} void doSomeThing(int a, int b) { int c = a + b + _m; cout <&lt
Linux C++11——多线程类thread
YBAdiam的博客
03-10 4639
一、并发和并行 1、并行(parallel) 指在同一时刻，有多条指令在多个处理器上同时执行。就好像两个人各拿一把铁锨在挖坑，一小时后，每人一个大坑。所以无论从微观还是从宏观来看，二者都是一起执行的。 2、并发(concurrency) 指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。这就好像两个人用同一把铁锨，轮流挖坑，一小时后，两个人各挖一个小一点的坑，要想挖两
Linux 下 c++ 类内使用多线程 std::thread
qq_18076309的博客
11-01 474
Linux 下 c++ 类内使用多线程 std::thread。
Linux C++的多线程编程
m0_74282605的博客
01-29 1043
线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务
C++11 std::thread-成员函数-GCC 4.9编译通过
zxgailixien的博客
09-01 653
1.get_id() 获取线程ID，返回类型std::thread::id对象。 2.join() 创建线程执行线程函数，调用该函数会阻塞当前线程，直到线程执行完join才返回。 3.detach() detach调用之后，目标线程就成为了守护线程，驻留后台运行，与之关联的std::thread对象失去对目标线程的关联，无法再通过std::thread对象取得该线程的控制权 4.swap() 交换两个线程对象 thread t1(threadFun1); thread t2(threadFun2);
C++_2——thread & Linux多线程
fangfang12138的博客
08-27 531
C++_2——thread & Linux多线程线程的创建、资源回收线程锁线程池线程通信与同步线程安全线程与进程进程间的通信方式其他摘抄和参考 线程的创建、资源回收 #include <thread> // 构造函数 // 默认构造 thread() noexcept; // 显式构造：输入重载函数的函数指针，导致编译错误 template <class Fn, class... Args> explicit thread (Fn&& fn, Arg
C++11 之 thread线程类
weixin_45782027的博客
06-02 2889
在C++11之前，C / C++一直是一种顺序的编程语言。顺序是指所有指令都是串行执行的，即在相同的时刻，有且仅有单个CPU的程序计数器指向可执行代码的代码段，并运行代码段中的指令。而C / C++代码也总是对应地拥有一份操作系统赋予进程的包括堆、栈、可执行的（代码）及不可执行的（数据）在内的各种内存区域。在C++11 标准中，增加了线程以及线程相关的类，很方便地支持了并发编程，使得编写的多线程程序的可移植性得到了很大的提高。
C++11多线程
gx1589969的博客
07-09 1094
1、std::thread 在C++11之前，C++语言层面是不支持多线程的，想利用C++实现并发程序，借助操作系统的API实现跨平台的并发程序存在着诸多不便，当C++11在语言层面支持多线程后，编写跨平台的多线程代码就方便了许多。 C++11提供的std::thread在开发多线程方面带来了便捷。 #include <iostream> #include <thread> void threadfunc() { std::cout << "thread
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值