首页
学习
活动
专区
工具
TVP
发布
精选内容/技术社群/优惠产品,尽在小程序
立即前往

为什么MinGW中仍然没有std::thread、std::promise和std::future?win32中的promise和futures的替代方案是什么?

MinGW(Minimalist GNU for Windows)是一个为Windows平台提供的GNU工具链,它允许开发者使用GCC编译器和其他GNU工具来编写和编译Windows应用程序。然而,MinGW在早期版本中并没有完全支持C++11标准库中的所有特性,包括std::threadstd::promisestd::future,这是因为这些特性依赖于操作系统提供的原生线程支持,而MinGW的某些版本可能没有完全实现或更新这些功能。

基础概念

  • std::thread:C++11标准库中的一个类,用于创建和管理线程。
  • std::promisestd::future:这两个类用于线程间的同步和数据传递。std::promise允许一个线程设置一个值或异常,而std::future则允许另一个线程获取这个值或异常。

为什么MinGW中缺少这些特性

MinGW最初是基于较旧的GCC版本,而这些版本可能没有完全实现C++11标准库的所有部分。随着时间的推移,MinGW已经更新并开始支持更多的C++11特性,包括线程库。但是,如果你使用的是较旧的MinGW版本,可能会遇到这些特性不可用的问题。

Win32中的替代方案

在Win32平台上,如果没有std::threadstd::promisestd::future,可以使用Windows API来实现类似的功能。

线程创建

使用CreateThread函数来创建线程:

代码语言:txt
复制
#include <windows.h>

DWORD WINAPI ThreadFunction(LPVOID lpParam) {
    // 线程执行的代码
    return 0;
}

int main() {
    HANDLE hThread = CreateThread(NULL, 0, ThreadFunction, NULL, 0, NULL);
    if (hThread == NULL) {
        // 处理错误
    }
    // 等待线程结束
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
    return 0;
}

线程同步和数据传递

使用EventMutexSemaphore等同步对象,以及CONDITION_VARIABLE来实现线程间的同步。对于数据传递,可以使用PIPE或者共享内存。

解决MinGW缺少这些特性的方法

  1. 更新MinGW:确保你使用的是最新版本的MinGW,因为它可能已经支持了这些特性。
  2. 使用第三方库:例如,可以使用Boost.Thread库,它提供了类似于std::threadstd::promisestd::future的功能,并且可以在MinGW中使用。
  3. 使用Windows API:如上所述,可以使用Win32 API来实现线程管理和同步。

示例:使用Boost.Thread

代码语言:txt
复制
#include <boost/thread.hpp>
#include <iostream>

void thread_function() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    boost::thread t(thread_function);
    t.join();
    return 0;
}

确保你已经安装了Boost库,并且在编译时链接了Boost.Thread库。

通过这些方法,即使在MinGW中缺少C++11线程支持的情况下,也可以实现多线程编程和线程间的同步。

页面内容是否对你有帮助?
有帮助
没帮助

相关·内容

C++ 异步编程脉络与示例

本文将系统地探讨 C++ 异步编程的发展历程,从早期的回调方法,到 std::future 和 std::promise,再到现代的协程(coroutines),全面解析各个阶段的特点和使用方法。...Futures 和 Promises 引入背景 C++11 引入了 std::future 和 std::promise,为异步编程提供了更结构化的工具。...缺点: 仍然存在一定的复杂性,特别是在处理多个异步任务时。 需要显式地管理 std::future 和 std::promise 对象。...} std::promise 和 std::future 是一对可以配合使用的工具。...每一种方式都有其优缺点,理解这些不同的异步编程范式,有助于在实际开发中选择最合适的解决方案。通过不断学习和实践,我们可以更好地应对复杂的异步编程挑战,为用户提供更高效、更可靠的程序。

22010

Chapter 7: The Concurrency API

Make std::threads unjoinable on all paths 一个thread对象如果在析构时仍然是joinable的,那么会使得程序终止运行 每个std::thread对象的状态要么是...对于joinable的线程,析构时析构函数通过detach断开了std::thread对象和底层执行线程的连接后,底层的线程仍然在运行,此时thread所在的函数占用的内存已经回收,如果后面仍有函数调用的话...Be aware of varying thread handle destructor behavior 一个non-deferred的std::future和一个joinable的std::thread...因为调用者的future和被调用者的promise在传递结果时,这个结果既没有存放在promise,也没有存放在future,而是存放在一个堆对象代表的shared state中,而标准没有指定个对象的行为...,此时线程间通信的最佳方式是什么呢?

91250
  • libcopp对C++20协程的接入和接口设计

    而 callable_future 和 task_future 的相似度比较高,都会管理协程的promise,那么我们为什么要把他们拆分成两个接口呢...显然我们并不希望每次有唤醒都去检查一次哪些任务完成了,哪些仍然要等待,这不但会有惊群效应,还会有很多冗余的重置 caller 和重新设置 caller 的行为。...接入过程中的易踩坑点 首先,在 《libcopp接入C++20 Coroutine和一些过渡期的设计》 里提到的 GCC 在MinGW环境下的链接符号问题 在当前的 GCC 12 中已经修复了, GCC...(特别是 task_future 和 generator_future 里 awaitable和promise对象之间交互时对 context 的传递,一定是在单线程内的。)...但是在 C++20 的无栈协程中,需要层层传递,层层创建。我预估整体开销应该是比之前使用有栈协程的方案高的。前面提到的编译器优化可以优化掉堆分配,但是协程本身的开销并没有省去。

    68420

    跟面试官刚同步异步编程,有她完全够用了

    lambda函数fun 输出线程id和一个传入的字符串 分别在新起的线程和当前线程中调用他 auto fun = [](std::string a, std::mutex & lock) {...//使用mutex的原因 两个线程都需要通过全局对象 std::cout来输出到屏幕 如果没有mutex 会打乱id和字符串的输出顺序 std::unique_lockstd::mutex>...有没有更高效的方式? 共享变量,函数参数和返回值三种,更高效的那就 future 和 promise 吧 7,既然你提到了 future 和 promise,你能说说他们是如何工作的吗?...有线程1和2,线程1希望从线程2中获取特定值,步骤如下: 线程1:创建promise对象,并从该对象中获得对应的future对象-> ->线程1将promise对象传递给线程...所以,我们可以使用std::async替代线程的创建,让它成为我们做异步操作的首选。

    56920

    C++并发编程 - 同步并发操作

    在C++标准库中, 有两种“期望”, 使用两种类型模板实现, 声明在头文件中: 唯一期望(uniquefutures)( std::future )和共享期望(shared futures)( std...即std::async、std::packaged_task和std::promise会返回std::future类型,线程通过std::future获取任务执行的结果。  ...std::promises 承诺与期望 std::promise对象可以保存某一类型 T 的值,该值可被 future 对象读取(可能在另外一个线程中),因此 promise 也提供了一种线程同步的手段...在 promise 对象构造时可以和一个共享状态(通常是std::future)相关联,并可以在相关联的共享状态(std::future)上保存一个类型为 T 的值。 ...针对std::async可能引发的问题,告诫程序员们,一定要规范的使用每一个接口,缺省的参数及返回值不处理的话可能让代码裂成“东非大裂谷”。把接口的参数和返回值,不管有没有必要,都要处理。

    1.1K40

    C++并发低级接口:std::thread和std::promise

    std::thread和std::promise 相比std::async,std::thread就原始多了。...虽然std::thread.detach()可以不阻塞主线程,但是如果主线程结束那这些后台任务都会强行终止,比如你后台是下载任务,所以几乎没有直接用detach的,都是配合后面的同步机制如std::condition_variable...这里也凸显了std::async的高级和std::thread的低级:在std::async中我们可以对它的返回值即std::future简单的调用get()实现同步等待甚至能获取任务的结果,但是std...多说一点,其实std::promise和std::future都是多线程状态共享的方案,这两种不存在高级低级,只有std::async和std::thread有点高级低级之分。...不过《C++标准库》中这样分类,加之std::future,std::promise分别用于std::async和std::thread的示例,我也只能照做了;)

    2.3K40

    【Example】C++ 标准库多线程同步及数据共享 (std::future 与 std::promise)

    在任何语言的多线程编程当中,必然涉及线程的同步及数据的共享,方式也有很多种。 C++ 标准库当中提供了同步及共享的方案:std::future 与 std::promise 。...【语法】【伪代码】std::future name(promise.get_future()); 【负责存储】std::promise 也是一个模板类,它提供了存储异步执行的值和异常的一种方式...4,std::promise 在作为使用者的异步线程当中,应当注意共享变量的生命周期、是否被 set 的问题。如果没有共享值没有被 set,而异步线程却结束,future 端会抛出异常。...std::shared_future 与 std::packaged_task std::future 有个非常明显的问题,就是只能和一个 std::promise 成对绑定使用,也就意味着仅限于两个线程之间使用...若 policy 中设置了 std::launch::async 和 std::launch::deferred 两个标志,则进行异步执行还是惰性求值取决于实现。

    1.6K30

    再也不用std::thread编写多线程了

    ::future和std::shared_future * *基于任务的:std::async 基于线程的:std::thread */ int sys = 1; int doAsyncWork()...以等待它的期望,该wait调用会阻塞反应任务到 * std::promise型别对象被设置为止 * * 2,发生端std::promise,接收端 std::future和std::shared_future...:promise和期望值之间是共享状态,而共享状态通常是动态分配的,因此,你就得假设这种设计会招致在堆上进行分配和回收的成本 * * 3,std::promise型别对象只能设置一次,它和期望值之间的通信通道是个一次性机制...* * 1,关键在 react的代码中使用std::shared_futures而非std::future,前者是把共享状态的所有权转移给了由share生成的 * std::shared_future...* * c++98中肯定会发生的,无论调用方传入的是什么,形参newName都会经过复制构造函数创建 * * 不过,在C++11中,newName仅在传入左值时候才会被复制构造,若传入右值,会被移动构造

    2.4K40

    读 NebulaGraph源码 | 查询语句 LOOKUP 的一生

    ); // 这里开始 DAG 的物理计划执行 // 调度是基于 folly 的 Promise 和 Future 异步调用展开的 return doSchedule(executor); }...也就是说,如果这个算子依赖了某些算子,只有它们的许诺兑现了(promise set value),这里的 future 才能得到处理 std::unordered_mapstd:...)); queue.push(root); visited.emplace(root); // 开始 DAG 访问图计算节点,生成每一个节点的 promise 和 future while...LOOKUP 语句的算子在执行什么? 上面我介绍了物理算子通过 folly 三方库的 Promise 和 Future 异步编程模型来实现调度执行。...有很多细节没有展开,后续的文章中我们将不断展开。其实,对于任意一个语句,基本执行的流程和 LOOKUP 的一生都类似,其中有不同的地方就是额外的算子不同,算子之间处理的逻辑不同。

    1.5K40

    C++11异步编程(std::async, std::future, std::packaged_task, std::promise)

    future中,然后通过future来获取想要得到的结果。... std::promise是一个类模板,它的作用是在不同的线程中实现数据的同步,与future结合使用,也间接实现了future在不同线程间的同步。...thread t(fun, 1, std::ref(p)); std::cout std::endl; // 当promise还没有值的时候在此等待...需要注意的是在使用的过程中不能多次set_value(),也不能多次get_future()和多次get(),因为一个promise对象只能和一个对象相关联,否则就会抛出异常。...std::async        其实这个函数是对上面的对象的一个整合,async先将可调用对象封装起来,然后将其运行结果返回到promise中,这个过程就是一个面向future的一个过程,最终通过future.get

    16.1K30

    【译文】Rust futures: async fn中的thread::sleep和阻塞调用

    你已经读了这篇文章的标题,可能会猜到get_book和get_music是按顺序执行的。但为什么!?异步fn中的所有内容不是都应该同时运行吗?...为什么async不行? 我不会在这里深入讨论futures和async/await(本书是一个很好的起点)。我只想指出造成困惑的两个可能的根源: std::thread::sleep 会阻塞?...但是文档中并没有明说“此调用是阻塞的,你不应该在异步上下文中使用它”,并且非系统程序员可能不会过多地考虑“将当前线程置于睡眠状态”。...你可以找到一个异步替代方案:当thread::sleep阻塞时,你可以使用它们(取决于你选择的运行时生态系统): async_std::task::sleep (1.0) tokio::time::delay_for...(0.2.0) tokio和async_std都为其他阻塞操作(例如文件系统和tcp流访问)提供了异步替代方法。

    3K20

    CC++开发基础——std::future与async异步编程

    std::promise也是一个类模板,可以基于std::promise实现线程之间的数据传输。 构造一个std::promise对象时,可以和std::future对象相互关联。...std::thread启动的线程如果抛出了异常,且异常没有被线程本身处理的时候,这个线程会导致整个应用程序发生终止。...std::future可以很方便地获取线程的执行结果,如果线程抛出了异常,std::future可以将异常转移到另一个线程中,让另一个线程来处理异常。...} } 运行结果: Caught exception: Exception throw from CalculateSum. 2.std::promise和std::future的区别 同一个线程或者另一个线程将线程函数的计算结果放入到...std::promise中,而std::future可以获取std::promise中存储的线程计算结果。

    1.1K10

    C++一分钟之-未来与承诺:std::future与std::promise

    在现代C++编程中,std::future和std::promise是异步编程模型中的两个重要组件,它们构成了C++标准库中处理异步计算结果的基础。...并发编程:在多线程环境中,std::promise和std::future可以用来在不同线程间传递数据,实现线程间的通信。...三、常见问题与易错点3.1 异常安全当向std::promise设置值时抛出异常,如果没有妥善处理,可能会导致结果永远不会被设置,而等待的std::future将永远阻塞。...3.2 多重获取std::future的结果只能获取一次。尝试再次调用get()会导致未定义行为。3.3 错误的线程同步在多线程环境下,没有正确同步对std::promise的访问可能导致数据竞争。...通过理解std::future和std::promise的工作原理及其最佳实践,开发者能够更高效、安全地编写异步和并发代码,充分利用现代硬件的多核优势,提升程序性能。

    99010

    来聊聊C++中头疼的线程、并发

    因为一旦主线程执行完,相应的资源就被释放了。 //但是对象本身ta还在吗?不在了。那为什么thread还能正常运行?因为创建thread时创建的副本在子线程中运行。...线程A锁了金锁,需要去锁住银锁;然而线程B锁了银锁,需要去锁住金锁,这样A和B都在等待对方释放锁。就成了死锁。 死锁的一般解决方案:只要保证两个互斥量上锁的顺序一致就不会死锁。...如果wait()或者get()没有调用则不会执行线程. eg: std::async(std::launch::deferred,my_thread)可以测试线程id,延迟调用,其实没有创建新线程,是在主线程中调用的线程入口函数...std::future fu=myprom.get_future();//promise和future绑定,用于获取线程返回值 auto result=fu.get(); }...然而CAS的过程其实没有获取和释放锁。它的运行和JMM内存模型没有关系。

    5.1K41

    UNIX(多线程):12---async、future、packaged_task、promise

    "future": 将来的意思,有人也称呼std::future提供了一种访问异步操作结果的机制,就是说这个结果你可能没有办法马上拿到,但不久的将来, 什么叫“启动一个异步任务”,就是自动创建一个线程并开始执行对应的线程入口函数...std::launch::deferred: 延迟调用,并且没有创建新线程,是在主线程中调用的线程入口函数。 ? ?...std::promise 我们能够再某个线程中给它赋值,然后我们可以再其他线程中,把这个值取出来用。...::get_id() << endl; //打印主线程id std::promise var_pro; //创建一个promise对象,用来保存int类型的值 std::thread objThread.../获取结果 objThread.join(); std::future t1 = var_pro.get_future(); //promise和线程绑定,用于获取线程返回值 std::thread

    45020

    《C++并发编程实战》读书笔记(2):并发操作的同步

    future>中提供了两种类模板future和shared_future,同一事件仅可关联一个future实例,但可关联多个shared_future,并且目标事件发生后关联的所有shared_future...promise通过get_future获取关联的future对象,等待数据的线程在future上阻塞,提供数据的线程通过set_value设置数据,设置完后future即就绪。...(true); } } } } async与packaged_task运行的函数抛出异常时会保存在future对象中,调用get时再次抛出。...std::chrono库中时钟是时间信息的来源,每个时钟类都提供当前时刻now、时间值的类型time_point、计时单元的长度ratio、计时速率是否恒定is_steady。...C++20中还提出两个新特性:latch和barrier。latch是一个同步对象,内含计数器,减到0时就绪。

    38920
    领券