在大多数情况下，我更喜欢进程而不是线程。 当您有一个相对较小的任务(每个划分的任务单元占用的进程开销>>时间)，并且需要在它们之间共享内存时，线程可能会很有用。想象一个大数组。 另外(离题)，请注意，如果您的CPU利用率是100%或接近100%，那么多线程或处理将没有任何好处。(事实上情况会更糟)

Linux(实际上还有Unix)为您提供了第三种选择。

选项1 -流程

创建一个独立的可执行文件来处理应用程序的某些部分(或所有部分)，并为每个进程分别调用它，例如，程序运行自己的副本来委托任务。

选项2 -线程

创建一个独立的可执行文件，它由一个线程启动，并创建额外的线程来执行一些任务

选项3 -分叉

仅在Linux/Unix下可用，这有点不同。fork进程实际上是拥有自己地址空间的进程——子进程(通常)无法影响其父进程或兄弟进程的地址空间(不像线程)——因此您获得了额外的健壮性。

但是，内存页不是复制的，它们是写时复制的，因此通常使用的内存比您想象的要少。

考虑一个web服务器程序，它包含两个步骤:

读取配置和运行时数据 服务页面请求

如果您使用线程，第1步将完成一次，第2步将在多个线程中完成。如果您使用“传统”流程，那么每个流程都需要重复步骤1和步骤2，存储配置和运行时数据的内存也需要重复。如果您使用fork()，那么您可以执行第1步，然后fork()，将运行时数据和配置保留在内存中，不受影响，不复制。

所以实际上有三种选择。

多线程是为受虐狂准备的。：）

If you are concerned about an environment where you are constantly creating threads/forks, perhaps like a web server handling requests, you can pre-fork processes, hundreds if necessary. Since they are Copy on Write and use the same memory until a write occurs, it's very fast. They can all block, listening on the same socket and the first one to accept an incoming TCP connection gets to run with it. With g++ you can also assign functions and variables to be closely placed in memory (hot segments) to ensure when you do write to memory, and cause an entire page to be copied at least subsequent write activity will occur on the same page. You really have to use a profiler to verify that kind of stuff but if you are concerned about performance, you should be doing that anyway.

Development time of threaded apps is 3x to 10x times longer due to the subtle interaction on shared objects, threading "gotchas" you didn't think of, and very hard to debug because you cannot reproduce thread interaction problems at will. You may have to do all sort of performance killing checks like having invariants in all your classes that are checked before and after every function and you halt the process and load the debugger if something isn't right. Most often it's embarrassing crashes that occur during production and you have to pore through a core dump trying to figure out which threads did what. Frankly, it's not worth the headache when forking processes is just as fast and implicitly thread safe unless you explicitly share something. At least with explicit sharing you know exactly where to look if a threading style problem occurs.

如果性能如此重要，那就增加另一台计算机和负载平衡。对于开发人员调试一个多线程应用程序的成本，即使是由一个有经验的多线程程序编写的应用程序，你可能会买4块40核的英特尔主板，每块都有64g内存。

That being said, there are asymmetric cases where parallel processing isn't appropriate, like, you want a foreground thread to accept user input and show button presses immediately, without waiting for some clunky back end GUI to keep up. Sexy use of threads where multiprocessing isn't geometrically appropriate. Many things like that just variables or pointers. They aren't "handles" that can be shared in a fork. You have to use threads. Even if you did fork, you'd be sharing the same resource and subject to threading style issues.

你的任务有多紧密耦合?

如果它们可以彼此独立，那么就使用流程。如果它们相互依赖，则使用线程。这样，您就可以终止并重新启动坏进程，而不会影响其他任务的操作。

其他人讨论了这些考虑因素。

也许重要的区别是，在Windows中，与线程相比，进程是沉重和昂贵的，而在Linux中，差异要小得多，所以等式在不同的点上平衡。

从前有Unix，在这个好的旧Unix中，进程有很多开销，所以一些聪明的人所做的是创建线程，这些线程将与父进程共享相同的地址空间，他们只需要减少上下文切换，这将使上下文切换更有效。

在当代的Linux (2.6.x)中，进程的上下文切换和线程的上下文切换在性能上没有太大的区别(只有MMU的东西对线程来说是额外的)。 共享地址空间存在问题，这意味着线程中的错误指针可能破坏同一地址空间中的父进程或另一个线程的内存。

一个进程受到MMU的保护，所以一个错误的指针只会导致一个信号11，而不会损坏。

我通常会使用进程(在Linux中没有太多的上下文切换开销，但是由于MMU的内存保护)，但是如果我需要一个实时调度器类，则会使用pthreads，这完全是另一回事。

为什么你认为线程在Linux上有这么大的性能提升?你有这方面的数据吗，还是说这只是一个神话?