C++11 thread

最新推荐文章于 2024-07-30 16:49:59 发布
最新推荐文章于 2024-07-30 16:49:59 发布
阅读量981 收藏
点赞数
分类专栏： linux服务器高级框架 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kakaka666/article/details/127912594
版权

目录

线程thread

主要成员函数

简单线程的创建 

线程封装 

zero_thread.h

zero_thread.cpp

main.cpp

C/C++Linux服务器开发/后台架构师【零声教育】-学习视频教程-腾讯课堂

线程thread

std::thread 在 #include 头文件中声明，因此使用 std::thread 时需要包含 #include 头文件。

#include <thread> // 头文件

std::thread（...）

主要成员函数

get_id()
获取线程ID，返回类型std::thread::id对象。
http://www.cplusplus.com/reference/thread/thread/get_id/


joinable()
判断线程是否可以加入等待
http://www.cplusplus.com/reference/thread/thread/joinable/


join()
等该线程执行完成后才返回。
http://www.cplusplus.com/reference/thread/thread/join/


detach()

        detach调用之后，目标线程就成为了守护线程，驻留后台运行，与之关联的std::thread对象失去对目标线程的关联，无法再通过std::thread对象取得该线程的控制权。当线程主函数执行完之后，线程就结束了，运行时库负责清理与该线程相关的资源。

        调用 detach 函数之后：
        *this 不再代表任何的线程执行实例。
        joinable() == false
        get_id() == std::thread::id()
http://www.cplusplus.com/reference/thread/thread/detach/

简单线程的创建 

1. 传入0个值
2. 传入2个值
3. 传入引用
4. 传入类函数
5. detach
6. move 
#include <iostream>
#include <thread>
using namespace std;

// 1 传入0个值
void func1()
{
	cout << "func1 into" << endl;
}

// 2 传入2个值
void func2(int a, int b)
{
    cout << "func2 a + b = " << a + b << endl;
}

void func2_1(int a, int b)
{
    cout << "func2_1 a + b = " << a + b << endl;
}

int func2_1(string a, string b)
{
    cout << "func2_1 a + b = " << a << b << endl;
    return 0;
}

// 3 传入引用
void func3(int& c) // 引用传递
{
	cout << "func3 c = " << &c << endl;
	c += 10;
}

//4. 传入类函数
class A
{
public:   
    void func4(int a)
    {
        //阻塞当前线程执行，至少经过指定的 sleep_duration
        std::this_thread::sleep_for(std::chrono::seconds(1));
        cout << "thread:" << name_ << ", fun4 a = " << a << endl;

    }
    void func4(string str)
    {
        阻塞当前线程执行，至少经过指定的 sleep_duration
        //std::this_thread::sleep_for(std::chrono::seconds(1));
        cout << "thread:" << name_ << ", fun4 str = " << str << endl;
    }
    void setName(string name) {
        name_ = name;
    }
    void displayName() {
        cout << "this:" << this << ", name:" << name_ << endl;
    }
    void play()
    {
        std::cout << "play call!" << std::endl;
    }
private:
    string name_;
};

//5. detach
void func5()
{
    cout << "func5 into sleep " << endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    cout << "func5 leave " << endl;
}

// 6. move
void func6()
{
    cout << "this is func6 !" << endl;
}

int main()
{
	// 1 传入0个值
	cout << "\n\n main1--------------------------\n";
	std::thread t1(func1);	// 只传递函数
	t1.join();

	// 2 传入2个值
	cout << "\n\n main2--------------------------\n";
	int a =10;
	int b =20;
	std::thread t2(func2, a, b); // 加上参数传递,可以任意参数
	t2.join();

	std::thread t2_1((void(*)(int, int)) func2_1, a, b); // 加上参数传递,可以任意参数
	t2_1.join();

	std::thread t2_2((int(*)(string, string)) func2_1, "darren", " and mark"); // 加上参数传递,可以任意参数
	t2_2.join();

	// 3. 传入引用
    cout << "\n\n main3--------------------------\n";
    int c =10;
    std::thread t3(func3, std::ref(c)); // std::ref 加上参数传递,可以任意参数
    t3.join();
    cout << "main3 c = " << &c << ", "<<c << endl;

    //4. 传入类函数
    //重载
    cout << "\n\n main4--------------------------\n";
    A * a4_ptr = new A();
    a4_ptr->setName("kaka");
    std::thread t41((void(A::*)(int)) & A::func4, a4_ptr, 100);      // 重载void func4(int a)
    t41.join();
    delete a4_ptr;

    //重载
    cout << "\n\n main4--------------------------\n";
    A* a4_ptr_2 = new A();
    a4_ptr_2->setName("king");
    std::thread t42((void(A::*)(string)) & A::func4, a4_ptr_2, "king"); // 重载 int func4(string str)
    t42.join();
    delete a4_ptr_2;

    //   5.detach
    cout << "\n\n main5--------------------------\n";
    std::thread t5(func5);  // 只传递函数
    t5.detach();  // 脱离
    cout << "pid: " << t5.get_id() << endl; // t5此时不能管理线程了
    cout << "joinable: " << t5.joinable() << endl; // false 判断线程是否可以加入等待
    //t5.join();出错
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 如果这里不休眠会怎么样
    cout << " main5 end\n";

    // 6.move
    cout << "\n\n main6--------------------------\n";
    int x = 10;
    thread t6_1(func6);
    thread t6_2(std::move(t6_1)); // t6_1 线程失去所有权
    t6_1.join();  // 抛出异常   after throwing an instance of 'std::system_error'
    t6_2.join();

	return 0;
}

 

线程封装 

zero_thread.h

#ifndef ZERO_THREAD_H
#define ZERO_THREAD_H
#include <thread>

class ZERO_Thread
{
public:
    ZERO_Thread(); // 构造函数
    virtual ~ZERO_Thread(); // 析构函数
    bool start();
    void stop();
    bool isAlive(); // 线程是否存活.
    std::thread::id id() { return th_->get_id(); }
    std::thread* getThread() { return th_; }
    void join();  // 等待当前线程结束, 不能在当前线程上调用
    void detach(); //能在当前线程上调用
protected:
    void threadEntry();
    virtual void run() = 0; // 运行
protected:
    bool  running_; //是否在运行
    std::thread *th_;
};

#endif // ZERO_THREAD_H

zero_thread.cpp

#include "1-2-zero_thread.h"
#include <sstream>
#include <iostream>
#include <exception>
ZERO_Thread::ZERO_Thread():
    running_(false), th_(NULL)
{

}

ZERO_Thread::~ZERO_Thread()
{
    if(th_ != NULL)
    {
        //如果到调用析构函数的时候，调用者还没有调用join则触发detach，此时是一个比较危险的动作，用户必须知道他在做什么
        if (th_->joinable())
        {
            std::cout << "~ZERO_Thread detach\n";
            th_->detach();
        }

        delete th_;
        th_ = NULL;
    }
    std::cout << "~ZERO_Thread()" << std::endl;
}

bool ZERO_Thread::start()
{
    if (running_)
    {
        return false;
    }
    try
    {
        th_ = new std::thread(&ZERO_Thread::threadEntry, this);
    }
    catch(...)
    {
        throw  "[ZERO_Thread::start] thread start error";
    }
    return true;
}

void ZERO_Thread::stop()
{
    running_ = false;
}

bool ZERO_Thread::isAlive()
{
    return running_;
}

void ZERO_Thread::join()
{
    if (th_->joinable())
    {
        th_->join();  // 不是detach才去join
    }
}

void ZERO_Thread::detach()
{
    th_->detach();
}

void ZERO_Thread::threadEntry()
{
    running_ = true;

    try
    {
        run();   // 函数运行所在 调用子类的run函数
    }
    catch (...)
    {
        running_ = false;
        throw;
    }
    running_ = false;
}

main.cpp

#include <iostream>
#include <chrono>
#include "1-2-zero_thread.h"
using namespace std;

class A: public ZERO_Thread
{
public:
    void run()
    {
        while (running_)
        {
            cout << "print A " << endl;
            std::this_thread::sleep_for(std::chrono::seconds(5));
        }
        cout << "----- leave A " << endl;
    }
};

class B: public ZERO_Thread
{
public:
    void run()
    {
        while (running_)
        {
            cout << "print B " << endl;
            std::this_thread::sleep_for(std::chrono::seconds(2));
        }
        cout << "----- leave B " << endl;
    }
};

int main()
{
    {
        A a;
        a.start();
        B b;
        b.start();
        std::this_thread::sleep_for(std::chrono::seconds(5));
        a.stop();
        a.join(); // join之前不去stop
        b.stop();
        b.join();  // 需要我们自己join
    }
    cout << "Hello World!" << endl;
    return 0;
}

kaka的卡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++(11)：多线程thread
风静如云的博客
05-03 1282
C++11的标准库中封装了线程的类，因此可以跨平台的使用线程库： #include <iostream> #include <thread> #include <chrono> using namespace std; void tFunc(int a, const char* str) { cout<<"thread func run, param a:"<<a<<" param str:"<<str<&lt
C++11 线程池 ThreadPool
12-21
在C++11中，我们可以使用`std::thread`类来创建和管理线程。线程池管理器还需要一个任务队列来存储待执行的任务。 2. **任务队列**：线程池中的任务不是直接提交给某一线程执行的，而是先放入一个任务队列。当线程...
C++11多线程—thread
终为nullptr
04-06 1497
C++11多线程thread详解！
C++ 多线程库 ＜thread＞
最新发布
Aforxiaoxie的博客
07-30 438
要创建一个线程，你需要实例化 std::thread 类，并传递一个可调用对象（函数、lambda 表达式或对象的成员函数）作为参数。// 输出结果：Sum: 30。创建 std::thread 对象后，线程会立即开始执行，你可以调用 join() 方法来等待线程完成。std::future 和 std::promise 用于线程间的结果传递。std::async 用于启动异步任务，并返回一个 std::future。
C++：std::thread：线程用法
C++ JAVA的专栏
01-06 7870
C++：std::thread：线程用法
C++ thread多线程的几种方法
pluto_rx的博客
03-13 2309
进程与线程: 一个程序创建运行就是一个进程，一个进程有一个主线程，主线程唯一 主线程执行main函数中的代码，当main函数执行完毕，主线程终止，其生命周期与进程一致。 在主线程以外可以通过代码创建其他线程来执行函数或者其他程序。 c++头文件 : #include <thread> 创建线程一： 线程执行函数 例如要创建线程执行函数 hello() void hello() { cout<<"hello"<<endl; } 只需要在函数里面调用创建线程调用： voi
C++ thread用法总结(整理)
热门推荐
顺其自然~专栏
03-15 3万+
1，简介 C++11中加入了<thread>头文件，此头文件主要声明了std::thread线程类。C++11的标准类std::thread对线程进行了封装，定义了C++11标准中的一些表示线程的类、用于互斥访问的类与方法等。应用C++11中的std::thread便于多线程程序的移值。 std::thread类成员函数： (1)、get_id：获取线程ID，返回一个类型为std::thread::id的对象。 (2)、joinable：检查线程是否可被join。检查当前的线程对象是否表
Qt例程和C++11thread.7z
07-16
【标题】"Qt例程和C++11thread"是一个结合了Qt库和C++11新特性，特别是线程支持的主题。这个压缩包可能包含了若干示例代码和教程，帮助开发者了解如何在Qt应用程序中有效地使用C++11的线程功能。 【描述】描述中的...
Qt和C++11thread.7z
04-12
C++11引入了`<thread>`库，为C++添加了对并行编程的内置支持。它包括`std::thread`类，允许开发者创建和管理线程。通过使用`std::thread`，程序员可以直接在C++代码中启动新的执行线程，执行特定任务，从而实现并发...
线程池c++11 thread类
09-05
线程池在C++11中是通过`std::thread`类实现的，它是C++标准库中的一个关键部分，用于处理并发编程。线程池的概念源于并行处理，它是一种资源管理策略，通过预先创建一组线程来执行任务，而不是每次需要时都创建新...
c++11封装thread库的方法示例
08-26
C++11 封装 Thread 库的方法示例 在 C++11 中，std::thread 提供了对多线程的支持，然而不同的平台提供了不同线程 API，这使得代码移植变得困难。为了解决这个问题，C++11 提供了对 thread 的封装，使得多线程的...
C++多线程编程——thread线程创建与使用（2W字保姆级介绍）
qq_25218501的博客
08-25 3020
同步执行：同步，是所有的操作都做完，才返回给用户结果异步执行：异步，不用等所有操作都做完，就响应用户请求处理耗时操作（数据库大量写入或者查询、文件下载、复杂计算）同步操作：所有的操作都做完，才返回给用户，这样用户在线等待的时间太长，给用户一种卡死了的感觉异步操作：即先响应用户请求然后慢慢去执行耗时操作，用户体验较好。
C++并发编程之thread
LIEY
03-12 433
c++11中增加了线程，使得我们可以非常方便的创建线程，它的基本用法是这样的： void f(int n); std::thread t(f, n + 1); t.join(); 不同于pthread_join可以获取线程函数的返回值，std::thread的join函数并不能获取线程函数的返回值。C++11给出的解决方案是使用std::promise和std::future. std::fut...
C++：线程支持库 的介绍和使用
Sauron7i的博客
05-15 686
文章目录thread1. 构造函数2. join()3. detach()4. joinable()多线程下的全局变量1. 加入互斥量std::metux2. 条件变量 thread 定义在头文件#include<thread> 类 thread 表示单个执行线程。线程允许多个函数同时执行。 std::thread 对象也可能处于不表示任何线程的状态（默认构造、被移动、 detach 或 join 后），并且执行线程可能与任何 thread 对象无关（ detach 后）。 没有两个 std::
C++使用thread类多线程编程
weixin_30488313的博客
12-28 2754
C++11中引入了一个用于多线程操作的thread类，简单多线程示例： #include <iostream> #include <thread> #include <Windows.h> using namespace std; void thread01() { for (int i = 0; i < 5; ...
C++多线程编程：深入剖析std::thread的使用方法
Lion_Long的博客
11-18 7084
C++11 thread的语法、构造函数、主要成员函数、简单线程的创建详解。 介绍线程封装。更多函数std::this_thread、std::this_thread::get_id()、std::this_thread::yield()、std::this_thread::sleep_for等的使用。
C++11----语言级线程库<thread>
风清扬
04-11 340
std::thread 用于创建一个执行的线程实例，所以它是一切并发编程的基础，使用时需要包含头文件#include&lt;thread&gt;，它提供了很多基本的线程操作，例如get_id()来获取所创建线程的线程 ID，例如使用 join() 通知主线程等待其他线程退出，detach脱离主线程。例如：#include &lt;iostream&gt; #include &lt;thread&g...
C++11 之 thread线程类
weixin_45782027的博客
06-02 2771
在C++11之前，C / C++一直是一种顺序的编程语言。顺序是指所有指令都是串行执行的，即在相同的时刻，有且仅有单个CPU的程序计数器指向可执行代码的代码段，并运行代码段中的指令。而C / C++代码也总是对应地拥有一份操作系统赋予进程的包括堆、栈、可执行的（代码）及不可执行的（数据）在内的各种内存区域。在C++11 标准中，增加了线程以及线程相关的类，很方便地支持了并发编程，使得编写的多线程程序的可移植性得到了很大的提高。
C++多线程----thread实现篇
weixin_43956732的博客
07-31 796
与 C++11 多线程相关的头文件地方 C++11 新标准中引入了四个头文件来支持多线程编程，他们分别是<atomic> ,<thread>,<mutex>,<condition_variable>和<future>。 <atomic>：该头文主要声明了两个类, std::atomic 和 std::atomic_flag，另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。 <thread>：该头文件主要
c++11 thread
09-06
C11引入了对多线程编程的支持。C11标准提供了一个名为"threads.h"的头文件，其中定义了一些函数和类型，用于创建和管理线程。下面是一个简单的使用C11多线程的示例代码： ```c #include <stdio.h> #include <threads.h> int count = 0; int increment(void* arg) { for (int i = 0; i < 100; i++) { count++; } return 0; } int main() { thrd_t thread1, thread2; thrd_create(&thread1, increment, NULL); thrd_create(&thread2, increment, NULL); thrd_join(thread1, NULL); thrd_join(thread2, NULL); printf("Count: %d\n", count); return 0; } ``` 在上述代码中，我们创建了两个线程，它们执行的函数是`increment`。这个函数会将count值增加100次。通过`thrd_create`函数创建线程，通过`thrd_join`函数等待线程结束。最后，我们打印出count的值。 需要注意的是，C11对多线程的支持在不同平台上可能有差异，具体的实现可能会有所不同。此外，多线程编程需要注意线程间的同步和竞争条件等问题，以确保程序的正确性和可靠性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值