blocks|key|1351466|text|我会把重点放在尽可能多的分区设计上，这样你就可以在线程之间共享最少的东西。如果您确保没有在线程之间共享静态和其他资源(如果您使用进程而不是线程来设计这些资源，那么您将共享的资源除外)，那么就没有问题了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1351467|因此，虽然你必须在脑海中有锁、信号量等概念，但解决这个问题的最好方法是尽量避免它们。|1351468|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|$]]

I would focus on design the thing as much as partitioned as possible so you have the minimal amount of shared things across threads. If you make sure you don't have statics and other resources shared among threads (other than those that you would be sharing if you designed this with processes instead of threads) you would be fine.

Therefore, while yes, you have to have in mind concepts like locks, semaphores, etc, the best way to tackle this is to try to avoid them.

blocks|key|1136016|text|您应该阅读有关锁、互斥、信号量和条件变量的内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1136017|一句话建议，如果你的应用程序有任何形式的UI，请确保你总是在UI线程中更改它。如果你从后台线程访问，大多数UI工具包/框架都会崩溃(或者行为出乎意料)。通常，它们提供某种形式的调度方法来执行UI线程中的某些函数。|1136018|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|$]]

You should read about locks, mutexes, semaphores and condition variables. 

One word of advice, if your app has any form of UI make sure you always change it from the UI thread. Most UI toolkits/frameworks will crash (or behave unexpectedly) if you access them from a background thread. Usually they provide some form of dispatching method to execute some function in the UI thread.

blocks|key|1351491|text|我发现有一件事非常有用，那就是使应用程序可以根据它用于各种任务的实际线程数进行配置。例如，如果有多个线程访问一个数据库，则可以通过命令行参数配置这些线程的数量。这在调试时非常方便-您可以通过将数字设置为1来排除线程问题，或者通过将其设置为较高的数字来强制它们。在计算出最佳线程数时，它也非常方便。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1351492|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|$]]

One thing I've found very useful is to make the application configurable with regard to the actual number of threads it uses for various tasks. For example, if you have multiple threads accessing a database, make the number of those threads be configurable via a command line parameter. This is extremely handy when debugging - you can exclude threading issues by setting the number to 1, or force them by setting it to a high number. It's also very handy when working out what the optimal number of threads is.

blocks|key|1351683|text|既然你是初学者，那就从简单开始吧。首先让它正常工作，然后再考虑优化。我见过人们试图通过增加特定代码段的并发性(通常使用可疑的技巧)来进行优化，而不是首先查看是否存在任何争用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1351684|其次，你希望能够在尽可能高的水平上工作。如果可以使用现有的主-从队列，请不要在锁和互斥级别上工作。英特尔的TBB看起来很有前途，它的级别比纯线程略高。|offset|length|1351685|第三，多线程编程很困难。尽可能减少你的代码中需要考虑的部分。如果您可以编写一个类，使该类的对象仅在单个线程中操作，并且没有静态数据，则可以极大地减少您在类中必须担心的事情。|1351686|entityMap|0|LINK|mutability|MUTABLE|url|http://www.threadingbuildingblocks.org/^0|0|1H|3|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Since you are a beginner, start simple. First make it work correctly, then worry about optimizations. I've seen people try to optimize by increasing the concurrency of a particular section of code (often using dubious tricks), without ever looking to see if there was any contention in the first place.

Second, you want to be able to work at as high a level as you can. Don't work at the level of locks and mutexs if you can using an existing master-worker queue. Intel's <a href="http://www.threadingbuildingblocks.org/" rel="nofollow noreferrer">TBB</a> looks promising, being slightly higher level than pure threads.

Third, multi-threaded programming is hard. Reduce the areas of your code where you have to think about it as much as possible. If you can write a class such that objects of that class are only ever operated on in a single thread, and there is no static data, it greatly reduces the things that you have to worry about in the class.

blocks|key|1351536|text|确保明确知道哪些对象是共享的，以及它们是如何共享的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1351537|尽可能让你的函数变得纯粹的功能性。也就是说，它们有输入和输出，没有副作用。这使得对您的代码进行推理变得更加简单。对于一个更简单的程序，这不是什么大问题，但随着复杂性的增加，它将变得至关重要。副作用是导致线程安全问题的原因。|1351538|在你的代码中扮演魔鬼的拥护者。看看一些代码，想一想我如何用一些适时的线程交错来打破这一点。在某种程度上，这种情况将会发生。|1351539|首先学习线程安全。一旦你弄清楚了这一点，你就会进入到困难的部分:并发性能。这就是远离全局锁至关重要的地方。找出最小化和删除锁的方法，同时仍然保持线程安全是很困难的。|1351540|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Make sure to explicitly know what objects are shared and how they are shared.

As much as possible make your functions purely functional. That is they have inputs and outputs and no side effects. This makes it much simpler to reason about your code. With a simpler program it isn't such a big deal but as the complexity rises it will become essential. Side effects are what lead to thread-safety issues.

Plays devil's advocate with your code. Look at some code and think how could I break this with some well timed thread interleaving. At some point this case will happen.

First learn thread-safety. Once you get that nailed down then you move onto the hard part: Concurrent performance. This is where moving away from global locks is essential. Figuring out ways to minimize and remove locks while still maintaining the thread-safety is hard.

blocks|key|1136229|text|远离MFC，它是多线程%2B消息库。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1136230|事实上，如果你看到MFC和线程朝你走来--快跑吧(*)|1136231|(*)当然，除非MFC来自山丘-在这种情况下，逃离山丘。|1136232|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Stay away from MFC and it's multithreading + messaging library. 
In fact if you see MFC and threads coming toward you - run for the hills (*)

(*) Unless of course if MFC is coming FROM the hills - in which case run AWAY from the hills.

blocks|key|1351828|text|尽可能让事情变得简单。更简单的设计(维护，更少的bug)要比CPU利用率稍高的更复杂的解决方案要好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1351829|尽量避免在线程之间共享状态，这减少了必须使用同步的位置的数量。|1351830|不惜一切代价避免虚假分享(google这个术语)。|1351831|使用线程池，这样您就不会频繁地创建/销毁线程(这是昂贵和缓慢的)。|1351832|考虑使用OpenMP、英特尔和微软(可能是其他公司)来支持C%2B%2B的这个扩展。|1351833|如果您正在进行数字运算，请考虑使用Intel+IPP，它在内部使用优化的SIMD函数(这并不是真正的多线程，而是相关排序的并行性)。|1351834|祝你玩得开心。|1351835|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Keep things dead simple as much as possible. It's better to have a simpler design (maintenance, less bugs) than a more complex solution that might have slightly better CPU utilization.

Avoid sharing state between threads as much as possible, this reduces the number of places that must use synchronization.

Avoid false-sharing at all costs (google this term).

Use a thread pool so you're not frequently creating/destroying threads (that's expensive and slow).

Consider using OpenMP, Intel and Microsoft (possibly others) support this extension to C++.

If you are doing number crunching, consider using Intel IPP, which internally uses optimized SIMD functions (this isn't really multi-threading, but is parallelism of a related sorts).

Have tons of fun.

blocks|key|1351697|text|我发现在伯克利观看John+Kubiatowicz关于操作系统和系统编程here的介绍性讲座很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1351698|entityMap|0|LINK|mutability|MUTABLE|url|http://academicearth.org/courses/operating-systems-and-system-programming^0|10|4|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 found viewing the introductory lectures on OS and systems programming <a href="http://academicearth.org/courses/operating-systems-and-system-programming" rel="nofollow noreferrer">here</a> by John Kubiatowicz at Berkeley useful.

blocks|key|1136298|text|在给出关于在C%2B%2B中做什么和不做什么的建议之前，我想问一个问题，你有什么特别的理由想要开始用C%2B%2B编写应用程序吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1136299|还有其他编程范例，在这些编程范例中，您可以利用多核，而无需进入多线程编程。一种这样的范例是函数式编程。把你的每一段代码都写成函数，没有任何副作用。这样就很容易在多线程中运行它，而不用担心同步问题。|1136300|我将Erlang用于我的开发目的。它的生产率提高了至少50%25。运行的代码可能没有用C%2B%2B编写的代码快。但我注意到，对于大多数后端离线数据处理，速度并不重要，重要的是工作的分配和尽可能多地利用硬件。Erlang提供了一个简单的并发模型，在该模型中，您可以在多线程中执行单个函数，而无需担心同步问题。编写多线程代码很容易，但调试却很耗时。我曾经在C%2B%2B中做过多线程编程，但目前我对Erlang并发模型很满意。这是值得研究的。|1136301|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Before giving any advice on do's and dont's about multi-thread programming in C++, I would like to ask the question Is there any particular reason you want to start writing the application in C++?

There are other programming paradigms where you utilize the multi-cores without getting into multi-threaded programming. One such paradigm is functional programming. Write each piece of your code as functions without any side effects. Then it is easy to run it in multiple thread without worrying about synchronization. 

I am using Erlang for my development purpose. It has increased by productivity by at least 50%. Code running may not be as fast as the code written in C++. But I have noticed that for most of the back-end offline data processing, speed is not as important as distribution of work and utilizing the hardware as much as possible. Erlang provides a simple concurrency model where you can execute a single function in multiple-threads without worrying about the synchronization issue. Writing multi-threaded code is easy, but debugging that is time consuming. I have done multi-threaded programming in C++, but I am currently happy with Erlang concurrency model. It is worth looking into.

blocks|key|1351872|text|我和你处于同一条船上，我刚刚开始作为项目的一部分第一次开始多线程，我一直在网上寻找资源。我发现this博客内容非常丰富。第1部分是pthread，但我从boost部分开始进行链接。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1351873|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.emptycrate.com/node/277^0|1B|4|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 in the same boat as you, I am just starting multi threading for the first time as part of a project and I've been looking around the net for resources. I found <a href="http://blog.emptycrate.com/node/277" rel="nofollow noreferrer">this</a> blog to be very informative. Part 1 is pthreads, but I linked starting on the boost section.

blocks|key|1351754|text|确保你知道volatile是什么意思和它的用法(一开始可能不是很明显)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1351755|此外，在设计多线程代码时，可以想象无限数量的处理器同时执行应用程序中的每一行代码。(呃，根据您代码中的逻辑，可能的每一行代码。)并且所有没有被标记为易失性的东西，编译器都会对它进行特殊的优化，这样只有改变它的线程才能读取/设置它的真值，而所有其他的线程都会得到垃圾。|1351756|entityMap^0|5|8|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

Make sure you know what <code>volatile</code> means and it's uses(which may not be obvious at first). 

Also, when designing multithreaded code, it helps to imagine that an infinite amount of processors is executing every single line of code in your application at once. (er, every single line of code that is possible according to your logic in your code.) And that everything that isn't marked volatile the compiler does a special optimization on it so that only the thread that changed it can read/set it's true value and all the other threads get garbage.

I'm currently working on a wireless networking application in C++ and it's coming to a point where I'm going to want to multi-thread pieces of software under one process, rather than have them all in separate processes. Theoretically, I understand multi-threading, but I've yet to dive in practically. 

What should every programmer know when writing multi-threaded code in C++?

What are the "things to know" when diving into multi-threaded programming in C++

我目前正在用C++开发一个无线网络应用程序，我希望在一个进程下对软件进行多线程处理，而不是将它们都放在单独的进程中。从理论上讲，我理解多线程，但我还没有深入到实践中。在用C++编写多线程代码时，每个程序员都应该知道什么？

问在深入研究C++中的多线程编程时，有哪些“需要知道的事情”
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在深入研究C++中的多线程编程时，有哪些“需要知道的事情”EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在深入研究C++中的多线程编程时，有哪些“需要知道的事情”
EN