Python多进程详解：如何合理利用最大进程数？

Python支持的最大线程数是多少？

Python线程太慢。
如果要并发运行，就用greenlet，速度快，写起来也方便。

如果锁是synchronized的话，线程太多的话可能会变慢。

ulimit-s返回我的默认线程数组大小8192。
将其除以内存大小即可得到理论线程数。

进程概念：暴露给操作系统整体的管理，其中包含对各种资源的调用。
各种资源管理的集合可以称为进程。

线程的概念：是操作系统能够进行操作调度的最小单位。
基本上它是指令的集合。

进程和线程的区别：

1.线程共享内存空间，进程拥有空闲内存空间。

2.线程启动速度快，但进程启动速度慢。
注：两者的运行速度是无与伦比的。

3.序列是一组执行的指令，进程​​是独立的

4个资源的集合。
同一进程中的线程共享相同的数据。

5.创建新线程非常容易，创建新进程需要克隆其父进程。

6.线程可以处理（控制）同一个进程中的其他线程，但进程只能处理子进程

7如果进程想要通信，必须经过中间代理。

8.对序列的修改可能会影响其他序列的行为。
但对父进程的修改不会影响子进程。

第一个程序使用循环创建了一个线程，但是这个程序中有51个线程我们创建了50个线程，但是还有一个程序本身的线程，就是主线程。
51个线程是并行的。
注意：在这个程序中，主线程启动子线程。

与上一个程序相比，这个程序多了一步计算时间，但是当我们观察结果时，我们会发现这个程序显示的执行时间只有0.007秒，这是因为最后一个print函数存在于整个程序的主线程中，所有的子线程都是并行的，因此可以认为，在子线程执行完毕之前，即主线程，当前已经执行了print函数执行。

下一个程序吸收了上面程序的缺点，创建一个列表，将所有线程出现在其中，然后使用for循环对序列中的线程实例调用join方法，这样使得主线程等待所有子线程在下去之前完成执行。
注意试用结果：两个线程的结果都是两秒多一点

注意试用结果，因为打印任务没有执行，程序执行时间很短。

这是因为在主线程启动子线程之前，子线程被设置为守护线程。

只要主线程执行完成，无论子线程是否执行完成，都会终止。
但它会等到非守护线程执行完毕

主线程退出，所有守护线程都被强制退出。
皇帝死后，他的奴隶也被埋葬

应用场景：socket-server

注意：GIL只是为了降低程序开发的复杂度。
但在2.0以上版本中，需要添加用户态锁（GIL缺陷），而在3.0以上版本中，要么加锁，要么不加锁。

下面的程序是一个典型的生产者-消费者模型。

生产者-消费者模型是开发架构中使用的经典模型

运维中的集群就是生产者-消费者模型，生活中大部分都是一样的

那么，多线程的使用场景是什么呢？

python中的多线程本质上就是不断的上下文切换，可以说是伪多线程。
而且我们知道IO操作不占用CPU，而是计算占用CPU所以多线程Python适合IO操作密集型任务，比如socket服务器那么Python是如何处理CPU密集型任务的呢？Python可以利用多个计算机核心的妥协：启动八个进程，每个进程有一个线程。
这样就可以使用多个进程来解决多核问题。

如果想要充分利用多核CPU资源，大多数情况下需要使用多进程，Python提供了多处理包来执行多进程。
多处理支持进程和子进程之间的同步和通信，并提供进程、队列、管道和锁等组件。

打开子进程

Multiprocessing提供了一个Process类来生成流程实例

Process([group[,target[,name[,args[,kwargs]]]]]]）

group组，实际没有使用

target代表调用对象，可以在方法名中发送

args代表提供参数以元组形式传递给调用对象，例如目标是一个函数a，它有两个参数m,n,那么参数为args=(m,n)

kwargs代表调用对象的字典

name是别名。
和给这个进程命名是一的

先举个小例子：

#-*-coding:utf-8-*-

frommultiprocessingimportProcess,Pool

导入

导入时间

defrun_proc(wTime):

n=0

whilen3:

defrun_proc(wTime):

n=0

whilen3:

打印"subProcess%srun,"%os.getpid(),"{0}".format(time.ctime())#获取当前进程号和运行时间

time.sleep(wTime)#等待(睡眠)

n+=1

if__name__=="__main__":

p=Process(target=run_proc,args=(2,))#请求子进程

p.start()#运行流程

打印"Parentprocessrun.subProcessis",p.pid

print"Parentprocessend,{0}".format(time.ctime())

运行结果：

磷arentprocessrun.subProcessis30196

Parentprocessend，MonMar2711：20：212017

subProcess30196run，MonMar2711：20：212017

subProcess30196run,MonMar2711:20:232017

subProcess30196run,MonMar2711:20:252017

从运行结果来看，父进程结束后子进程还在运行，会造成僵尸（僵尸进程）。

通常，当子进程终止时，它会通知父进程，释放其占用的内存，并将自己的退出信息留在内核中。
当父进程得知子进程已经终止时，它会从内核中检索子进程的退出信息。
但是，如果父进程先于子进程终止，则可能会导致子进程退出信息保留在内核中，从而使子进程成为僵尸进程。
当大量僵尸进程积累时，内存空间就会被占用。

有没有办法避免僵尸进程？

这里介绍一下进程的daemon属性，当它的值为TRUE时，父进程就会终止，进程直接终止（即使还没有运行完）。

所以在上面的程序中添加p.deamon=true，看看效果。

#-*-coding:utf-8-*-

frommultiprocessingimportProcess，池

导入

导入时间

defrun_proc(wTime):

n=0

whilen3:

print"subProcess%srun,"%os.getpid(),"{0}".format(时间.ctime())

time.sleep(wTime)

n+=1

if__name__=="__main__":

p=进程(target=run_proc,args=(2,))

p.daemon=True#加入守护进程

p.start()

打印"Parentprocessrun.subProcessis",p.pid

print"Parentprocessend,{0}".format(time.ctime())

执行结果：

Parentprocessrun.subProcessis31856

Parentprocessend,MonMar2711:40:102017

这又是个问题子进程还没有执行完。
有没有办法在子进程执行完毕后终止父进程？

这里引入了p.join()方法，该方法使得父进程只有在子进程执行完毕后才执行后续代码

#-*-coding:utf-8-*-

frommultiprocessingimportProcess，池

导入

导入时间

defrun_proc(wTime)：

n=0

whilen3:

print"subProcess%srun,"%os.getpid(),"{0}".format(time.ctime())

time.sleep(wTime)

n+=1

if__name__=="__main__":

p=Process(target=run_proc,args=(2,))

p.daemon=真

p.start()

p.join()#Join方法

print"Parentprocessrun.subProcessis",p.pid

print"Parentprocessend,{0}".format(time.ctime())

执行结果：

subProcess32076run,MonMar2711:46:072017

subProcess32076run，MonMar2711：46：092017

subProcess32076run，MonMar2711：46：112017

Parentprocessrun.subProcessis32076

Parentprocessend，MonMar2711：46:112017:132017

顺便说一句这样，所有流程就能顺利进行。

结论：以上是CTO头注编译的关于python可以打开的最大进程数的回答总结希望对您有帮助！如果您的问题解决了，请分享给更多关心这个问题的朋友~

如何在python中实现多进程之间的通信?

Python中的多进程通信主要包括共享内存、管道、队列、消息队列（消息队列，如队列模块、multiprocessing.Queue或redis、Rabbitmq等）和数据套接字。
下面对这五种常用的方法进行详细分析。

1.共享内存

共享内存允许不同的进程直接访问同一物理内存区域。
使用multiprocessing.Value和multiprocessing.Array创建共享内存对象。

代码示例：初始化一个整型共享变量并在多次操作中修改其值。

python

importmultiprocessing

shared_var=multiprocessing.Value('i',5)

defworker():withshared_var.get_lock(:print(f"运算符:{共享_var.value}")shared_var.value+=1

if__name__=='main':p=multiprocessing.Process(target=worker)p.start()p.join()

注意，多个进程修改共享内存时必须使用锁来保证线程安全。

2.管道（pipes）

管道支持单向通信，允许数据在多个进程之间单向传输。
管道建​​立后，每个连接都有一个读端和一个写端。

示例代码：创建管道，父进程向子进程发送信息。

python

导入多处理

defwriter(pipe):pipe.send("Hellofromwriter")pipe。
Close()

defreader(pipe):message=pipe.recv()print(f"已收到:{message}")pipe.Close()

if__name__=='main':parent_conn,child_conn=multiprocessing.Pipe()#创建管道p=multiprocessing.Process(target=writer,args=(child_conn,))r=multiprocessing.Process(target=reader,args=(parent_conn,))

父进程将信息发送给子进程，然后关闭管道，并接收子进程打印信息并打印出来。

3.队列（Queue）

队列提供​​数据的安全存储和交换。
使用multiprocessing.Queue创建一个可以被多个进程共享的队列。

代码示例：在生产者进程和消费者进程之间传输数据。

python

importmultiprocessing

defProducer(queue):foriinrange(5):queue.put(i)print(f"生产:{i}")

defconsumer(queue):whileTrue:item=queue.get()ifitemisNone:breakprint(f"消耗:{item}")

if__name__=='main':queue=multiprocessing.Queue()p=multiprocessing.Process(target=生产者,args=(queue,))c=multiprocessing.Process(target=Consumer,args=(queue,))

生产者将数排队，消费者输出数据并消费。

4.消息队列（MessageQueue）

标准库的队列模块提供了简单的消息队列功能。
在大型项目中经常使用外部服务，例如RabbitMQ或Redis作为消息队列系统。

示例代码：使用pika库运行RabbitMQ。

首先安装Pika库：bashpipinstallpika

示例代码：启动消费者监听队列并接收消息。

python

importpika

connection=pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))channel=connection.channel()

defcallback(ch,方法,属性,body):print("[x]已收到%r"%body)

channel.basic_consume(queue='hello',on_message_callback=callback,auto_ack=True)

print('[*]Waitingformessages.ToexitpressCTRL+C')channel.start_consume()

主程序启动消费者监听队列，接收并打印消息。

5.数据套接字

使用Python的socket模块实现多进程通信。
该方法支持复杂的数据传输。

示例代码：服务器端创建一个socket并等待客户端连接并接收数据。

Python

importsocket

server_socket=socket.socket(socket.AF_INET,socket.SOCK_STR)EAM)

server_socket.bind(('localhost',8000))

server_socket.listen(5)

whileTrue:

conn,addr=server_socket.accept()

data=conn.recv(1024)

print(f"已收到：{data.decode()}")

康涅狄格州。
Close()

总之，Python提供了多种多进程通信方式，开发者应该根据高效可靠的进程间通信的实际需求进行选择。
确保同步和线程安全至关重要。