多进程与多线程区别

万次阅读 多人点赞 2016-04-21 10:01:16

在Unix上编程采用多线程还是多进程的争执由来已久，这种争执最常见到在C/S通讯中服务端并发技术的选型上，比如WEB服务器技术中，Apache是采用多进程的（perfork模式，每客户连接对应一个进程，每进程中只存在唯一一...

在Unix上编程采用多线程还是多进程的争执由来已久，这种争执最常见到在C/S通讯中服务端并发技术的选型上，比如WEB服务器技术中，Apache是采用多进程的（perfork模式，每客户连接对应一个进程，每进程中只存在唯一一个执行线程）， Java的Web容器Tomcat、Websphere等都是多线程的（每客户连接对应一个线程，所有线程都在一个进程中）。

从Unix发展历史看，伴随着Unix的诞生进程就出现了，而线程很晚才被系统支持，例如Linux直到内核2.6，才支持符合Posix规范的NPTL线程库。进程和线程的特点，也就是各自的优缺点如下：

进程优点：编程、调试简单，可靠性较高。
进程缺点：创建、销毁、切换速度慢，内存、资源占用大。
线程优点：创建、销毁、切换速度快，内存、资源占用小。
线程缺点：编程、调试复杂，可靠性较差。

上面的对比可以归结为一句话：“线程快而进程可靠性高”。线程有个别名叫“轻量级进程”，在有的书籍资料上介绍线程可以十倍、百倍的效率快于进程；而进程之间不共享数据，没有锁问题，结构简单，一个进程崩溃不像线程那样影响全局，因此比较可靠。我相信这个观点可以被大部分人所接受，因为和我们所接受的知识概念是相符的。

在写这篇文章前，我也属于这“大部分人”，这两年在用C语言编写的几个C/S通讯程序中，因时间紧总是采用多进程并发技术，而且是比较简单的现场为每客户fork()一个进程，当时总是担心并发量增大时负荷能否承受，盘算着等时间充裕了将它改为多线程形式，或者改为预先创建进程的形式，直到最近在网上看到了一篇论文《Linux系统下多线程与多进程性能分析》作者“周丽焦程波兰巨龙”，才认真思考这个问题，我自己也做了实验，结论和论文作者的相似，但对大部分人可以说是颠覆性的。

下面是得出结论的实验步骤和过程，结论究竟是怎样的？感兴趣就一起看看吧。

实验代码使用周丽论文中的代码样例，我做了少量修改，值得注意的是这样的区别：

论文实验和我的实验时间不同，论文所处的年代linux内核是2.4，我的实验linux内核是2.6，2.6使用的线程库是NPTL，2.4使用的是老的Linux线程库（用进程模拟线程的那个LinuxThread）。

论文实验和我用的机器不同，论文描述了使用的环境：单 cpu 机器基本配置为:celeron 2.0 GZ, 256M, Linux 9.2,内核 2.4.8。我的环境是我的工作本本：单cpu单核celeron(R) M 1.5 GZ，1.5G内存，ubuntu10.04 desktop，内核2.6.32。

进程实验代码（fork.c）：

#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#define P_NUMBER 255 /* 并发进程数量 */
#define COUNT 100 /* 每进程打印字符串次数 */
#define TEST_LOGFILE "logFile.log"
FILE *logFile = NULL;
char *s = "hello linux\0";
int main()
{
int i = 0,j = 0;
logFile = fopen(TEST_LOGFILE, "a+"); /* 打开日志文件 */
for(i = 0; i < P_NUMBER; i++)
{
if(fork() == 0) /* 创建子进程，if(fork() == 0){}这段代码是子进程运行区间 */
{
for(j = 0;j < COUNT; j++)
{
printf("[%d]%s\n", j, s); /* 向控制台输出 */
fprintf(logFile,"[%d]%s\n", j, s); /* 向日志文件输出 */
}
exit(0); /* 子进程结束 */
}
}
for(i = 0; i < P_NUMBER; i++) /* 回收子进程 */
{
wait(0);
}
printf("OK\n");
return 0;
}

进程实验代码（thread.c）：

#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#define P_NUMBER 255 /* 并发线程数量 */
#define COUNT 100 /* 每线程打印字符串次数 */
#define Test_Log "logFIle.log"
FILE *logFile = NULL;
char *s = "hello linux\0";
print_hello_linux() /* 线程执行的函数 */
{
int i = 0;
for(i = 0; i < COUNT; i++)
{
printf("[%d]%s\n", i, s); /* 向控制台输出 */
fprintf(logFile, "[%d]%s\n", i, s); /* 向日志文件输出 */
}
pthread_exit(0); /* 线程结束 */
}
int main()
{
int i = 0;
pthread_t pid[P_NUMBER]; /* 线程数组 */
logFile = fopen(Test_Log, "a+"); /* 打开日志文件 */
for(i = 0; i < P_NUMBER; i++)
pthread_create(&pid[i], NULL, (void *)print_hello_linux, NULL); /* 创建线程 */
for(i = 0; i < P_NUMBER; i++)
pthread_join(pid[i],NULL); /* 回收线程 */
printf("OK\n");
return 0;
}

两段程序做的事情是一样的，都是创建“若干”个进程/线程，每个创建出的进程/线程打印“若干”条“hello linux”字符串到控制台和日志文件，两个“若干”由两个宏 P_NUMBER和COUNT分别定义，程序编译指令如下：

diaoyf@ali:~/tmp1$ gcc -o fork fork.c
diaoyf@ali:~/tmp1$ gcc -lpthread -o thread thread.c

实验通过time指令执行两个程序，抄录time输出的挂钟时间（real时间）：

time ./fork
time ./thread

每批次的实验通过改动宏 P_NUMBER和COUNT来调整进程/线程数量和打印次数，每批次测试五轮，得到的结果如下：

一、重复周丽论文实验步骤

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m1.277s	0m1.175s	0m1.227s	0m1.245s	0m1.228s	0m1.230s
多线程	0m1.150s	0m1.192s	0m1.095s	0m1.128s	0m1.177s	0m1.148s

进程线程数：255 / 打印次数：100

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m6.341s	0m6.121s	0m5.966s	0m6.005s	0m6.143s	0m6.115s
多线程	0m6.082s	0m6.144s	0m6.026s	0m5.979s	0m6.012s	0m6.048s

进程线程数：255 / 打印次数：500

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m12.155s	0m12.057s	0m12.433s	0m12.327s	0m11.986s	0m12.184s
多线程	0m12.241s	0m11.956s	0m11.829s	0m12.103s	0m11.928s	0m12.011s

进程线程数：255 / 打印次数：1000

	第1次	第2次	第3次	第4次	第5次	平均
多进程	1m2.182s	1m2.635s	1m2.683s	1m2.751s	1m2.694s	1m2.589s
多线程	1m2.622s	1m2.384s	1m2.442s	1m2.458s	1m3.263s	1m2.614s

进程线程数：255 / 打印次数：5000

本轮实验是为了和周丽论文作对比，因此将进程/线程数量限制在255个，论文也是测试了255个进程/线程分别进行10 次,50 次,100 次,200 次……900 次打印的用时，论文得出的结果是：任务量较大时,多进程比多线程效率高;而完成的任务量较小时,多线程比多进程要快，重复打印 600 次时,多进程与多线程所耗费的时间相同。

虽然我的实验直到5000打印次数时，多进程才开始领先，但考虑到使用的是NPTL线程库的缘故，从而可以证实了论文的观点。从我的实验数据看，多线程和多进程两组数据非常接近，考虑到数据的提取具有瞬间性，因此可以认为他们的速度是相同的。

当前的网络环境中，我们更看中高并发、高负荷下的性能，纵观前面的实验步骤，最长的实验周期不过1分钟多一点，因此下面的实验将向两个方向延伸，第一，增加并发数量，第二，增加每进程/线程的工作强度。

二、增加并发数量的实验

下面的实验打印次数不变，而进程/线程数量逐渐增加。在实验过程中多线程程序在后三组（线程数500，800，1000）的测试中都出现了“段错误”，出现错误的原因和线程栈的大小有关。

实验中的计算机CPU是32位的赛扬，寻址最大范围是4GB（2的32次方），Linux是按照3GB/1GB的方式来分配内存，其中1GB属于所有进程共享的内核空间，3GB属于用户空间（进程虚拟内存空间），对于进程而言只有一个栈，这个栈可以用尽这3GB空间（计算时需要排除程序文本、数据、共享库等占用的空间），所以它的大小通常不是问题。但对线程而言每个线程有一个线程栈，这3GB空间会被所有线程栈摊分，线程数量太多时，线程栈累计的大小将超过进程虚拟内存空间大小，这就是实验中出现的“段错误”的原因。

Linux2.6的默认线程栈大小是8M，可以通过 ulimit -s 命令查看或修改，我们可以计算出线程数的最大上线: (1024*1024*1024*3) / (1024*1024*8) = 384，实际数字应该略小与384，因为还要计算程序文本、数据、共享库等占用的空间。在当今的稍显繁忙的WEB服务器上，突破384的并发访问并不是稀罕的事情，要继续下面的实验需要将默认线程栈的大小减小，但这样做有一定的风险，比如线程中的函数分配了大量的自动变量或者函数涉及很深的栈帧（典型的是递归调用），线程栈就可能不够用了。可以配合使用POSIX.1规定的两个线程属性guardsize和stackaddr来解决线程栈溢出问题， guardsize控制着线程栈末尾之后的一篇内存区域，一旦线程栈在使用中溢出并到达了这片内存，程序可以捕获系统内核发出的告警信号，然后使用 malloc获取另外的内存，并通过stackaddr改变线程栈的位置，以获得额外的栈空间，这个动态扩展栈空间办法需要手工编程，而且非常麻烦。

有两种方法可以改变线程栈的大小，使用 ulimit -s 命令改变系统默认线程栈的大小，或者在代码中创建线程时通过pthread_attr_setstacksize函数改变栈尺寸，在实验中使用的是第一种，在程序运行前先执行ulimit指令将默认线程栈大小改为1M：

diaoyf@ali:~/tmp1$ ulimit -s 1024
diaoyf@ali:~/tmp1$ time ./thread

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m4.958s	0m5.032s	0m5.181s	0m4.951s	0m5.032s	0m5.031s
多线程	0m4.994s	0m5.040s	0m5.071s	0m5.113s	0m5.079s	0m5.059s

进程线程数：100 / 打印次数：1000

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m12.155s	0m12.057s	0m12.433s	0m12.327s	0m11.986s	0m12.184s
多线程	0m12.241s	0m11.956s	0m11.829s	0m12.103s	0m11.928s	0m12.011s

进程线程数：255 / 打印次数：1000 （这里使用了第一次的实验数据）

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m17.686s	0m17.569s	0m17.609s	0m17.663s	0m17.784s	0m17.662s
多线程	0m17.694s	0m17.976s	0m17.884s	0m17.785s	0m18.261s	0m17.920s

进程线程数：350 / 打印次数：1000

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m23.638s	0m23.543s	0m24.135s	0m23.981s	0m23.507s	0m23.761s
多线程	0m23.634s	0m23.326s	0m23.408s	0m23.294s	0m23.980s	0m23.528s

进程线程数：500 / 打印次数：1000 （线程栈大小更改为1M）

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m38.517s	0m38.133s	0m38.872s	0m37.971s	0m38.005s	0m38.230s
多线程	0m38.011s	0m38.049s	0m37.635s	0m38.219s	0m37.861s	0m37.995s

进程线程数：800 / 打印次数：1000 （线程栈大小更改为1M）

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m48.157s	0m47.921s	0m48.124s	0m48.081s	0m48.126s	0m48.082s
多线程	0m47.513s	0m47.914s	0m48.073s	0m47.920s	0m48.652s	0m48.014s

进程线程数：1000 / 打印次数：1000 （线程栈大小更改为1M）

出现了线程栈的问题，让我特别关心Java线程是怎样处理的，因此用Java语言写了同样的实验程序，Java程序加载虚拟机环境比较耗时，所以没有用time提取测试时间，而直接将测时写入代码。对Linux上的C编程不熟悉的Java程序员也可以用这个程序去对比理解上面的C语言试验程序。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class MyThread extends Thread
{
static int P_NUMBER = 1000; /* 并发线程数量 */
static int COUNT = 1000; /* 每线程打印字符串次数 */
static String s = "hello linux\n";
static FileOutputStream out = null; /* 文件输出流 */
@Override
public void run()
{
for (int i = 0; i < COUNT; i++)
{
System.out.printf("[%d]%s", i, s); /* 向控制台输出 */
StringBuilder sb = new StringBuilder(16);
sb.append("[").append(i).append("]").append(s);
try
{
out.write(sb.toString().getBytes());/* 向日志文件输出 */
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
public static void main(String[] args) throws FileNotFoundException, InterruptedException
{
MyThread[] threads = new MyThread[P_NUMBER]; /* 线程数组 */
File file = new File("Javalogfile.log");
out = new FileOutputStream(file, true); /* 日志文件输出流 */
System.out.println("开始运行");
long start = System.currentTimeMillis();
for (int i = 0; i < P_NUMBER; i++) //创建线程
{
threads[i] = new MyThread();
threads[i].start();
}
for (int i = 0; i < P_NUMBER; i++) //回收线程
{
threads[i].join();
}
System.out.println("用时：" + (System.currentTimeMillis() – start) + " 毫秒");
return;
}
}

	第1次	第2次	第3次	第4次	第5次	平均
Java	65664 毫秒	66269 毫秒	65546 毫秒	65931 毫秒	66540 毫秒	65990 毫秒

线程数：1000 / 打印次数：1000

Java程序比C程序慢一些在情理之中，但Java程序并没有出现线程栈问题，5次测试都平稳完成，可以用下面的ps指令获得java进程中线程的数量：

diaoyf@ali:~$ ps -eLf | grep MyThread | wc -l
1010

用ps测试线程数在1010上维持了很长时间，多出的10个线程应该是jvm内部的管理线程，比如用于GC。我不知道Java创建线程时默认栈的大小是多少，很多资料说法不统一，于是下载了Java的源码jdk-6u21-fcs-src-b07-jrl-17_jul_2010.jar（实验环境安装的是 SUN jdk 1.6.0_20-b02），但没能从中找到需要的信息。对于jvm的运行，java提供了控制参数，因此再次测试时，通过下面的参数将Java线程栈大小定义在8192k，和Linux的默认大小一致：

diaoyf@ali:~/tmp1$ java -Xss8192k MyThread

出乎意料的是并没有出现想象中的异常，但用ps侦测线程数最高到达337，我判断程序在创建线程时在栈到达可用内存的上线时就停止继续创建了，程序运行的时间远小于估计值也证明了这个判断。程序虽然没有抛出异常，但运行的并不正常，另一个问题是最后并没有打印出“用时 xxx毫秒”信息。

这次测试更加深了我的一个长期的猜测：Java的Web容器不稳定。因为我是多年编写B/S的Java程序员，WEB服务不稳定常常挂掉也是司空见惯的，除了自己或项目组成员水平不高，代码编写太烂的原因之外，我一直猜测还有更深层的原因，如果就是线程原因的话，这颠覆性可比本篇文章的多进程性能颠覆性要大得多，想想世界上有多少Tomcat、Jboss、Websphere、weblogic在跑着，嘿嘿。

这次测试还打破了以前的一个说法：单CPU上并发超过6、7百，线程或进程间的切换就会占用大量CPU时间，造成服务器效率会急剧下降。但从上面的实验来看，进程/线程数到1000时（这差不多是非常繁忙的WEB服务器了），仍具有很好的线性。

三、增加每进程/线程的工作强度的实验

这次将程序打印数据增大，原来打印字符串为：

char *s = "hello linux\0";

现在修改为每次打印256个字节数据:

char *s = "1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\
1234567890abcdef\0";

	第1次	第2次	第3次	第4次	第5次	平均
多进程	0m28.149s	0m27.993s	0m28.094s	0m27.657s	0m28.016s	0m27.982s
多线程	0m28.171s	0m27.764s	0m27.865s	0m28.041s	0m27.780s	0m27.924s

进程线程数：255 / 打印次数：100

	第1次	第2次	第3次	第4次	第5次	平均
多进程	2m20.357s	2m19.740s	2m19.965s	2m19.788s	2m19.796s	2m19.929s
多线程	2m20.061s	2m20.462s	2m19.789s	2m19.514s	2m19.479s	2m19.861s

进程线程数：255 / 打印次数：500

	第1次	第2次
多进程	9m39s	9m17s
多线程	9m31s	9m22s

进程线程数：255 / 打印次数：2000 （实验太耗时，因此只进行了2轮比对）

【实验结论】

从上面的实验比对结果看，即使Linux2.6使用了新的NPTL线程库（据说比原线程库性能提高了很多，唉，又是据说！），多线程比较多进程在效率上没有任何的优势，在线程数增大时多线程程序还出现了运行错误，实验可以得出下面的结论：

在Linux2.6上，多线程并不比多进程速度快，考虑到线程栈的问题，多进程在并发上有优势。

四、多进程和多线程在创建和销毁上的效率比较

预先创建进程或线程可以节省进程或线程的创建、销毁时间，在实际的应用中很多程序使用了这样的策略，比如Apapche预先创建进程、Tomcat 预先创建线程，通常叫做进程池或线程池。在大部分人的概念中，进程或线程的创建、销毁是比较耗时的，在stevesn的著作《Unix网络编程》中有这样的对比图（第一卷第三版 30章客户/服务器程序设计范式）：

行号	服务器描述	进程控制CPU时间（秒，与基准之差）
行号	服务器描述	Solaris2.5.1	Digital Unix4.0b	BSD/OS3.0
0	迭代服务器（基准测试，无进程控制）	0.0	0.0	0.0
1	简单并发服务，为每个客户请求fork一个进程	504.2	168.9	29.6
2	预先派生子进程，每个子进程调用accept		6.2	1.8
3	预先派生子进程，用文件锁保护accept	25.2	10.0	2.7
4	预先派生子进程，用线程互斥锁保护accept	21.5
5	预先派生子进程，由父进程向子进程传递套接字	36.7	10.9	6.1
6	并发服务，为每个客户请求创建一个线程	18.7	4.7
7	预先创建线程，用互斥锁保护accept	8.6	3.5
8	预先创建线程，由主线程调用accept	14.5	5.0

stevens已驾鹤西去多年，但《Unix网络编程》一书仍具有巨大的影响力，上表中stevens比较了三种服务器上多进程和多线程的执行效率，因为三种服务器所用计算机不同，表中数据只能纵向比较，而横向无可比性，stevens在书中提供了这些测试程序的源码（也可以在网上下载）。书中介绍了测试环境，两台与服务器处于同一子网的客户机，每个客户并发5个进程（服务器同一时间最多10个连接），每个客户请求从服务器获取4000字节数据，预先派生子进程或线程的数量是15个。

第0行是迭代模式的基准测试程序，服务器程序只有一个进程在运行（同一时间只能处理一个客户请求），因为没有进程或线程的调度切换，因此它的速度是最快的，表中其他服务模式的运行数值是比迭代模式多出的差值。迭代模式很少用到，在现有的互联网服务中，DNS、NTP服务有它的影子。第1～5行是多进程服务模式，期中第1行使用现场fork子进程，2～5行都是预先创建15个子进程模式，在多进程程序中套接字传递不太容易（相对于多线程）， stevens在这里提供了4个不同的处理accept的方法。6～8行是多线程服务模式，第6行是现场为客户请求创建子线程，7～8行是预先创建15个线程。表中有的格子是空白的，是因为这个系统不支持此种模式，比如当年的BSD不支持线程，因此BSD上多线程的数据都是空白的。

从数据的比对看，现场为每客户fork一个进程的方式是最慢的，差不多有20倍的速度差异，Solaris上的现场fork和预先创建子进程的最大差别是504.2 ：21.5，但我们不能理解为预先创建模式比现场fork快20倍，原因有两个：

1. stevens的测试已是十几年前的了，现在的OS和CPU已起了翻天覆地的变化，表中的数值需要重新测试。

2. stevens没有提供服务器程序整体的运行计时，我们无法理解504.2 ：21.5的实际运行效率，有可能是1504.2 : 1021.5，也可能是100503.2 : 100021.5，20倍的差异可能很大，也可能可以忽略。

因此我写了下面的实验程序，来计算在Linux2.6上创建、销毁10万个进程/线程的绝对用时。

创建10万个进程（forkcreat.c）:

#include <stdlib.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>
int count; /* 子进程创建成功数量 */
int fcount; /* 子进程创建失败数量 */
int scount; /* 子进程回收数量 */
/* 信号处理函数–子进程关闭收集 */
void sig_chld(int signo)
{
pid_t chldpid; /* 子进程id */
int stat; /* 子进程的终止状态 */
/* 子进程回收，避免出现僵尸进程 */
while ((chldpid = wait(&stat)) > 0)
{
scount++;
}
}
int main()
{
/* 注册子进程回收信号处理函数 */
signal(SIGCHLD, sig_chld);
int i;
for (i = 0; i < 100000; i++) //fork()10万个子进程
{
pid_t pid = fork();
if (pid == -1) //子进程创建失败
{
fcount++;
}
else if (pid > 0) //子进程创建成功
{
count++;
}
else if (pid == 0) //子进程执行过程
{
exit(0);
}
}
printf("count: %d fcount: %d scount: %d\n", count, fcount, scount);
}

创建10万个线程（pthreadcreat.c）:

#include <stdio.h>
#include <pthread.h>
int count = 0; /* 成功创建线程数量 */
void thread(void)
{
/* 线程啥也不做 */
}
int main(void)
{
pthread_t id; /* 线程id */
int i,ret;
for (i = 0; i < 100000; i++) /* 创建10万个线程 */
{
ret = pthread_create(&id, NULL, (void *)thread, NULL);
if(ret != 0)
{
printf ("Create pthread error!\n");
return (1);
}
count++;
pthread_join(id, NULL);
}
printf("count: %d\n", count);
}

创建10万个线程的Java程序:

public class ThreadTest
{
public static void main(String[] ags) throws InterruptedException
{
System.out.println("开始运行");
long start = System.currentTimeMillis();
for(int i = 0; i < 100000; i++) //创建10万个线程
{
Thread athread = new Thread(); //创建线程对象
athread.start(); //启动线程
athread.join(); //等待该线程停止
}
System.out.println("用时：" + (System.currentTimeMillis() – start) + " 毫秒");
}
}

在我的赛扬1.5G的CPU上测试结果如下（仍采用测试5次后计算平均值）：

创建销毁10万个进程	创建销毁10万个线程	创建销毁10万个线程（Java）
0m18.201s	0m3.159s	12286毫秒

从数据可以看出，多线程比多进程在效率上有5～6倍的优势，但不能让我们在使用那种并发模式上定性，这让我想起多年前政治课上的一个场景：在讲到优越性时，面对着几个对此发表质疑评论的调皮男生，我们的政治老师发表了高见，“不能只横向地和当今的发达国家比，你应该纵向地和过去中国几十年的发展历史比”。政治老师的话套用在当前简直就是真理，我们看看，即使是在赛扬CPU上，创建、销毁进程/线程的速度都是空前的，可以说是有质的飞跃的，平均创建销毁一个进程的速度是0.18毫秒，对于当前服务器几百、几千的并发量，还有预先派生子进程/线程的必要吗？

预先派生子进程/线程比现场创建子进程/线程要复杂很多，不仅要对池中进程/线程数量进行动态管理，还要解决多进程/多线程对accept的“抢” 问题，在stevens的测试程序中，使用了“惊群”和“锁”技术。即使stevens的数据表格中，预先派生线程也不见得比现场创建线程快，在《Unix网络编程》第三版中，新作者参照stevens的测试也提供了一组数据，在这组数据中，现场创建线程模式比预先派生线程模式已有了效率上的优势。因此我对这一节实验下的结论是：

预先派生进程/线程的模式（进程池、线程池）技术，不仅复杂，在效率上也无优势，在新的应用中可以放心大胆地为客户连接请求去现场创建进程和线程。

我想，这是fork迷们最愿意看到的结论了。

五、并发服务的不可测性

看到这里，你会感觉到我有挺进程、贬线程的论调，实际上对于现实中的并发服务具有不可测性，前面的实验和结论只可做参考，而不可定性。对于不可测性，我举个生活中的例子。

这几年在大都市生活的朋友都感觉城市交通状况越来越差，到处堵车，从好的方面想这不正反应了我国GDP的高速发展。如果你7、8年前来到西安市，穿过南二环上的一些十字路口时，会发现一个奇怪的U型弯的交通管制，为了更好的说明，我画了两张图来说明，第一张图是采用U型弯之前的，第二张是采用U型弯之后的。

南二环交通图一

南二环交通图二

为了讲述的方便，我们不考虑十字路口左拐的情况，在图一中东西向和南北向的车辆交汇在十字路口，用红绿灯控制同一时间只能东西向或南北向通行，一般的十字路口都是这样管控的。随着车辆的增多，十字路口的堵塞越来越严重，尤其是上下班时间经常出现堵死现象。于是交通部门在不动用过多经费的情况下而采用了图二的交通管制，东西向车辆行进方式不变，而南北向车辆不能直行，需要右拐到下一个路口拐一个超大的U型弯，这样的措施避免了因车辆交错而引发堵死的次数，从而提高了车辆的通过效率。我曾经问一个每天上下班乘公交经过此路口的同事，他说这样的改动不一定每次上下班时间都能缩短，但上班时间有保障了，从而迟到次数减少了。如果今天你去西安市的南二环已经见不到U型弯了，东西向建设了高架桥，车辆分流后下层的十字路口已恢复为图一方式。

从效率的角度分析，在图一中等一个红灯45秒，远远小于图二拐那个U型弯用去的时间，但实际情况正好相反。我们可以设想一下，如果路上的所有运行车辆都是同一型号（比如说全是QQ3微型车），所有的司机都遵守交规，具有同样的心情和性格，那么图一的通行效率肯定比图二高。现实中就不一样了，首先车辆不统一，有大车、小车、快车、慢车，其次司机的品行不一，有特别遵守交规的，有想耍点小聪明的，有性子慢的，也有的性子急，时不时还有三轮摩托逆行一下，十字路口的“死锁”也就难免了。

那么在什么情况下图二优于图一，是否能拿出一个科学分析数据来呢？以现在的科学技术水平是拿不出来的，就像长期的天气预报不可预测一样，西安市的交管部门肯定不是分析各种车辆的运行规律、速度，再进行复杂的社会学、心理学分析做出U型弯的决定的，这就是要说的不可测性。

现实中的程序亦然如此，比如WEB服务器，有的客户在快车道（宽带），有的在慢车道（窄带），有的性子慢（等待半分钟也无所谓），有的性子急（拼命的进行浏览器刷新），时不时还有一两个黑客混入其中，这种情况每个服务器都不一样，既是是同一服务器每时每刻的变化也不一样，因此说不具有可测性。开发者和维护者能做的，不论是前面的这种实验测试，还是对具体网站进行的压力测试，最多也就能模拟相当于QQ3通过十字路口的场景。

结束语

本篇文章比较了Linux系统上多线程和多进程的运行效率，在实际应用时还有其他因素的影响，比如网络通讯时采用长连接还是短连接，是否采用 select、poll，java中称为nio的机制，还有使用的编程语言，例如Java不能使用多进程，PHP不能使用多线程，这些都可能影响到并发模式的选型。

收起

展开全文

python 彻底解读多线程与多进程

万次阅读 多人点赞 2019-03-26 14:20:34

title: 多线程与多进程 copyright: true top: 0 date: 2019-03-03 16:16:41 tags: 多线程多进程 categories: Python高阶笔记 permalink: password: keywords: description: 对python的多线程多进程进一步刨析。真是...


title: 多线程与多进程

copyright: true

top: 0

date: 2019-03-03 16:16:41

tags: 多线程多进程

categories: Python高阶笔记

permalink:

password:

keywords:

description: 对python的多线程多进程进一步刨析。
真是这样的话，有些话，只有准确的时间准确的地点亲口说出来。现在时间错过了，再说也没用了

在此之前请完整阅读完
Python threading 多线程模块
Python multiprocess 多进程模块
GIL 全局解释器锁
GIL(全局解释器锁，GIL 只有cpython有)：在同一个时刻，只能有一个线程在一个cpu上执行字节码，没法像c和Java一样将多个线程映射到多个CPU上执行，但是GIL会根据执行的字节码行数(为了让各个线程能够平均利用CPU时间，python会计算当前已执行的微代码数量，达到一定阈值后就强制释放GIL)和时间片以及遇到IO操作的时候主动释放锁，让其他字节码执行。
作用：限制多线程同时执行，保证同一个时刻只有一个线程执行。
原因：线程并非独立，在一个进程中多个线程共享变量的，多个线程执行会导致数据被污染造成数据混乱，这就是线程的不安全性，为此引入了互斥锁。
互斥锁：即确保某段关键代码的数据只能又一个线程从头到尾完整执行，保证了这段代码数据的安全性，但是这样就会导致死锁。
死锁：多个子线程在等待对方解除占用状态，但是都不先解锁，互相等待，这就是死锁。
基于GIL的存在，在遇到大量的IO操作(文件读写，网络等待)代码时，使用多线程效率更高。
多线程
一个CPU再同一个时刻只能执行一个线程，但是当遇到IO操作或者运行一定的代码量的时候就会释放全局解释器锁，执行另外一个线程。
就好像你要烧水和拖地，这是两个任务，如果是单线程来处理这两个任务的话，先烧水，等水烧开，再拖地。这样等待水烧开的时间就白白浪费了，倘若事交给多线程来做的话，就先烧水，烧水的过程中(相当于IO操作的时候)把时间资源让出来给拖地，拖完地后水也烧好了，这个就是多线程的优势，再同一个时间段做更多的事情，也就是再以后会降到的高并发。
它提供如下一些方法：
t1 = threading.Thread(target=你写的函数名,args=(传入变量(如果只有一个变量就必须在后加上逗号),),name=随便取一个线程名)：把一个线程实例化给t1，这个线程负责执行target=你写的函数名
t1.start()：负责执行启动这个线程
t1.join():必须要等待你的子线程执行完成后再执行主线程
t1.setDeamon(True):当你的主线程执行完毕后，不管子线程有没有执行完成都退出主程序，注意不能和t1.join()一起使用。
threading.current_thread().name:打印出线程名

这些方法一开始看可能会觉得有些多，不过不打紧，可以先把后面的代码看完在回过头看这些提供的方法就觉得很简单了。
单线程版本
import time

def mop_floor():
    print('我要拖地了')
    time.sleep(1)
    print('地拖完了')

def heat_up_watrt():
    print('我要烧水了')
    time.sleep(6)
    print('水烧开了')

start_time = time.time()
heat_up_watrt()
mop_floor()
end_time = time.time()
print('总共耗时:{}'.format(end_time-start_time))

返回结果：
我要烧水了
水烧开了
我要拖地了
地拖完了
总共耗时:7.000766277313232

单线程一共耗时7秒
多线程版本
import threading
import time

def mop_floor():
    print('我要拖地了')
    time.sleep(1)
    print('地拖完了')

def heat_up_watrt():
    print('我要烧水了')
    time.sleep(6)
    print('水烧开了')

start_time = time.time()
t1 = threading.Thread(target=heat_up_watrt)
t2 = threading.Thread(target=mop_floor)
t1.start()
t2.start()
t1.join()
t2.join()
end_time = time.time()
print('总共耗时:{}'.format(end_time-start_time))

返回结果：
我要烧水了
我要拖地了
地拖完了
水烧开了
总共耗时:6.000690460205078

可以看到烧水等待的时候直接执行拖地任务，并且总共耗时为6秒，关于这里的start和jion都是固定的操作套路，记住这两个代词以后直接套用即可，需要注意的是多线程程序的执行顺序是不确定的。当执行到sleep语句时，线程将被阻塞（Blocked），到sleep结束后，线程进入就绪（Runnable）状态，等待调度的命令执行另一个子线程，线程调度将自行选择一个线程执行。
类方法实现多线程
当遇到比较复杂的业务逻辑或者想要再子线程上面加一些方法的话，可以使用自己的类重写代码，还是使用刚刚的例子：
import threading
import time

class mop_floor(threading.Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        print('我要拖地了')
        time.sleep(1)
        print('地拖完了')

class heat_up_watrt(threading.Thread):
    def __init__(self,name):
        # 这里传入参数name，就是传入子线程名字
        super().__init__(name=name)
        # 记住这里的格式不能错

    def run(self):
        print('我要烧水了')
        print(self.name)
        print(threading.current_thread().name)
        # 这两个都是打印出当前子线程的名字
        time.sleep(6)
        print('水烧开了')

start_time = time.time()
t1 = mop_floor()
t2 = heat_up_watrt('***我是烧水员***')
t1.start()
t2.start()
t1.join()
t2.join()
end_time = time.time()
print('总共耗时:{}'.format(end_time-start_time))

返回结果：
我要拖地了
我要烧水了
***我是烧水员***
***我是烧水员***
地拖完了
水烧开了
总共耗时:6.000684022903442

python的threading.Thread类有一个run方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的start方法，可以启动该线程，交给python虚拟机进行调度，当该线程获得执行的机会时，就会调用run方法执行线程。
当然你也可以在类方法中加上使用线程锁
class test(threading.Thread):
	def __init__(self,lock):
		super().__init()__()
		self.lock = lock

	def run(self):
		self.lock.acquire()
		pass
		self.lock.release()

	if __name__ == '__main__':
		lock = threading.Lock()
		t = test(lock)

run方法与start方法的区别
其实不仅仅是start，使用run也可以让子线程执行：
def mop_floor():
    print('我要拖地了')
    time.sleep(1)
    print('地拖完了')


def heat_up_watrt():
    print('我要烧水了')
    time.sleep(6)
    print('水烧开了')

start_time = time.time()
t1 = threading.Thread(target=heat_up_watrt)
t2 = threading.Thread(target=mop_floor)
t1.run()
t2.run()
# 注意这里不能加上join()
end_time = time.time()
print('总共耗时:{}'.format(end_time - start_time))

返回结果：
我要烧水了
水烧开了
我要拖地了
地拖完了
总共耗时:7.000263929367065

两个子线程都用run()方法启动，但却是先运行t1.run()，运行完之后才按顺序运行t2.run()，两个线程都工作在主线程，没有启动新线程，因此，run()方法仅仅是普通函数调用。
start() 方法是启动一个子线程，线程名就是我们定义的name
run() 方法并不启动一个新线程，就是在主线程中调用了一个普通函数而已。

因此，如果你想启动多线程，就必须使用start()方法。
烧水和拖地只是两个比喻，运用到实际业务中就好比爬虫中一个线程去爬标题与网址另一个去爬标题内的内容，也好比一个线程去获取网页内容，另一个线程去把网页内容写入本地，网络编程中也是，你在等待tcp链接的时候可以去做另外的事情等等。
主线程与子线程
回到刚刚烧水与拖地的例子中：
主线程：一个进程中至少有一个线程，并作为程序的入口，这个线程就是主线程(从一开始的代码执行到最后的打印出执行时间为主线程)
子线程：一个进程至少有一个主线程，其它线程称为子线程(拖地与烧水两个子线程)
上面的例子中可以发现一共有三个线程，一个主线程和两个子线程，如何定义子线程的？其实在代码中就发现了，使用t1 = threading.Thread(target=heat_up_watrt)即可生成一个子线程，然后使用t1.start()即可启动这个子线程，这样的话t1.jion()是不是就多余呢？其实不然，使用t1.jion()的作用就是:等待子线程执行完毕后再执行主线程，如果不加上t1.jion()的话，子线程任然执行，但是子线程再等待的时候(io操作的时候)，释放出资源，这个时候主线程拿到资源运行主线程的任务，就会直接打印出共耗时:xxx，然后再等待子线程运行结束，最后退出主程序。
注意这里的t1.jion()放到位置很重要：
t1.start()
t1.join()
t2.start()
t2.join()

如果这样放的话，就是先执行线程1然后等待线程1执行完毕，然后执行线程2等待线程2执行完毕。
t1.start()
t2.start()
t1.join()
t2.join()

这样的话就不一样，会等到线程1与线程2执行完毕后再执行主线程。
上面说到主线程推出后要等待子线程执行完毕后才会退出整个主程序，此时使用t1.setDaemon(True)的话，会当主线程执行完毕后，t1子线程不管有没有执行完毕，都退出主程序。
线程间通信
在一个进程中，不同子线程负责不同的任务，t1子线程负责获取到数据，t2子线程负责把数据保存的本地，那么他们之间的通信使用Queue来完成。因为再一个进程中，数据变量是共享的，即多个子线程可以对同一个全局变量进行操作修改，Queue是加了锁的安全消息队列。
在此之前回顾Queue消息队列的使用Queue消息队列

注意queue.join()阻塞等待队列中任务全部处理完毕，需要配合queue.task_done使用
import threading
import time
import queue

q = queue.Queue(maxsize=5)

def t1(q):
    while 1:
        for i in range(10):
            q.put(i)




def t2(q):
    while not q.empty():
        print('队列中的数据量：'+str(q.qsize()))
        # q.qsize()是获取队列中剩余的数量
        print('取出值:'+str(q.get()))
        # q.get()是一个堵塞的，会等待直到获取到数据
        print('-----')
        time.sleep(0.1)


t1 = threading.Thread(target=t1,args=(q,))
t2 = threading.Thread(target=t2,args=(q,))
t1.start()
t2.start()

返回结果：
队列中的数据量：5
取出值:0
-----
队列中的数据量：5
取出值:1
-----
队列中的数据量：5
取出值:2
-----
队列中的数据量：5
取出值:3
-----
队列中的数据量：5
取出值:4
-----
队列中的数据量：5
取出值:5

这个即使消息队列的简单使用，举个例子就能清晰的明白线程间使用queue如何通信：
import threading
import time
import queue
'''
模拟包子店卖包子
厨房每一秒钟制造一个包子
顾客每三秒吃掉一个包子
厨房一次性最多存放100个包子
'''
q = queue.Queue(maxsize=100)
# 厨房一次性最多存放100个包子

def produce(q):
# 这个函数专门产生包子
    for i in range(10000):
        q.put('第{}个包子'.format(str(i)))
        # 生产出包子，表明包子的id号
        time.sleep(1)
        # 要一秒才能造出一个包子


def consume(q):
    while not q.empty():
        # 只要包子店里有包子
        print('包子店的包子剩余量：'+str(q.qsize()))
        # q.qsize()是获取队列中剩余的数量
        print('小桃红吃了:'+str(q.get()))
        # q.get()是一个堵塞的，会等待直到获取到数据
        print('------------')
        time.sleep(3)


t1 = threading.Thread(target=produce,args=(q,))
t2 = threading.Thread(target=consume,args=(q,))
t1.start()
t2.start()

返回结果：
包子店的包子剩余量：1
小桃红吃了:第0个包子
------------
包子店的包子剩余量：2
小桃红吃了:第1个包子
------------
包子店的包子剩余量：4
小桃红吃了:第2个包子
------------
包子店的包子剩余量：6
小桃红吃了:第3个包子
------------
包子店的包子剩余量：8
小桃红吃了:第4个包子
------------
包子店的包子剩余量：10
小桃红吃了:第5个包子
------------
......

线程同步
如果没有控制多个线程对同一资源的访问，对数据造成破坏，使得线程运行的结果不可预期。这种现象称为“线程不安全”。
同步就是协同步调，按预定的先后次序进行运行。
如:你说完，我再说。
"同"字从字面上容易理解为一起动作
其实不是，"同"字应是指协同、协助、互相配合。
如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B依言执行，再将结果给A;A再继续操作。
线程锁实现同步控制
线程锁使用threading.Lock()实例化，使用acquire()上锁，使用release()释放锁,牢记acquire与release()必须要同时成对存在。它提供一些如下方法：
acquire():上锁，这个时候只能运行上锁后的代码
release():解锁，解锁后把资源让出来，给其他线程使用

举个例子：
def run1():
    while 1:
        print('我是老大，我先运行')
def run2():
    while 1:
        print('我是老二，我第二运行')
def run3():
    while 1:
        print('我是老三，我最后运行')

t1 = threading.Thread(target=run1)
t2 = threading.Thread(target=run2)
t3 = threading.Thread(target=run3)
t1.start()
t2.start()
t3.start()

这样运行的结果是无序没法控制的，但是当你加上一把锁后，就不一样了。
def run1():
    while 1:
        if l1.acquire():
            # 如果第一把锁上锁了
            print('我是老大，我先运行')
            l2.release()
            # 释放第二把锁
def run2():
    while 1:
        if l2.acquire():
            # 如果第二把锁上锁了
            print('我是老二，我第二运行')
            l3.release()
            # 释放第三把锁

def run3():
    while 1:
        if l3.acquire():
            # 如果第三把锁上锁了
            print('我是老三，我最后运行')
            l1.release()
            # 释放第一把锁


t1 = threading.Thread(target=run1)
t2 = threading.Thread(target=run2)
t3 = threading.Thread(target=run3)

l1 = threading.Lock()
l2 = threading.Lock()
l3 = threading.Lock()
# 实例化三把锁

l2.acquire()
l3.acquire()

t1.start()
t2.start()
t3.start()

返回结果：
我是老大，我先运行
我是老二，我第二运行
我是老三，我最后运行
我是老大，我先运行
我是老二，我第二运行
我是老三，我最后运行
我是老大，我先运行
我是老二，我第二运行
我是老三，我最后运行
.....

此时虽然按照自己的要求同步执行，但是运行速度会慢一点，因为上锁与释放锁需要时间会影响性能。
lock还有Rlock的方法，RLock允许在同一线程中被多次acquire（比如你一个函数上了锁，这个函数调用另一个函数，另一个函数也上了锁 ）。而Lock却不允许这种情况。否则会出现死循环，程序不知道解哪一把锁。注意：如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的锁
条件变量实现同步精准控制
条件变量，用于复杂的线程间同步。在一些对线程间通信要求比较精准的需求下，使用简单的lock加锁解锁已经没法实现需求，这个时候condition条件控制就派上用场了。
condition源代码中本质上还是调用lock实现条件变量的控制， 他提供如下一些方法：
acquire():上锁
release():解锁
wait(timeout=None):堵塞线程，知道接受到一个notify或者超时才能继续运行，需记住wait()必须在已经获得lock的前提下才能调用
notify(n=1):打通线程(个人觉得这样叫方便理解),堵塞的线程接收到notify后开始运行，需记住notify()必须在已经获得lock的前提下才能调用
notifyAll():如果调用wait()堵塞的线程比较多，就打通所有的堵塞线程

通过实例代码来弄清楚他们怎么调用：
import threading
import random
import queue

q = queue.Queue(maxsize=100)

def produce(q):
    while 1:
        result = str(random.randint(1,100))
        q.put(result)
        print('我生成了一个随机数字:'+result)
def consume(q):
    while 1:
        res = q.get()
        print('我获取到了你生成的随机数字:'+str(res))

t1 = threading.Thread(target=produce,args=(q,))
t2 = threading.Thread(target=consume,args=(q,))
t1.start()
t2.start()

返回结果：
我生成了一个随机数字:29
我获取到了你生成的随机数字:92
我生成了一个随机数字:38
我获取到了你生成的随机数字:9
我生成了一个随机数字:21
我获取到了你生成的随机数字:37
我生成了一个随机数字:28

由于线程的不安全性，每次生成和获取的数字都并非同时是按顺序索取要得到的，这个时候condition就派上用场了（其实如果设置消息队列的q=queue.Queue(size=1)就能解决这个问题）。
import threading
import random

def produce():
    global q
    while 1:
        con.acquire()
        # 必须在有锁的前提下才能使用条件变量
        q = str(random.randint(1,100))
        print('我生成了一个随机数字:'+q)
        con.notify()
        # 发起一个信号，释放一个被堵塞的线程
        con.wait()
        # 发起一个信号，堵塞当前线程，等待另一个notify出现的时候就执行下面的代码
        con.release()
        # 必须要解锁
def consume():
    global q
    while 1:
        con.acquire()
        # 必须在有锁的前提下才能使用条件变量
        print('我获取到你生成的随机数字:'+q)
        con.notify()
        # 发起一个信号，释放一个被堵塞的线程
        con.wait()
        # 堵塞当前线程
        con.release()

t1 = threading.Thread(target=produce)
t2 = threading.Thread(target=consume)
con = threading.Condition()
t1.start()
t2.start()

返回结果：
我生成了一个随机数字:99
我获取到你生成的随机数字:99
我生成了一个随机数字:53
我获取到你生成的随机数字:53
我生成了一个随机数字:26
我获取到你生成的随机数字:26

同时condition的源码类中是有enter和exit两个魔法函数的，这也就意味能够使用with上下管理，省去自己加锁解锁的过程，举一个更加方便理解的例子：
import threading
import time
con = threading.Condition()
def run():
    while 1:
        with con:
            # 使用上下文管理器，省去了自动上锁解锁的过程
            print('-----------------')
            print('我完事了，该你了')
            con.notify()
            # 发起一个信号，释放掉一个wait
            con.wait()


def result():
    while 1:
        with con:
            con.wait()
            # 我在等待一个noity出现，这样我就能运行了
            time.sleep(0.3)
            print('三秒后....')
            print('我也完事了，你继续')
            con.notify()

t1 = threading.Thread(target=run)
t2 = threading.Thread(target=result)
t2.start()
t1.start()
# 注意这里必须t2先运行，想想为什么

返回结果：
-----------------
我完事了，该你了
三秒后....
我也完事了，你继续
-----------------
我完事了，该你了
三秒后....
我也完事了，你继续
......

condition源码中其实是调用了两把锁，外层的锁是调用lock，内层的锁是通过wait()方法实现，每次调用wait的时候，都会分配一把锁放在等待的队列中，知道noitfy方法出现就释放这把锁。
信号量实现定量的线程同步
semaphore适用于控制进入数量的锁，好比文件的读写操作，写入的时候一般只用一个线程写，如果多个线程同时执行写入操作的时候，就会造成写入数据混乱。 但是读取的时候可以用多个线程来读取，可以看到写与写是互斥的，读与写不是互斥的，读与读不是互斥的。
文件读写只是个例子，在一些日常业务中比如爬虫读取网址的线程数量控制等。
BoundedSemaphore。这种锁允许一定数量的线程同时更改数据，它不是互斥锁。比如地铁安检，排队人很多，工作人员只允许一定数量的人进入安检区，其它的人继续排队。
这个使用很简单的：
import time
import threading

def run(n, se):
    se.acquire()
    print("run the thread: %s" % n)
    time.sleep(1)
    se.release()

# 设置允许5个线程同时运行
semaphore = threading.BoundedSemaphore(5)
for i in range(20):
    t = threading.Thread(target=run, args=(i,semaphore))
    t.start()

运行后，可以看到5个一批的线程被放行。他用来控制进入某段代码的线程数量。
最后提起一点，Rolok是基于lock实现了，condition是基于Rlock和lock实现的，semahhore是基于condition实现的。
事件实现线程锁同步
事件线程锁的运行机制：

全局定义了一个Flag，如果Flag的值为False，那么当程序执行wait()方法时就会阻塞，如果Flag值为True，线程不再阻塞。这种锁，类似交通红绿灯（默认是红灯），它属于在红灯的时候一次性阻挡所有线程，在绿灯的时候，一次性放行所有排队中的线程。
事件主要提供了四个方法set()、wait()、clear()和is_set()。
调用wait()方法将等待信号。
is_set():判断当前是否状态
调用set()方法会将Flag设置为True。
调用clear()方法会将事件的Flag设置为False。

举个例子：
import threading
import time
import random

boys = ['此时一位捡瓶子的靓仔路过\n------------','此时一位没钱的网友路过\n------------','此时一位推着屎球的屎壳郎路过\n------------']
event = threading.Event()
def lighter():
    event.set()
    while 1:
        ti = (random.randint(1, 10))
        time.sleep(ti)
        print('等待 {} 秒后'.format(str(ti)))
        event.clear()
        time.sleep(ti)
        event.set()


def go(boy):
    while 1:
        if event.is_set():
            # 如果事件被设置
            print('在辽阔的街头')
            print(boy)
            time.sleep(random.randint(1, 5))
        else:
            print('在寂静的田野')
            print(boy)
            event.wait()
            print('突然，一辆火车驶过')
            time.sleep(5)

t1 = threading.Thread(target=lighter)
t1.start()

for boy in boys:
    t2 = threading.Thread(target=go,args=(boy,))
    t2.start()

线程池编程
作用
线程池只有在py3.2才内置的，2版本只能自己维护一个线程池很麻烦。在Python3.2中的concurrent_futures，其可以实现线程池，进程池，不必再自己使用管道传数据造成死锁的问题。并且这个模块具有线程池和进程池、管理并行编程任务、处理非确定性的执行流程、进程/线程同步等功能，但是平时用的最多的还是用来构建线程池和进程池。
在线程池中，主线程可以获取任意一个线程的状态以及返回结果，并且当一个线程完成后，主线程能立即得到结果。
功能
此模块由以下部分组成：

concurrent.futures.Executor: 这是一个虚拟基类，提供了异步执行的方法。
submit(function, argument): 调度函数（可调用的对象）的执行，将 argument 作为参数传入。
map(function, argument): 将 argument 作为参数执行函数，以 异步 的方式。
shutdown(Wait=True): 发出让执行者释放所有资源的信号。
concurrent.futures.Future: 其中包括函数的异步执行。Future对象是submit任务（即带有参数的functions）到executor的实例
done():比如t1.done()判断任务t1是否完成，没完成则返回False
cancel():比如t1.cancel()，取消线程执行，当线程正在执行和执行完毕后是没法取消执行的，但是如果一个线程没有启动的话，是可以取消t1线程执行的

套用模板
线程池用起来非常方便，基本上是照着模板往里面套即可
	# coding:utf-8
	from concurrent.futures import ThreadPoolExecutor
	# 导入线程池模块
	import threading
	# 导入线程模块，作用是获取当前线程的名称
	import os,time
	
	def task(n):
	    print('%s:%s is running' %(threading.currentThread().getName(),os.getpid()))
	    # 打印当前线程名和运行的id号码
	    time.sleep(2)
	    return n**2
	    # 返回传入参数的二次幂
	
	if __name__ == '__main__':
	    p=ThreadPoolExecutor()
	    #实例化线程池，设置线程池的数量，不填则默认为cpu的个数*5
	    l=[]
	    # 用来保存返回的数据，做计算总计
	    for i in range(10):
	        obj=p.submit(task,i)
			# 这里的obj其实是futures的对象，使用obj.result()获取他的结果
	        # 传入的参数是要执行的函数和该函数接受的参数
			# submit是非堵塞的
			# 这里执行的方式是异步执行
			# -----------------------------------
			# # p.submit(task,i).result()即同步执行
			# -----------------------------------
			# 上面的方法使用range循环有个高级的写法，即map内置函数
			# p = ThreadPoolExecutor()
			# obj=p.map(task,range(10))
			# p.shutdown()
			# 这里的obj的值就是直接返回的所有计算结果，不属于futures对象
			# -----------------------------------
	        l.append(obj)
	        # 把返回的结果保存在空的列表中，做总计算
	    p.shutdown()
	    # 所有计划运行完毕，关闭结束线程池
	    
	    print('='*30)
	    print([obj.result() for obj in l])
	
	#上面方法也可写成下面的方法
	    # with ThreadPoolExecutor() as p:   #类似打开文件,可省去.shutdown()
	    #     future_tasks = [p.submit(task, i) for i in range(10)]
	    # print('=' * 30)
	    # print([obj.result() for obj in future_tasks])

submit与map的区别

submit返回的是一个futures的对象，使用.result()才能获取他的运行结果
submit接受的对象是函数加一个固定的参数
map返回的是所有线程执行完毕后返回的结果
map接受的对象是函数加一个传入函数的集合列表
他们都能提前获取先执行完的结果
map比submit简单好用
map返回的结果是安装列表传入参数的顺序返回结果，submit返回结果是哪个线程先执行完就返回哪个线程的结果

获取部分执行完成的结果
想要获取到部分执行完成的结果使用
from concurrent.futures import as_completed

as_completed其实是一个生成器，他只会返回以及完成的线程结果
比如：
all_tasks = [p.submit(task,obj) for obj in l]
for f in as_completed(all_tasks):
	data = f.result()

因为生成器的缘故，他会先把执行完毕的结果赋值给data,其实通过map方法也可以实现
for data in p.map(task,range(10)):
	print data

这样也是可以优先把执行完毕的结果获取出来,map函数中其实也有yield函数。map和as_completed的区别在于，map执行是按照传入列表的元素一个一个按顺序返回的，并且返回的是直接的结果，as_completed返回的是一个futures的对象，使用.result()获取他的结果。as_completed返回的不是按照顺序返回的。
堵塞线程
多线程中使用jion堵塞线程，在线程池中也可以堵塞等待某一些子线程的线程池执行完毕后再执行主线程
from concurrent.futures import wait

wait用在你的线程池下面，比如：
all_tasks = [p.submit(task,obj) for obj in l]
wait(all_tasks)

这里只有等待all_tasks里面的线程执行完毕后才能继续执行，里面的可以加上参数等待线程池中只要有一个线程执行结束就执行后面的代码
wait(all_tasks,return_when=FIRST_COMPLETED)

判断是否执行完毕
task1 = p.submit(task,10)
print(task1.done())
# 如果执行完毕，返回True

取消执行线程
task1 = p.submit(task,10)
task1.cancel()

当线程正在执行和执行完毕后是没法取消执行的，但是如果一个线程没有启动的话，是可以取消t1线程执行的。
线程池提供的方法非常简单，易于使用，但是他背后的原理是很值得研究的。
线程池设计理念
线程池优秀的设计理念在于：他返回的结果并不是执行完毕后的结果，而是futures的对象，这个对象会在未来存储线程执行完毕的结果，这一点也是异步编程的核心。python为了提高与统一可维护性，多线程多进程和协程的异步编程都是采取同样的方式。
多进程
因为GIL的存在，没法利用到多核CPU的优势，这个时候多进程就出来了，它能利用多个CPU并发的优势实现并行。
多进程：消耗CPU操作，CPU密集计算
多线程：大量的IO操作
进程间切换的开销要大于线程间开销，对操作系统来说开多线程比开多进程来说消耗的资源少一些,不同的进程是由主进程完全复制后，每个进程独立隔离开，不像多线程对全局变量直接修改，因为是完全复制独立的，所以当主进程结束后，子进程任然执行。
另外多进程必须要注意的一点就是在运行的时候，必须要加上
if __name__ == '__main__':
	pass

进程池套用模板
与线程池用法几乎一致，进程池是基于multiprocessing实现的
from concurrent.futures import ProcessPoolExecutor
import os,time,random
def task(n):
    print('%s is running' %os.getpid())
    time.sleep(2)
    return n**2


if __name__ == '__main__':
    p=ProcessPoolExecutor()  #不填则默认为cpu的个数
    l=[]
    start=time.time()
    for i in range(10):
        obj=p.submit(task,i)   #submit()方法返回的是一个future实例，要得到结果需要用obj.result()
        l.append(obj)

    p.shutdown()  #类似用from multiprocessing import Pool实现进程池中的close及join一起的作用
    print('='*30)
    # print([obj for obj in l])
    print([obj.result() for obj in l])
    print(time.time()-start)

    #上面方法也可写成下面的方法
    # start = time.time()
    # with ProcessPoolExecutor() as p:   #类似打开文件,可省去.shutdown()
    #     future_tasks = [p.submit(task, i) for i in range(10)]
    # print('=' * 30)
    # print([obj.result() for obj in future_tasks])
    # print(time.time() - start)

进程池相关的使用功能与线程池基于一致。
multiprocessing具体使用与数据通信
这些功能在我之前的笔记写的比较完整与友好，这里不重复造轮子写概念了，

具体传送Python multiprocess 多进程模块
参考链接
具体链接之线程池进程池
参考链接 1 
参考链接 2 
参考链接 3
欢迎关注公众号：【安全研发】获取更多相关工具，课程，资料分享哦~

收起

展开全文

线程、进程、多线程、多进程和多任务小结

千次阅读 多人点赞 2019-04-20 11:59:56

3 多进程 4 多线程 5 线程与进程的关系 6 线程和进程的区别 7 进程的优缺点 7.1 进程的优点 7.2 进程的缺点 8 线程的优缺点 8.1 线程的优点 8.2 线程的缺点 9 多线程的优缺点 9.1 多线程的优点 9.2 多...

最近经常看到多进程，多线程和多任务等名词，很容易混。网上查了很多资料，内容很多。作为Linux初学者，还是想从最基础的开始了解，找通俗的例子了解，由浅入深。我把网上查阅的资料整理的一下，一次性全部摸透，还是有点难度的。写个博客，记录一下，以便后期查阅复习。

首先，从定义开始，先看一下教科书上进程和线程定义：

进程：资源分配的最小单位。

线程：程序执行的最小单位。

心中默念，啥啥啥，写的这是啥。于是乎我就想到王宝强一脸懵逼的表情。

1 进程

进程是程序执行时的一个实例，即它是程序已经执行到课中程度的数据结构的汇集。从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。

举例说明进程：

想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕。他有做生日蛋糕的食谱，厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中，做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(CPU)，而做蛋糕的各种原料就是输入数据。进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来，说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态)，然后拿出一本急救手册，按照其中的指示处理蛰伤。这里，我们看到处理机制是从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治)，每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后，这位计算机科学家又回来做蛋糕，从他离开时的那一步继续做下去。

2 线程

线程是CPU调度的最小单位(程序执行流的最小单元)，它被包含在进程之中，是进程中的实际运作单元。一条线程是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

一个标准的线程有线程ID、当前指令指针(PC),寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单元，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现处间断性。

线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件(如某个信号量)，逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

举例说明线程：

假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且有共同都需要拥有的东西——-文本内容，不停的切换造成性能上的损失。若有一种机制，可以使任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带来的性能损耗，那就好了。这种机制就是线程。

总的来说：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。

3 多进程

进程是程序在计算机上的一次执行活动。当你运行一个程序，你就启动了一个进程。显然，程序是死的(静态的)，进程是活的(动态的)。进程可以分为系统进程和用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程，它们就是处于运行状态下的操作系统本身；所有由用户启动的进程都是用户进程。进程是操作系统进行资源分配的单位。进程又被细化为线程，也就是一个进程下有多个能独立运行的更小的单位。在同一个时间里，同一个计算机系统中如果允许两个或两个以上的进程处于运行状态，这便是多任务。现代的操作系统几乎都是多任务操作系统，能够同时管理多个进程的运行。多任务带来的好处是明显的，比如你可以边听网易云音乐，一边上网，与此同时甚至可以将下载的文档打印出来，而这些任务之间丝毫不会相互干扰。那么这里就涉及到并行的问题，俗话说，一心不能二用，这对计算机也一样，原则上一个CPU只能分配给一个进程，以便运行这个进程。我们通常使用的计算机中只有一个CPU，也就是说只有一颗心，要让它一心多用，同时运行多个进程，就必须使用并发技术。实现并发技术相当复杂，最容易理解的是“时间片轮转进程调度算法”，它的思想简单介绍如下：在操作系统的管理下，所有正在运行的进程轮流使用CPU，每个进程允许占用CPU的时间非常短(比如10毫秒)，这样用户根本感觉不出来 CPU是在轮流为多个进程服务，就好像所有的进程都在不间断地运行一样。但实际上在任何一个时间内有且仅有一个进程占有CPU。如果一台计算机有多个CPU，情况就不同了，如果进程数小于CPU数，则不同的进程可以分配给不同的CPU来运行，这样，多个进程就是真正同时运行的，这便是并行。

并行处理（Parallel Processing）是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作于同一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间。并发处理(concurrency Processing)：指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机(CPU)上运行，但任一个时刻点上只有一个程序在处理机(CPU)上运行

并发的关键是你有处理多个任务的能力，不一定要同时。并行的关键是你有同时处理多个任务的能力。所以说，并行是并发的子集。

4 多线程

线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单元。在单一程序中同时运行多个想成完成不同的工作，称为多线程。

多线程是为了使得多个线程并行的工作以完成多项任务，以提高系统的效率。线程是在同一时间需要完成多项任务的时候被实现的。

打个比方：

多进程是立体交通系统（近似于立交桥），虽然造价高，上坡下坡多耗点油，但是不堵车。

多线程是平面交通系统，造价低，但红绿灯太多，老堵车。

5 线程与进程的关系

（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程；

（2）资源分配给进程，同一进程内的所有线程共享该进程的所有资源；

（3）线程在执行过程中需要协作同步。不同进程中的线程之间要利用消息通信的方法实现同步；

（4）处理机分配给线程，即真正在处理机上运行的是线程；

（5）线程是进程的一个执行单元，也是进程内的可调用实体。

6 线程和进程的区别

（1）线程共享内存空间；进程的内存是独立的；

（2）同一个进程的线程之间可以直接交流；两个进程想通信，必须通过一个中间代理来实现；

（3）创建新进程很简单；创建新进程需要对其父进程进行一个克隆；

（4）一个线程可以控制和操作同一进程里的其他线程；但是进程只能操作子进程；

（5）改变注线程(如优先权)，可能会影响其他线程；改变父进程，不影响子进程。

（6）调度：线程作为分配和调度的基本单位，进程作为拥有资源的基本单位

（7）并发性：不进进程之间可以并发执行，同一进程内的线程也可以并发执行

（8）拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但是可以访问隶属于进程的系统资源

（9）系统开销：在创建和撤销进程的时候，系统都要分配和回收资源，导致系统的明显大于创建和撤销线程时的开销。但进程有独立的地址空间，进程崩溃后，在保护模式的下不会对其他进程造成影响，而线程只是进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有独立的地址空间，一个线程死后就等于整个进程死掉，所以多进程程序要比多线程程序健壮，但是在进程切换的时候消耗的资源较大，效率差。

根本区别就一点：用多进程每个进程有自己的地址空间(address space)，线程则共享地址空间。

总结：多线程执行效率高; 多进程耗资源，安全。

7 进程的优缺点

7.1 进程的优点

1）顺序程序的特点：具有封闭性和可再现性；

2）程序的并发执行和资源共享。多道程序设计出现后，实现了程序的并发执行和资源共享，提高了系统的效率和系统的资源利用率。

7.2 进程的缺点

操作系统调度切换多个线程要比切换调度进程在速度上快的多。而且进程间内存无法共享，通讯也比较麻烦。线程之间由于共享进程内存空间，所以交换数据非常方便；在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。

8 线程的优缺点

8.1 线程的优点

1）它是一种非常"节俭"的多任务操作方式。在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。当然，在具体的系统上，这个数据可能会有较大的区别；

2）线程间方便的通信机制，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便；

3）使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上；

4）改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

8.2 线程的缺点

1）调度时，要保存线程状态，频繁调度，需要占用大量的机时；

2）程序设计上容易出错（线程同步问题）。

9 多线程的优缺点

9.1 多线程的优点

1）无需跨进程边界；程序逻辑和控制方式简单；

2）所有线程可以直接共享内存和变量等；

3）线程方式消耗的总资源比进程方式好。

9.2 多线程的缺点

1）每个线程与主程序共用地址空间，受限于2GB地址空间；

2）线程之间的同步和加锁控制比较麻烦；一个线程的崩溃可能影响到整个程序的稳定性；

3）到达一定的线程数程度后，即使再增加CPU也无法提高性能，例如Windows Server 2003，大约是1500个左右的线程数就快到极限了（线程堆栈设定为1M），如果设定线程堆栈为2M，还达不到1500个线程总数；

4）线程能够提高的总性能有限，而且线程多了之后，线程本身的调度也是一个麻烦事儿，需要消耗较多的CPU 。

10多进程的优缺点

10.1 多进程的优点

1）每个进程互相独立，不影响主程序的稳定性，子进程崩溃没关系；

2）通过增加CPU，就可以容易扩充性能；

3）可以尽量减少线程加锁/解锁的影响，极大提高性能，就算是线程运行的模块算法效率低也没关系；

4）每个子进程都有2GB地址空间和相关资源，总体能够达到的性能上限非常大。

10.2 多进程的缺点

1）逻辑控制复杂，需要和主程序交互；

2）需要跨进程边界，如果有大数据量传送，就不太好，适合小数据量传送、密集运算多进程调度开销比较大。

总结：最好是多进程和多线程结合，即根据实际的需要，每个CPU开启一个子进程，这个子进程开启多线程可以为若干同类型的数据进行处理。当然你也可以利用多线程+CPU+轮询方式来解决问题……方法和手段是多样的，关键是自己看起来实现方便有能够满足要求，代价也合适。

按照多个不同的维度（类别），来看看多线程和多进程的对比（注：因为是感性的比较，因此都是相对的，不是说一个好得不得了，另外一个差的无法忍受）。

对比类别	多进程	多线程	总结
数据共享、同步	数据共享复杂，需要用IPC；数据是分开的，同步简单	因为共享进程数据，数据共享简单，但也是因为这个原因导致同步复杂	各有优势
内存、CPU	占用内存多，切换复杂，CPU利用率低	占用内存少，切换简单，CPU利用率高	线程占优
创建销毁、切换	创建销毁、切换复杂，速度慢	创建销毁、切换简单，速度很快	线程占优
编程、调试	编程简单，调试简单	编程复杂，调试复杂	进程占优
可靠性	进程间不会互相影响	一个线程挂掉将导致整个进程挂掉	进程占优
分布式	适应于多核、多机分布式；如果一台机器不够，扩展到多台机器比较简单	适应于多核分布式	进程占优

其实没有绝对的好与坏，只有哪个更加合适的问题。我们来看实际应用中究竟如何判断更加合适。

1）需要频繁创建销毁的优先用线程

这种原则最常见的应用就是Web服务器了，来一个连接建立一个线程，断了就销毁线程，要是用进程，创建和销毁的代价是很难承受的

2）需要进行大量计算的优先使用线程

所谓大量计算，当然就是要耗费很多CPU，切换频繁了，这种情况下线程是最合适的。这种原则最常见的是图像处理、算法处理。

3）强相关的处理用线程，弱相关的处理用进程

什么叫强相关、弱相关？理论上很难定义，给个简单的例子就明白了。

一般的Server需要完成如下任务：消息收发、消息处理。“消息收发”和“消息处理”就是弱相关的任务，而“消息处理”里面可能又分为“消息解码”、“业务处理”，这两个任务相对来说相关性就要强多了。因此“消息收发”和“消息处理”可以分进程设计，“消息解码”、“业务处理”可以分线程设计。当然这种划分方式不是一成不变的，也可以根据实际情况进行调整。

4）可能要扩展到多机分布的用进程，多核分布的用线程

5）都满足需求的情况下，用你最熟悉、最拿手的方式

至于“数据共享、同步”、“编程、调试”、“可靠性”这几个维度的所谓的“复杂、简单”应该怎么取舍，我只能说：没有明确的选择方法。但我可以告诉你一个选择原则：如果多进程和多线程都能够满足要求，那么选择你最熟悉、最拿手的那个。需要提醒的是：虽然我给了这么多的选择原则，但实际应用中基本上都是“进程+线程”的结合方式，千万不要真的陷入一种非此即彼的误区。

8 多任务(多进程)

现代操作系统比如Mac OS X，UNIX，Linux，Windows等，都是支持“多任务”的操作系统。

什么叫“多任务”呢？简单地说，就是操作系统可以同时运行多个任务。打个比方，你一边在用浏览器上网，一边在听MP3，一边在用Word写论文，这就是多任务，至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是桌面上没有显示而已。

现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢？

其实操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程。

有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些 “子任务” 称为线程（Thread）。

由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。当然，真正地同时执行多线程需要多核CPU才可能实现。

参考资料

[1] https://www.cnblogs.com/pingqiang/p/8007549.html#多进程多线程

[2] https://www.cnblogs.com/ww36315610/p/3881533.html?tdsourcetag=s_pctim_aiomsg

[3] http://www.cnblogs.com/Yogurshine/p/3640206.html

[4] https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/0013868322563729e03f6905ea94f0195528e3647887415000?tdsourcetag=s_pctim_aiomsg

[5] https://www.cnblogs.com/yuanchenqi/articles/6755717.html#_label3?tdsourcetag=s_pctim_aiomsg

[6] https://www.cnblogs.com/zhanht/p/5401685.html?tdsourcetag=s_pctim_aiomsg

[7] https://www.kafan.cn/edu/85866456.html

收起

展开全文

线程进程多线程

Python多进程2 多进程的参数返回

千次阅读 2020-01-15 21:23:02

原文地址学习来源对于在当前主进程的操作，函数的返回值...在主进程中可以将他们依次取出，这样就做到了多进程与主进程的返回值传递。关于队列，我在我的这篇博客中做了简单说明，该博客也是多线程中返回值传递的...

原文地址
学习来源
分类目录——多进程
对于在当前主进程的操作，函数的返回值可以直接操作，或者用一个参量进行接收。但是在其他进程中运行的函数的返回值，是无法直接传递到主进程的。将其返回值存到一个全局性的存储器中，是一种可行的方案。这里用queue（队列）来存储多个进程的返回值。在主进程中可以将他们依次取出，这样就做到了多进程与主进程的返回值传递。关于队列，我在我的这篇博客中做了简单说明，该博客也是多线程中返回值传递的介绍。
实例演示
import multiprocessing as mp    # 多进程的模块

def job(q):     # 进程调用测程序，传递的参数为一个queue（队列）对象
    res = 0
    for i in range(1000):
        res += i**2
    q.put(res)      # 把结果（就是主进程中函数的返回值）存入队列

if __name__ == '__main__':
    q = mp.Queue()
    p1 = mp.Process(target=job, args=(q,))
    # 生成进程，并传入要执行的操作（函数），args=参数列表，只传一个参数的时候注意要在参数后面加一个逗号，因为args需要一个可迭代的参量
    p2 = mp.Process(target=job, args=(q,))
    p1.start()      # 进程操作开始执行
    p2.start()
    p1.join()       # 将进程操作设定为关键路径
    p2.join()
    # p1，p2都进行join()操作，p1，p2执行完之后（p1，p2都进行了job并把结果存入了q）才进行下面的操作
    res1 = q.get()      # 从结果队列中取值
    res2 = q.get()
    print(res1+res2)

收起

展开全文

python 队列返回值

python多进程与并发
万次阅读 2020-07-13 04:19:35
介绍多线程与多进程的区别，以及python实现并发
收起
python 多线程
Python多进程之进程池
千次阅读 2017-04-05 11:28:16
当我们有并行处理需求的时候，可以采用多进程迂回地解决。如果要在主进程中启动大量的子进程，可以用进程池的方式批量创建子进程。首先，创建一个进程池子，然后使用apply_async()方法将子进程加入到进程池中。...
收起
python 多线程
Python多进程之进程池Pool
千次阅读 2018-04-12 17:26:53
我们可以很方便的开启多进程，但是多进程开启还是需要限制一下的，否则会导致计算机崩溃 from multiprocessing import Process,Pool,freeze_support #导入相关的包，多进程和进程池 import time,os def Foo(i):...
收起
python
gdb调试多进程
千次阅读 2020-12-01 11:15:28
在Linux系统下主要使用的调试器就是gdb, 但是在使用gdb的时候遇到了多进程的程序时,默认的配置我们是不可以直接多多个进程同时进行调试的, 需要设置几个参数… 例子这里程序利用fork()函数生成了一个子进程(第一个...
收起
多进程通信
千次阅读 2018-08-18 18:53:54
多进程：首先，先来讲一下fork之后，发生了什么事情。由fork创建的新进程被称为子进程（child process）。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子...
收起
多进程和多线程的区别是什么？多进程和多线程的优缺点分析
万次阅读 2018-08-23 13:00:21
多进程和多线程的区别是什么？多进程和多线程的优缺点分析　多进程和多线程的区别是什么？此前小编给大家介绍了进程和线程的区别，那么大家知道多进程和多线程的区别又是什么吗？它们分别有什么优缺点？为了...
收起
多进程和多进程间通信
千次阅读 2015-03-17 07:55:18
一、进程空间和多进程父子关系：进程是分配资源的最小单位(进程内存空间)。fork后，子进程会复制父进程的task_struct结构；并为子进程的堆栈分配物理页（开始只是标记为只读的)，延迟到当父或子线程尝试写这些区域...
收起
Python多进程多线程测试
万次阅读 2019-09-17 17:18:35
今天在工作中遇到爬虫效率问题，在此处记录多进程、多线程测试脚本 #!/usr/bin/env python # -*- coding: utf-8 -*- __author__ = 'Seven' from concurrent.futures import ThreadPoolExecutor, ...
收起
Python 进程，多进程，获取进程id，给子进程传递参数
千次阅读 2018-11-21 22:05:44
线程与线程之间共享全局变量，进程之间不能共享全局变量。进程与进程相互独立 (可以通过socket套接字实现进程间通信，可以通过硬盘(文件)实现进程...demo.py（多进程）： import threading # 线程 import tim...
收起
Python 进程
Android多进程实现,一个APP多个进程
千次阅读 2019-07-30 10:03:06
Android IPC机制（一）开启多进程（文章1：刘望舒大神的文章，1.3w阅读量，20赞） Android IPC机制（二）用Messenger进行进程间通信（文章2：刘望舒大神的文章，6k阅读量，7赞） Android多进程实现,一个APP多个...
收起
多线程与多进程
千次阅读 2019-02-27 10:26:49
多进程 多线程优劣数据共享、同步数据是分开的:共享复杂，需要用IPC;同步简单多线程共享进程数据：共享简单；同步复杂各有优势内存、CPU 占用内存多，切换复杂，CPU利用率低占用内存少...
收起
c++多进程编程
千次阅读 2020-04-16 10:12:52
c++多进程编程介绍进程：进程是一个正在执行的程序，是向CPU申请资源的，进程之间数据相互独立，一个进程至少有一个线程。线程：线程是进程中的单一的顺序控制流程也可以叫做最小控制单元，线程是进程中执行单元...
收起
python多进程假死
千次阅读 多人点赞 2019-08-23 15:55:17
结论：python多进程间用Queue通信时，如果子进程操作Queue满了或者内容比较大的情况下，该子进程会阻塞等待取走Queue内容(如果Queue数据量比较少，不会等待)，如果调用join，主进程将处于等待，等待子进程结束，造成...
收起
python多进程和进程池
千次阅读 2018-12-15 02:05:42
写在最前面： linux下可使用 fork ...我们分别使用单进程和多进程处理run函数 # -*- coding: utf-8 -*- import time,os from multiprocessing import Pool def run(n): time.sleep(1) print('Run chil...
收起
python
多进程详细讲解
千次阅读 2018-08-18 19:48:32
一、什么是多进程 相信看过我其他博客的同学已经对多线程和多进程有一个简单的了解了，下面我们简单说一下多进程。我们知道在进行较多的I/O操作时候，比如socket server之类的可以用到多线程，那么什么时候用多进程...
收起
Pipe Manager
编写多进程程序 --多进程编程
千次阅读 2015-06-28 01:47:17
通过编写多进程程序，熟练掌握fork()、exec()、wait()和waitpid()等函数的使用，进一步理解在Linux中多进程编程的步骤。实验内容该实验有3个进程，其中一个为父进程，其余两个是该父进程创建的子进程，...
收起
python多进程编程，如何让主进程和子进程都退出
千次阅读 2020-05-06 20:10:36
python的多线程不是真正的多线程，所以使用多进程来实现高并发，比如训练模型读取数据时，但是kill只会杀死相应的进程ID，由于真实环境下子进程太多，一个一个去kill太麻烦，下面实现了只需要杀死主进程id即可同时使...
收起
python kill 深度学习
python的多线程与多进程介绍及多进程详解(调用multiprocessing组件)
千次阅读 2017-04-17 08:15:29
这里我们解决以下几个问题：多进程与多线程概念 多进程和单进程区别 python下通过multiprocessing调用多进程的基本方法
收起
python 多线程
Android开发中怎样用多进程、用多进程的好处、多进程的缺陷、解决方法
千次阅读 2017-02-10 12:21:12
1.怎样用多进程 Android多进程概念：一般情况下，一个应用程序就是一个进程，这个进程名称就是应用程序包名。我们知道进程是系统分配资源和调度的基本单位，所以每个进程都有自己独立的资源和内存空间，别的进程...
收起
process
Python多进程初识
千次阅读 2018-04-12 17:06:12
''' io 操作不占用CPU 读文件读内存等都是io操作计算是占cpu python的多线程其实是假的多线程，...这个时候可以用多进程，进程之间也不需要锁的概念适合io密集型的任务，例如同时操作多个文件，多个socket操作，...
收起
python
【Python-多进程】Python中多进程之间的数据共享
千次阅读 2018-06-01 20:22:52
多进程中，每个进程都是独立的，各自持有一份数据，无法共享。本篇文章介绍三种用于进程数据共享的方法queuesArrayManager.dictpipeQueue12345678910111213from multiprocessing import queuesimport ...
收起
python 多进程编程
万次阅读 2018-11-21 14:11:08
python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing，只需要定义一个函数，Python会完成其他所有事情...
收起
python
python实现多进程
万次阅读 多人点赞 2017-03-12 14:02:48
在这里用Python程序来实现多进程并加深对多进程并发的理解
收起
并发
Linux多进程 -- 创建子进程
千次阅读 2017-07-09 13:41:57
Linux多进程 – 创建子进程 fork函数 Linux创建单个子进程 Linux创建多个子进程父子进程共享内容
收起
linux
nginx 多进程进程 epoll
千次阅读 2015-01-24 10:03:45
有一个单进程的linux epoll服务器程序，近来希望将它改写成多进程版本，主要原因有： 1、在服务高峰期间并发的网络请求非常大，目前的单进程版本的支撑不了：单进程时只有一个循环先后处理epoll_wait()...
收起
多线程、多进程、线程池、进程池
千次阅读 2017-04-11 15:01:18
OS实现多进程和多线程往往是通过时间片的形式执行的，即让每个任务(进程/线程)轮流交替执行，因为时间片切分的很小，以至于我们感觉多个任务在同时执行。如果我们要同时执行多个任务怎么办？主要有两种解决方案：一...
收起
线程池线程

多进程与多线程区别

python 彻底解读多线程与多进程

title: 多线程与多进程 copyright: true top: 0 date: 2019-03-03 16:16:41 tags: 多线程多进程 categories: Python高阶笔记 permalink: password: keywords: description: 对python的多线程多进程进一步刨析。

GIL 全局解释器锁

多线程

单线程版本

多线程版本

类方法实现多线程

run方法与start方法的区别

主线程与子线程

线程间通信

线程同步

线程锁实现同步控制

条件变量实现同步精准控制

信号量实现定量的线程同步

事件实现线程锁同步

线程池编程

作用

功能

套用模板

submit与map的区别

获取部分执行完成的结果

堵塞线程

判断是否执行完毕

取消执行线程

线程池设计理念

多进程

进程池套用模板

multiprocessing具体使用与数据通信

参考链接

线程、进程、多线程、多进程 和 多任务 小结

1 进程

2 线程

3 多进程

4 多线程

5 线程与进程的关系

6 线程和进程的区别

7 进程的优缺点

7.1 进程的优点

7.2 进程的缺点

8 线程的优缺点

8.1 线程的优点

8.2 线程的缺点

9 多线程的优缺点

9.1 多线程的优点

9.2 多线程的缺点

10多进程的优缺点

10.1 多进程的优点

10.2 多进程的缺点

8 多任务(多进程)

参考资料

Python多进程2 多进程的参数返回

python多进程与并发

Python多进程之进程池

Python多进程之进程池Pool

gdb调试多进程

多进程通信

多进程和多线程的区别是什么？多进程和多线程的优缺点分析

多进程和多进程间通信

Python多进程多线程测试

Python 进程，多进程，获取进程id，给子进程传递参数

Android多进程实现,一个APP多个进程

多线程与多进程

c++多进程编程

python多进程假死

python多进程和进程池

多进程详细讲解

编写多进程程序 --多进程编程

python多进程编程，如何让主进程和子进程都退出

python的多线程与多进程介绍及多进程详解(调用multiprocessing组件)

Android开发中怎样用多进程、用多进程的好处、多进程的缺陷、解决方法

Python多进程初识

【Python-多进程】Python中多进程之间的数据共享

python 多进程编程

python实现多进程

Linux多进程 -- 创建子进程

nginx 多进程进程 epoll

多线程、多进程、线程池、进程池

多进程

title: 多线程与多进程
copyright: true
top: 0
date: 2019-03-03 16:16:41
tags: 多线程多进程
categories: Python高阶笔记
permalink:
password:
keywords:
description: 对python的多线程多进程进一步刨析。

线程、进程、多线程、多进程和多任务小结