c++多线程

🕗 发布于 2024-11-16 13:34 c++

c++多线程

- - lambda的简单说明

lambda的简单说明

lambda的格式：
[捕获列表]<模板声明>(参数列表)mutable 异常说明->类型{函数体}

auto b = [](int a, int b) { return a + b; };

[]<class T>(T v) noexcept -> void{
    cout << v << endl;
}("blog.csdn.net");

//捕获列表 函数体必写 其他可省略 // 最短的lambda函数
auto b = [] { return 1; };

在这里插入图片描述

1.主线程在 t.join() 处阻塞，等待t线程执行完毕

2.std::thread::joinable() 用于检查 std::thread 是否可联结（joinable）joinable() 返回 false：线程对象未关联线程（未初始化），或线程已被 join() 或 detach()。 joinable()返回true：线程对象关联了一个有效的线程，且尚未 join()或detach()。

demo1 函数指针

thread t = thread(printMessage, 5);这行代码会立即启动一个新线程，执行传入的方法。这里和java不一样

#include<iostream>
#include<thread>
using namespace std;
void printMessage(int count) {
    for (int i = 0; i < count; ++i) {
        std::cout << "Hello from thread (function pointer)!\n";
    }
}
int main()
{

    thread t = thread(printMessage, 5);
    t.join();// 等待线程完成
    return 0;
}

demo2 仿函数 (函数对象)

使用对象的operator方法

#include <iostream>
#include <thread>

class PrintTask {
public:
    void operator()(int count) const {
        for (int i = 0; i < count; ++i) {
            std::cout << "Hello from thread (function object)!\n";
        }
    }
};

int main() {
    std::thread t2(PrintTask(), 5); // 创建线程，传递函数对象和参数
    t2.join(); // 等待线程完成
    return 0;
}

demo3 lambda表达式

使用lambda

#include<iostream>
#include<thread>
using namespace std;

int main()
{
    thread t( 
        [](int count){
            for (int i = 0; i < count; ++i) {
                        std::cout << "Hello from thread (lambda)!\n";
                    }
        },
        5
    );
    t.join();
    return 0;
}

std::mutex

std::mutex是 C++11 中最基本的互斥量，一个线程将mutex锁住时，其它的线程就不能操作mutex，直到这个线程将mutex解锁。

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int n = 0;
mutex mtx;// 全局互斥量
void count10000() {
for (int i = 1; i <= 10000; i++) {
mtx.lock(); // 请求锁定互斥量
n++;
mtx.unlock();// 释放互斥量
}
}
int main() {
thread th[10];
for (thread &x : th)
x = thread(count10000);
for (thread &x : th)
x.join();
cout << n << endl;
return 0;
}

还有一个bool try_lock()。尝试将mutex上锁。如果mutex未被上锁，则将其上锁并返回true；如果mutex已被锁则返回false。

std::atomic

原子操作确保对共享数据的访问是不可分割的，即在多线程环境下，原子操作要么完全执行，要么完全不执行，不会出现中间状态。

#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
std::atomic<int> n = 0;
void count10000() {
for (int i = 1; i <= 10000; i++) {
n++;
}
}
int main() {
thread th[100];
for (thread &x : th)
x = thread(count10000);
for (thread &x : th)
x.join();
cout << n << endl;
return 0;
}

thread_local

线程局部存储允许每个线程拥有自己的数据副本。这可以通过thread_local关键字实现，避免了对共享资源的争用。

#include <iostream>
#include <thread>
#include <atomic>
#include <mutex>
using namespace std;

thread_local int n = 0;
mutex mtx; // // 加锁只是保护输出

int main(int argc, char const *argv[])
{
    thread t1 =thread(
        []() {
            n= 1;
            mtx.lock();
            std::cout<<"thread1" << n << std::endl;
            mtx.unlock();
        }
    );
    thread t2 =thread(
        []() {
            n= 2;
            mtx.lock();
            std::cout <<"thread2" << n << std::endl;
            mtx.unlock();
        }
    );
     thread t3 =thread(
        []() {
             mtx.lock();
            std::cout <<"thread3" << n << std::endl;
             mtx.unlock();
        }
    );


    t1.join();
    t2.join();
    t3.join();
    return 0;
}

async

创建

template<class Fn, class... Args> future<typename result_of<Fn(Args...)>::type> async(launch policy, Fn&& fn, Args&&...args);

可以创建有返回结果的线程

thread 也是可以同步或异步的，异步detach()：将线程与主线程分离，使其独立执行。同步join()：让主线程等待该线程完成。

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
// #include <thread> // 这里我们用async创建线程
#include <future> // std::async std::future
using namespace std;

template<class ... Args> decltype(auto) sum(Args&&... args) {
// C++17折叠表达式
// "0 +"避免空参数包错误
return (0 + ... + args);
}

int main() {
// 注：这里不能只写函数名sum，必须带模板参数
future<int> val = async(launch::async, sum<int, int, int>, 1, 10, 100);
// future::get() 阻塞等待线程结束并获得返回值
cout << val.get() << endl;
return 0;
}

std::launch有2个枚举值和1个特殊值：

枚举值：launch::async		异步启动
枚举值：launch::deferred		在调用future::get、future::wait时同步启动（std::future见后文）
特殊值：launch::async \| launch::defereed		同步或异步，根据操作系统而定

#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <future>
 
using namespace std::chrono;
 
std::string fetchDataFromDB(std::string recvData) {
  //确保函数要5秒才能执行完成
  std::this_thread::sleep_for(seconds(5));
 
  //处理创建数据库连接、获取数据等事情
  return "DB_" + recvData;
}
 
std::string fetchDataFromFile(std::string recvData) {
  //确保函数要5秒才能执行完成
  std::this_thread::sleep_for(seconds(5));
 
  //处理获取文件数据
  return "File_" + recvData;
}
 
int main() {
  //获取开始时间
  system_clock::time_point start = system_clock::now();
 
  std::future<std::string> resultFromDB = std::async(std::launch::async, fetchDataFromDB, "Data");
 
  //从文件获取数据
  std::string fileData = fetchDataFromFile("Data");
 
  //从DB获取数据
  //数据在future<std::string>对象中可获取之前，将一直阻塞
  std::string dbData = resultFromDB.get();
 
  //获取结束时间
  auto end = system_clock::now();
 
  auto diff = duration_cast<std::chrono::seconds>(end - start).count();
  std::cout << "Total Time taken= " << diff << "Seconds" << std::endl;
 
  //组装数据
  std::string data = dbData +  " :: " + fileData;
 
  //输出组装的数据
  std::cout << "Data = " << data << std::endl;
 
  return 0;
}

只使用了5秒,而不是10秒

执行结果

对于执行结果：

我们可以使用get、wait、wait_for、wait_until等待执行结束

get：

get可以获得执行的结果。如果选择异步执行策略，调用get时，如果异步执行没有结束，get会阻塞当前调用线程，直到异步执行结束并获得结果，如果异步执行已经结束，不等待获取执行结果；

如果选择同步执行策略，只有当调用get函数时，同步调用才真正执行，这也被称为函数调用被延迟。

任务的结果只能被获取一次。再次调用会导致异常 std::future_error。

wait:

功能：等待异步任务完成。阻塞当前线程，直到任务完成。不会返回任务结果。结果可以通过 get() 获取。

wait_for()

功能：等待指定的时间，检查任务是否完成。

wait_until()

功能：等待直到指定的时间点，检查任务是否完成。

等待行为：阻塞到指定的时间点，如果任务在这段时间内完成则返回；否则返回超时状态。

返回值：返回 std::future_status 枚举值，和 wait_for() 相同。

//查询future的状态
std::future_status status;
do {
    status = future.wait_for(std::chrono::seconds(1));
    if (status == std::future_status::deferred) {
        std::cout << "deferred" << std::endl;
    } else if (status == std::future_status::timeout) {
        std::cout << "timeout" << std::endl;
    } else if (status == std::future_status::ready) {
        std::cout << "ready!" << std::endl;
    }
} while (status != std::future_status::ready);

std::future获取结果的方式有三种：

get：等待异步操作结束并返回结果
wait：等待异步操作结束，但没有返回值
waite_for：超时等待返回结果，还没执行完。上面示例中就是对超时等待的使用展示

注意事项

错误示范：

#include <iostream>
#include <future>
#include <thread>
#include <chrono>
#include <iomanip>
#include <vector>

void task(int i) {
    std::cout << "Task"<<i<< "started" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout << "Task"<<i<< "finished" << std::endl;


    auto end_time = std::chrono::system_clock::now();
    std::time_t end_time_t = std::chrono::system_clock::to_time_t(end_time);
    std::cout << "Task"<<i<< "finished time: " << std::put_time(std::localtime(&end_time_t), "%F %T") << std::endl;
}

int main() {
    // 记时
    auto start_time = std::chrono::system_clock::now();
    std::time_t start_time_t = std::chrono::system_clock::to_time_t(start_time);
    std::cout << "main Start time: " << std::put_time(std::localtime(&start_time_t), "%F %T") << std::endl;
    
   // std::vector<std::future<void>> mfus;
    for (size_t i = 0; i < 10; i++)
    {
         //mfus.push_back( std::async(std::launch::async, task,i));
         std::async(std::launch::async, task,i);
    }
    

    auto end_time = std::chrono::system_clock::now();
    std::time_t end_time_t = std::chrono::system_clock::to_time_t(end_time);
    std::cout << " main End time: " << std::put_time(std::localtime(&end_time_t), "%F %T") << std::endl;

    return 0;
}

这10个task 会按照顺序同步执行

为什么呢？

调用了 std::async 但是没有保存返回的 std::future 对象。当一个 std::future 对象在其生命周期结束时（例如，当它离开作用域或被显式销毁时），如果它关联的任务还没有完成，那么这个 std::future 对象的析构函数会等待任务完成。

std::future 它们会在循环体的末尾被销毁，从而导致每个任务实际上是依次等待完成的。

修改就是把上面的注释打开，使用vector不让future对象去销毁

这样就可以异步了，最好的话也可以加上下面的，虽然是void

   // Wait for all tasks to complete
    for (auto& fut : futures) {
        fut.get();  // This will block until the task is done
    }

原文地址：https://blog.csdn.net/beginnerdzz/article/details/143801816

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Flume1.9.0自定义Sink组件将数据发送至Mysql
下一篇：Android Osmdroid + 天地图（二）

关于selenium元素找不到的问题（Unable to locate element: {“method“:“xpath“,“selector“:“）
过了两周，查看日志发现，裂开了，又不好使了，然后，我重新运行了一遍，想找找问题，结果他又好使了。我真的裂开，裂开了啊，再然后下载页面，发现他会出现两种页面，并且页面源代码完全不同？之前一个任务让用se
阅读更多2024-11-17
iOS 键盘弹出视图精准上移
注意，我们可以自行设置一个适当的buffer,我这里是40，就是输入框距离。1 视图精准位移，需要计算出输入框距离屏幕底部的距离，然后。计算出输入框需要上移的距离，就是整个视图需要上移的距离,键盘有一
阅读更多2024-11-17
Intern大模型训练营（八）：Llamaindex RAG 实践
首先在Intern Studio中申请30% A100的开发机。进入开发机后，创建新的conda环境，命名为llamaindex复制完成后，在本地查看环境。运行conda命令，激活llamaindex
阅读更多2024-11-17
Spring事务管理
Spring事务管理是Spring框架中的一个重要功能，用于管理数据库事务。它提供了一种声明式的方式来管理事务，简化了开发人员的工作。
阅读更多2024-11-17
介绍一下整数在内存的储存形式(c基础)
把整数以二进制形式写出在前面补零(保证32位)把整数以二进制形式写出在前面补零（第一位为符号位负数为1，正数为0。第一位（左）为符号位补1。（即1变为0，0变为1)
阅读更多2024-11-17
Linux驱动开发第2步_“物理内存”和“虚拟内存”的映射
“新字符设备的GPIO驱动”和“设备树下的GPIO驱动”都要用到寄存器地址，使用“物理内存”和“虚拟内存”映射时，非常不方便，而pinctrl和gpio子系统的GPIO驱动，非常简化。因此，要重点学习
阅读更多2024-11-17
LLMs 激活函数篇
LLMs 激活函数
阅读更多2024-11-17
学习python的第十天之数据类型——dict字典
Python 中的字典（Dictionary）是一个非常强大的内置数据类型，它用来存储键值对（key-value pairs）信息。字典是无序的，这意味着它们不会记录你添加键值对的顺序；然而，从 Py
阅读更多2024-11-17
基于Java Springboot校园共享单车
为了节省时间和提高工作效率，越来越多的人选择利用互联网进行线上打理各种事务，然后线上管理系统也就相继涌现。基于这种情况，我们需要这样一个界面简单大方、功能齐全的系统来解决用户问题，满足用户需求。课题主
阅读更多2024-11-17
HashMap面试知识点
HashMap链表的插入的方式是是头插法，在多线程的情况下，容易产生环形链表，查询时就会产生死循环问题。HashMap的插入法改为了尾插法，但是多线程情况下依然会产生一些问题，例如前面说到的put()
阅读更多2024-11-17

c++多线程

c++多线程

lambda的简单说明

demo1 函数指针

demo2 仿函数 (函数对象)

demo3 lambda表达式

std::mutex

std::atomic

thread_local

async

创建

执行结果

注意事项

相关文章