blocks|key|1664720|text|不幸的是，没有简单的方法。几个选项:+linux上的pthread，windows上的win32+api线程或boost：：线程库|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1664721|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

unfortunately there is no easy way. Couple of options: pthread on linux, win32 api threads on windows or boost::thread library

blocks|key|365183|text|在语言中，没有一种简单的方法来创建多线程应用程序。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|365184|entityMap^0|1|O|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

There is no easy way to create a multithreaded application in any language.

blocks|key|1666884|text|只是提到它，因为它还没有被提及:一个支持OpenMP的编译器(http://openmp.org/wp/)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1666885|entityMap|0|LINK|mutability|MUTABLE|url|http://openmp.org/wp/^0|V|L|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Just to mention it because it hasn't been mentioned: a compiler with OpenMP support (<a href="http://openmp.org/wp/" rel="nofollow noreferrer">http://openmp.org/wp/</a>)

blocks|key|1664741|text|Qt有一个漂亮的threading+support+and+documentation，但正如其他人警告的那样，它不适合初学者。我给自己提供的文档链接指向一个short+reading+list|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1664742|entityMap|0|LINK|mutability|MUTABLE|url|http://doc.trolltech.com/4.5/threads.html|1|http://doc.trolltech.com/4.5/threads.html#reading^0|8|Z|0|27|I|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

Qt has a pretty 
<a href="http://doc.trolltech.com/4.5/threads.html" rel="nofollow noreferrer">threading support and documentation</a>
but as others have cautioned this is not for beginners. The doc link I gave itself points to a <a href="http://doc.trolltech.com/4.5/threads.html#reading" rel="nofollow noreferrer">short reading list</a>

blocks|key|1604508|text|pthreads！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1604509|https://computing.llnl.gov/tutorials/pthreads/|offset|length|1604510|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1A|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

pthreads!

<a href="https://computing.llnl.gov/tutorials/pthreads/" rel="nofollow noreferrer">https://computing.llnl.gov/tutorials/pthreads/</a>

blocks|key|1604705|text|这个问题没有简单的答案。这在很大程度上取决于你希望从多线程中获得什么，平台/编译器，以及你想要使用的线程模型。每一个线程API都有它的陷阱。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1604706|因为到目前为止还没有人提到它，所以OpenMP是许多现代主流编译器中支持的另一个选项，旨在简化并发性的使用。http://openmp.org/wp/|offset|length|1604707|entityMap|0|LINK|mutability|MUTABLE|url|http://openmp.org/wp/^0|0|1I|L|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

There is no simple answer to this. It depends very heavily on what you hope to gain from multithreading, the platform/compiler, and which threading model you want to use. Every threading API has its pitfalls.

And just because no one has mentioned it so far, OpenMP is another option that is supported in many modern mainstream compilers and is intended to simplify the use of concurrency.
<a href="http://openmp.org/wp/" rel="nofollow noreferrer">http://openmp.org/wp/</a>

blocks|key|198501|text|我在C%2B%2B中工作已经有一段时间了，我还没有看到Boost线程支持，但我发现将操作系统提供的semaphore服务(通常是POSIX或Win32+)封装在简单的类中是非常有帮助的，这些类将获得锁，并在析构函数中释放它们，从而使它们的使用变得相当简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|198502|void+operateOnSharedResource(SharableResource+&+foo)+{
++++MutexLock+lock(foo.getMutex());
++++//+do+stuff+to+foo
++++//+implicit+call+to+MutexLock+dtor+performs+release+
}|code-block|syntax|javascript|198503|归根结底，有很多这样的简单技巧可以简化线程编程，如果Boost现在还没有这样的东西，我会很惊讶(编辑:它有，它在Lock+Types中有文档)。|198504|无论如何，编写多线程代码的主要问题不会被任何第三方库解决，这就是理解你的代码在哪里可以被有效地并行化，在哪里共享的资源将被接触并且必须被考虑。下面是我在编写多线程代码时使用的一些经验法则。|198505|198506|尝试最小化共享资源的数量|unordered-list-item|198507|尝试将共享资源封装在使所有操作成为原子的类包装中。|198508|使辅助线程尽可能简单|198509|198510|正确的封装对于编写更安全的多线程代码确实很神奇，因为您可以看到的东西越少，具有竞争条件的东西就越少。|198511|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Boost_C%252B%252B_Libraries|1|http://en.wikipedia.org/wiki/Semaphore_(programming)|2|http://en.wikipedia.org/wiki/POSIX|3|http://www.boost.org/doc/libs/1_40_0/doc/html/thread/synchronization.html#thread.synchronization.locks^0|N|5|0|19|9|1|1O|5|2|0|0|1K|A|3|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]|$A|1F|B|1G|1|1H]|$A|1I|B|1J|1|1K]]|C|$]]|$1|D|3|E|5|F|7|1L|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|K|3|L|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]|$1|N|3|O|5|P|7|1S|8|@]|9|@]|C|$]]|$1|Q|3|R|5|P|7|1T|8|@]|9|@]|C|$]]|$1|S|3|T|5|P|7|1U|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1V|8|@]|9|@]|C|$]]|$1|V|3|W|5|6|7|1W|8|@]|9|@]|C|$]]|$1|X|3|-4|5|6|7|1X|8|@]|9|@]|C|$]]]|Y|$Z|$5|10|11|12|C|$13|14]]|15|$5|10|11|12|C|$13|16]]|17|$5|10|11|12|C|$13|18]]|19|$5|10|11|12|C|$13|1A]]]]

It's been a while since I worked in C++ and I haven't seen the <a href="http://en.wikipedia.org/wiki/Boost_C%2B%2B_Libraries" rel="nofollow noreferrer">Boost</a> threading support, but I found it very helpful to encapsulate <a href="http://en.wikipedia.org/wiki/Semaphore_(programming)" rel="nofollow noreferrer">semaphore</a> services provided by the OS, usually either <a href="http://en.wikipedia.org/wiki/POSIX" rel="nofollow noreferrer">POSIX</a> or Win32, in simple classes that would acquire locks, and release them in the destructors, making their use fairly simple.

<pre><code>void operateOnSharedResource(SharableResource &amp; foo) {
 MutexLock lock(foo.getMutex());
 // do stuff to foo
 // implicit call to MutexLock dtor performs release 
}
</code></pre>

Ultimately there are lots of simple tricks like this to ease thread programming and I'd be surprised if Boost didn't have something like this by now (EDIT: It does and it's documented in <a href="http://www.boost.org/doc/libs/1_40_0/doc/html/thread/synchronization.html#thread.synchronization.locks" rel="nofollow noreferrer">Lock Types</a>). 

Regardless, the main problem with writing multi-threaded code isn't going to be solved by any third party library, and that's understanding where your code can be parallelized usefully, and where shared resources are going to be touched and must be accounted for. Here's a few rules of thumb I use when writing multi-threaded code.

<ul>
<li>Try to minimize the number of shared resources</li>
<li>Try to encapsulate shared resources in class wrappers that make all operations atomic.</li>
<li>Make worker threads as simple as possible</li>
</ul>

Proper encapsulation really does wonders for writing safer multi-threaded code, because the fewer things you can see, the fewer things can have a race condition.

blocks|key|198470|text|C%2B%2B0x规范包括线程工具(我最喜欢的新特性之一)。很快你编译的操作系统就不再重要了！只要看看创建一个新线程并加入到创建者线程中是多么容易：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|198471|#include+<thread>
#include+<iostream>

class+SayHello
{
public:
++++void+operator()()+const
++++{
++++++++std::cout<<"hello"<<std::endl;
++++}
};

int+main()
{
++++std::thread+t((SayHello()));
++++t.join();
}|code-block|syntax|javascript|198472|Visual+Studio2010正在实现C%2B%2B0x的一部分，但我们还在等待线程工具。|198473|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/C%252B%252B0x#Threading_facilities^0|0|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

The <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Threading_facilities" rel="nofollow noreferrer">C++0x</a> specification includes threading facilities (one of my favorite new features). Soon it won't matter what OS you're compiling for! Just look how easy it is to create a new thread and join back to the creator thread:

<pre><code>#include &lt;thread&gt;
#include &lt;iostream&gt;

class SayHello
{
public:
 void operator()() const
 {
 std::cout&lt;&lt;"hello"&lt;&lt;std::endl;
 }
};

int main()
{
 std::thread t((SayHello()));
 t.join();
}
</code></pre>

Visual Studio 2010 is implementing parts of C++0x but we're still waiting on the threading facilities.

blocks|key|198582|text|我不确定最简单的是什么，但我相信Poco+C%2B%2B项目中包含的线程库是对用户最友好的。要进行预览，请查看Thread.h头文件。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|198583|entityMap|0|LINK|mutability|MUTABLE|url|http://www.google.com/codesearch/p?hl=nl&sa=N&cd=1&ct=rc#UuBQaZ0XbaM/trunk/ofx.mod/core.mod/libs/poco/include/Poco/Thread.h^0|1F|8|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I'm not sure about the easiest, but IMO the most user-friendly threading library is the one included in the Poco C++ project. For a preview have a look at the <a href="http://www.google.com/codesearch/p?hl=nl&amp;sa=N&amp;cd=1&amp;ct=rc#UuBQaZ0XbaM/trunk/ofx.mod/core.mod/libs/poco/include/Poco/Thread.h" rel="nofollow noreferrer">Thread.h</a> header file.

blocks|key|365504|text|Boost.Thread相对容易，因为它是可移植的，有良好的文档记录，并且具有诸如scoped_try_lock之类的高级应用程序接口。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|365505|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_40_0/doc/html/thread.html|1|http://www.boost.org/doc/libs/1_40_0/doc/html/thread/synchronization.html#thread.synchronization.locks.scoped_try_lock^0|0|C|0|15|F|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

<a href="http://www.boost.org/doc/libs/1_40_0/doc/html/thread.html" rel="nofollow noreferrer">Boost.Thread</a> is relatively easier because it's portable, well-documented and has high-level API such as <a href="http://www.boost.org/doc/libs/1_40_0/doc/html/thread/synchronization.html#thread.synchronization.locks.scoped_try_lock" rel="nofollow noreferrer">scoped_try_lock</a>.

blocks|key|1664879|text|除了已经提到的那些，ACE是另一个流行的和广泛部署的C%2B%2B框架，它提供了跨多个平台的线程封装。例如，它的C%2B%2B风格没有Boost.Thread那么现代，但它已经相当成熟了。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1664880|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cs.wustl.edu/~schmidt/ACE.html|1|http://www.boost.org/doc/libs/1_40_0/doc/html/thread.html^0|A|3|0|1N|C|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

Besides the ones already mentioned, <a href="http://www.cs.wustl.edu/~schmidt/ACE.html" rel="nofollow noreferrer">ACE</a> is another popular and widely deployed C++ framework that provides thread encapsulations across multiple platforms. It's style of C++ isn't as modern as <a href="http://www.boost.org/doc/libs/1_40_0/doc/html/thread.html" rel="nofollow noreferrer">Boost.Thread</a>, for example, but it is quite mature.

blocks|key|365204|text|我会说和Qt一起。Qt线程和Qt并发性可能值得谷歌一下。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|365205|entityMap|0|LINK|mutability|MUTABLE|url|http://qt.nokia.com/doc/4.5/threads.html^0|4|2|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I would say with <a href="http://qt.nokia.com/doc/4.5/threads.html" rel="nofollow noreferrer">Qt</a>. Qt Threads and Qt Concurrency are probably worth googling.

blocks|key|1666911|text|Posix+Thread非常好，它们还附带了很棒的文档和教程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1666912|虽然不像java线程那么简单，但仍然相当不错。|1666913|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Posix Thread is quite good, they also come with great documentation and tutorials.

Not as easy as java threads, but still quite good.

blocks|key|198653|text|这完全取决于你在做什么。如果你能把你正在做的事情放到OpenMP中去，那么这就是你要走的路。否则，您可能想看看Intel's+TBB。TBB提供了几个您应该能够适应的工作流，但是该库是双重许可的，您可能无法接受其中任何一个许可。如果OpenMP和TBB都失效了，那么你应该考虑你的操作系统的线程池能力。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|198654|在某些情况下，您可能需要咬紧牙关使用Boost.Thread。如果是这样的话，你会想看看what+makes+multithreading+in+C%2B%2B+hard+(即使你没有使用C%2B%2B0x也很好读：“不是线程本身，而是通信导致了问题。可变的共享状态引入了隐式通信，”第3页)。|198655|entityMap|0|LINK|mutability|MUTABLE|url|http://www.threadingbuildingblocks.org/|1|http://www.justsoftwaresolutions.co.uk/files/designing_mt_programs.pdf^0|1J|B|0|0|18|11|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

This depends entirely on what you're doing. If you can fit what you're doing into OpenMP then that is the way to go. Otherwise you may want to look at <a href="http://www.threadingbuildingblocks.org/" rel="nofollow noreferrer">Intel's TBB</a>. TBB offers several workflows which you should be able to fit into, but the library is dual licensed and you may not be able to accept either license. If both OpenMP and TBB are out, then you should consider your operating system's thread pools abilities.

At some point you may need to bite the bullet and use Boost.Thread. If so, you'll want to look at <a href="http://www.justsoftwaresolutions.co.uk/files/designing_mt_programs.pdf" rel="nofollow noreferrer">what makes multithreading in C++ hard</a> (good to read even if you're not using C++0x: "It's not the threads themselves, it's the communication that causes problems. Mutable shared state introduces implicit communication," page 3).

blocks|key|1604896|text|最简单的方法是避免/最小化可变的共享状态。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1604897|一旦你有了可变的共享状态，你就需要处理锁，这是编写多线程程序的大部分困难所在。|1604898|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The easiest way is by avoiding/minimizing mutable shared state.

Once you have mutable shared state, you need to deal with locking which is where the bulk of the difficulty in writing multi-threaded programs exists.

What is the easiest way to create multithreaded applications with C/C++?

What is easiest way to create multithreaded applications with C/C++?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

用C/C++创建多线程应用程序最简单的方法是什么？

问用C/C++创建多线程应用程序最简单的方法是什么？
EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用C/C++创建多线程应用程序最简单的方法是什么？EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用C/C++创建多线程应用程序最简单的方法是什么？
EN