ℹ️ Skipped - page is already crawled
| Filter | Status | Condition | Details |
|---|---|---|---|
| HTTP status | PASS | download_http_code = 200 | HTTP 200 |
| Age cutoff | FAIL | download_stamp > now() - 6 MONTH | 8.6 months ago |
| History drop | PASS | isNull(history_drop_reason) | No drop reason |
| Spam/ban | PASS | fh_dont_index != 1 AND ml_spam_score = 0 | ml_spam_score=0 |
| Canonical | PASS | meta_canonical IS NULL OR = '' OR = src_unparsed | Not set |
| Property | Value |
|---|---|
| URL | https://blog.csdn.net/u010660276/article/details/50570289 |
| Last Crawled | 2025-07-27 15:19:32 (8 months ago) |
| First Indexed | 2018-09-27 23:49:12 (7 years ago) |
| HTTP Status Code | 200 |
| Meta Title | python多进程_python process terminate 和 kill的如何区分使用-CSDN博客 |
| Meta Description | 文章浏览阅读916次。Unix/Linux操作系统提供了一个fork()系统调用,它非常特殊。普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回。子进程永远返回0,而父进程返回子进程的ID。这样做的理由是,一个父进程可以fork出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用getp_python process terminate 和 kill的如何区分使用 |
| Meta Canonical | null |
| Boilerpipe Text | Unix/Linux操作系统提供了一个fork()系统调用,它非常特殊。普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回。 子进程永远返回0,而父进程返回子进程的ID。这样做的理由是,一个父进程可以fork出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用getppid()就可以拿到父进程的ID。 Python的os模块封装了常见的系统调用,其中就包括fork,可以在Python程序中轻松创建子进程: import os print ( 'Process (%s) start...' % os .getpid())
# Only works on Unix/Linux/Mac:
pid = os .fork()
if pid == 0 :
print ( 'I am child process (%s) and my parent is %s.' % ( os .getpid(), os .getppid()))
else :
print ( 'I (%s) just created a child process (%s).' % ( os .getpid(), pid)) 由于Windows没有fork调用,上面的代码在Windows上无法运行。由于Mac系统是基于BSD(Unix的一种)内核,所以,在Mac下运行是没有问题的,推荐大家用Mac学Python! 有了fork调用,一个进程在接到新任务时就可以复制出一个子进程来处理新任务,常见的Apache服务器就是由父进程监听端口,每当有新的http请求时,就fork出子进程来处理新的http请求。 multiprocessing 如果你打算编写多进程的服务程序,Unix/Linux无疑是正确的选择。由于Windows没有fork调用,难道在Windows上无法用Python编写多进程的程序? 由于Python是跨平台的,自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。 multiprocessing模块提供了一个Process类来代表一个进程对象,下面的例子演示了启动一个子进程并等待其结束: __author__ = 'gaoqingjin' from multiprocessing import Process
from time import sleep
import os
def run_function (name) :
print( 'Run child process %s (%s)' % (name,os.getpid()))
sleep( 1 )
if __name__== '__main__' :
print( 'Parent process %s.' % os.getpid())
p=Process(target=run_function,args=( 'test' ,))
print( 'Child process will start.' )
p.start()
p.join()
print( 'Child process end.' ) 创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process实例,用start()方法启动,这样创建进程比fork()还要简单。 join()方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。 Pool 如果要启动大量的子进程,可以用进程池的方式批量创建子进程:
Pool可以提供指定数量的进程,供用户调用,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到规定最大值,那么该请求就会等待,直到池中有进程结束,才会创建新的进程来它。这里有一个简单的例子: from multiprocessing import Pool
import os,time,random
def long_time_task (name) :
print( 'Run task %s (%s)' % (name,os.getpid()))
start=time.time()
time.sleep(random.random()* 3 )
end=time.time()
print( 'Task %s run %0.2f seconds.' % (name,(end-start)))
if __name__== '__main__' :
print( 'Parent process %s.' % os.getpid())
p=Pool( 4 )
for i in range( 5 ):
p.apply_async(long_time_task,args=(i,))
print( 'Waiting for all subprocess done...' )
p.close()
p.join()
print( 'All subprocess done.' ) 执行结果: Parent process 1180.
Waiting for all subprocess done...
Run task 0 ( 7452 )
Run task 1 ( 4336 )
Run task 2 ( 7720 )
Run task 3 ( 8600 )
Task 1 run 0.79 seconds .
Run task 4 ( 4336 )
Task 4 run 0.16 seconds .
Task 0 run 1.00 seconds .
Task 3 run 1.11 seconds .
Task 2 run 2.79 seconds .
All subprocess done.
Sucess pool.apply_async()用来向进程池提交目标请求,pool.join()是用来等待进程池中的worker进程执行完毕,防止主进程在worker进程结束前结束。但必pool.join()必须使用在pool.close()或者pool.terminate()之后。其中close()跟terminate()的区别在于close()会等待池中的worker进程执行结束再关闭pool,而terminate()则是直接关闭。result.successful()表示整个调用执行的状态,如果还有worker没有执行完,则会抛出AssertionError异常。对Pool对象调用join()方法会等待所有子进程执行完毕,调用join()之前必须先调用close(),调用close()之后就不能继续添加新的Process了。 请注意输出的结果,task 0,1,2,3是立刻执行的,而task 4要等待前面某个task完成后才执行,这是因为Pool的默认大小在我的电脑上是4,因此,最多同时执行4个进程。这是Pool有意设计的限制,并不是操作系统的限制。如果改成: p = Pool(5) 就可以同时跑5个进程。 由于Pool的默认大小是CPU的核数,如果你不幸拥有8核CPU,你要提交至少9个子进程才能看到上面的等待效果。 子进程 很多时候,子进程并不是自身,而是一个外部进程。我们创建了子进程后,还需要控制子进程的输入和输出。 subprocess模块可以让我们非常方便地启动一个子进程,然后控制其输入和输出。 下面的例子演示了如何在Python代码中运行命令nslookup www.python.org,这和命令行直接运行的效果是一样的: import subprocess
print( '$ nslookup www.python.org' )
r=subprocess.call([ 'nslookup' , 'www.python.org' ])
print( 'Exit code: ' ,r) 运行结果: $ nslookup www .python .org
非权威应答:
服务器: linedns .bta .net .cn Address: 202.106 .196 .115
名称: python .map .fastly .net Address: 103.245 .222 .223 Aliases: www .python .org
Exit code: 0 如果子进程还需要输入,则可以通过communicate()方法输入: import subprocess
print( '$ nslookup' )
p=subprocess.Popen([ 'nslookup' ],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
output,err=p.communicate( b'set q=mx\npython.org\nexit\n' )
print(output)
print( 'Exit code: ' ,p.returncode) Popen.poll()
检查子进程是否已结束,设置并返回returncode属性。
Popen.wait()
等待子进程结束,设置并返回returncode属性。
Popen.send_signal(signal)
给子进程发送signal信号。
注意:windows下目前只支持发送SIGTERM,等效于下面的terminate() 。 Popen.terminate()
停止子进程。Posix下是发送SIGTERM信号。windows下是调用TerminateProcess()这个API。 Popen.kill()
杀死子进程。Posix下是发送SIGKILL信号。windows下和terminate() 无异。 Popen.stdin
如果stdin 参数是PIPE,此属性就是一个文件对象,否则为None 。 Popen.stdout
如果stdout参数是PIPE,此属性就是一个文件对象,否则为None 。 Popen.stderr
如果stderr 参数是PIPE,此属性就是一个文件对象,否则为None 。
Popen.returncode
子程序的返回值,由poll()或者wait()设置,间接地也由communicate()设置。
如果为None,表示子进程还没终止。
如果为负数-N的话,表示子进程被N号信号终止。(仅限*nux) 进程间通信 Process之间肯定是需要通信的,操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制,提供了Queue、Pipes等多种方式来交换数据。 我们以Queue为例,在父进程中创建两个子进程,一个往Queue里写数据,一个从Queue里读数据: from multiprocessing import Process,Queue
import os,time,random
def write (q) :
print( 'Process to write: %s' % os.getpid())
for value in [ 'a' , 'b' , 'c' ]:
print( 'Put %s to queue.' % value)
q.put(value)
time.sleep(random.random())
def read (q) :
print( 'Process to read: %s.' % os.getpid())
while True :
value=q.get( True )
print( 'Get %s from queue.' % value)
if __name__== '__main__' :
q=Queue()
pw=Process(target=write,args=(q,))
pr=Process(target=read,args=(q,))
pw.start()
pr.start()
pw.join()
pr.terminate() 运行结果: Process to write : 2484
Put a to queue.
Process to read : 236.
Get a from queue.
Put b to queue.
Put c to queue.
Get b from queue.
Get c from queue. 在Unix/Linux下,multiprocessing模块封装了fork()调用,使我们不需要关注fork()的细节。由于Windows没有fork调用,因此,multiprocessing需要“模拟”出fork的效果,父进程所有Python对象都必须通过pickle序列化再传到子进程去,所有,如果multiprocessing在Windows下调用失败了,要先考虑是不是pickle失败了。 小结 在Unix/Linux下,可以使用fork()调用实现多进程。 要实现跨平台的多进程,可以使用multiprocessing模块。 进程间通信是通过Queue、Pipes等实现的。 |
| Markdown | # python多进程
最新推荐文章于 2023-11-02 11:33:07 发布

[u010660276](https://blog.csdn.net/u010660276 "u010660276")  最新推荐文章于 2023-11-02 11:33:07 发布
 阅读量916 [  收藏]()
  点赞数
分类专栏: [python](https://blog.csdn.net/u010660276/category_5702151.html)
[ python 专栏收录该内容](https://blog.csdn.net/u010660276/category_5702151.html "python")
27 篇文章
[订阅专栏]()
Unix/Linux操作系统提供了一个fork()系统调用,它非常特殊。普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回。
子进程永远返回0,而父进程返回子进程的ID。这样做的理由是,一个父进程可以fork出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用getppid()就可以拿到父进程的ID。
Python的os模块封装了常见的系统调用,其中就包括fork,可以在Python程序中轻松创建子进程:
```
import os
print('Process (%s) start...' % os.getpid())
# Only works on Unix/Linux/Mac:
pid = os.fork()
if pid == 0:
print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
print('I (%s) just created a child process (%s).' % (os.getpid(), pid))
```
由于Windows没有fork调用,上面的代码在Windows上无法运行。由于Mac系统是基于BSD(Unix的一种)内核,所以,在Mac下运行是没有问题的,推荐大家用Mac学Python!
有了fork调用,一个进程在接到新任务时就可以复制出一个子进程来处理新任务,常见的Apache服务器就是由父进程监听端口,每当有新的http请求时,就fork出子进程来处理新的http请求。
**multiprocessing**
如果你打算编写多进程的服务程序,Unix/Linux无疑是正确的选择。由于Windows没有fork调用,难道在Windows上无法用Python编写多进程的程序?
由于Python是跨平台的,自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。
multiprocessing模块提供了一个Process类来代表一个进程对象,下面的例子演示了启动一个子进程并等待其结束:
```
__author__ = 'gaoqingjin'
# encode='utf-8'
from multiprocessing import Process
from time import sleep
import os
def run_function(name):
print('Run child process %s (%s)' % (name,os.getpid()))
sleep(1)
if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p=Process(target=run_function,args=('test',))
print('Child process will start.')
p.start()
p.join()
print('Child process end.')
```
创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process实例,用start()方法启动,这样创建进程比fork()还要简单。
join()方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。
**Pool**
如果要启动大量的子进程,可以用进程池的方式批量创建子进程:
Pool可以提供指定数量的进程,供用户调用,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到规定最大值,那么该请求就会等待,直到池中有进程结束,才会创建新的进程来它。这里有一个简单的例子:
```
from multiprocessing import Pool
import os,time,random
def long_time_task(name):
print('Run task %s (%s)' % (name,os.getpid()))
start=time.time()
time.sleep(random.random()*3)
end=time.time()
print('Task %s run %0.2f seconds.' % (name,(end-start)))
if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p=Pool(4)
for i in range(5):
p.apply_async(long_time_task,args=(i,))
print('Waiting for all subprocess done...')
p.close()
p.join()
print('All subprocess done.')
```
执行结果:
```
Parent process 1180.
Waiting for all subprocess done...
Run task 0 (7452)
Run task 1 (4336)
Run task 2 (7720)
Run task 3 (8600)
Task 1 run 0.79 seconds.
Run task 4 (4336)
Task 4 run 0.16 seconds.
Task 0 run 1.00 seconds.
Task 3 run 1.11 seconds.
Task 2 run 2.79 seconds.
All subprocess done.
Sucess
```
pool.apply\_async()用来向进程池提交目标请求,pool.join()是用来等待进程池中的worker进程执行完毕,防止主进程在worker进程结束前结束。但必pool.join()必须使用在pool.close()或者pool.terminate()之后。其中close()跟terminate()的区别在于close()会等待池中的worker进程执行结束再关闭pool,而terminate()则是直接关闭。result.successful()表示整个调用执行的状态,如果还有worker没有执行完,则会抛出AssertionError异常。对Pool对象调用join()方法会等待所有子进程执行完毕,调用join()之前必须先调用close(),调用close()之后就不能继续添加新的Process了。
请注意输出的结果,task 0,1,2,3是立刻执行的,而task 4要等待前面某个task完成后才执行,这是因为Pool的默认大小在我的电脑上是4,因此,最多同时执行4个进程。这是Pool有意设计的限制,并不是操作系统的限制。如果改成:
```
p = Pool(5)
```
就可以同时跑5个进程。
由于Pool的默认大小是CPU的核数,如果你不幸拥有8核CPU,你要提交至少9个子进程才能看到上面的等待效果。
**子进程**
很多时候,子进程并不是自身,而是一个外部进程。我们创建了子进程后,还需要控制子进程的输入和输出。
subprocess模块可以让我们非常方便地启动一个子进程,然后控制其输入和输出。
下面的例子演示了如何在Python代码中运行命令nslookup www.python.org,这和命令行直接运行的效果是一样的:
```
import subprocess
print('$ nslookup www.python.org')
r=subprocess.call(['nslookup','www.python.org'])
print('Exit code: ',r)
```
运行结果:
```
$ nslookup www.python.org
非权威应答:
服务器: linedns.bta.net.cn
Address: 202.106.196.115
名称: python.map.fastly.net
Address: 103.245.222.223
Aliases: www.python.org
Exit code: 0
```
如果子进程还需要输入,则可以通过communicate()方法输入:
```
import subprocess
print('$ nslookup')
p=subprocess.Popen(['nslookup'],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
output,err=p.communicate(b'set q=mx\npython.org\nexit\n')
print(output)
print('Exit code: ',p.returncode)
```
Popen.poll()
检查子进程是否已结束,设置并返回returncode属性。
Popen.wait()
等待子进程结束,设置并返回returncode属性。
Popen.send\_signal(signal)
给子进程发送signal信号。
注意:windows下目前只支持发送SIGTERM,等效于下面的terminate() 。
Popen.terminate()
停止子进程。Posix下是发送SIGTERM信号。windows下是调用TerminateProcess()这个API。
Popen.kill()
杀死子进程。Posix下是发送SIGKILL信号。windows下和terminate() 无异。
Popen.stdin
如果stdin 参数是PIPE,此属性就是一个文件对象,否则为None 。
Popen.stdout
如果stdout参数是PIPE,此属性就是一个文件对象,否则为None 。
Popen.stderr
如果stderr 参数是PIPE,此属性就是一个文件对象,否则为None 。
Popen.returncode
子程序的返回值,由poll()或者wait()设置,间接地也由communicate()设置。
如果为None,表示子进程还没终止。
如果为负数-N的话,表示子进程被N号信号终止。(仅限\*nux)
**进程间通信**
Process之间肯定是需要通信的,操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制,提供了Queue、Pipes等多种方式来交换数据。
我们以Queue为例,在父进程中创建两个子进程,一个往Queue里写数据,一个从Queue里读数据:
```
from multiprocessing import Process,Queue
import os,time,random
def write(q):
print('Process to write: %s' % os.getpid())
for value in ['a','b','c']:
print('Put %s to queue.' % value)
q.put(value)
time.sleep(random.random())
def read(q):
print('Process to read: %s.' % os.getpid())
while True:
value=q.get(True)
print('Get %s from queue.' % value)
if __name__=='__main__':
q=Queue()
pw=Process(target=write,args=(q,))
pr=Process(target=read,args=(q,))
pw.start()
pr.start()
pw.join()
pr.terminate()
```
运行结果:
```
Process to write: 2484
Put a to queue.
Process to read: 236.
Get a from queue.
Put b to queue.
Put c to queue.
Get b from queue.
Get c from queue.
```
在Unix/Linux下,multiprocessing模块封装了fork()调用,使我们不需要关注fork()的细节。由于Windows没有fork调用,因此,multiprocessing需要“模拟”出fork的效果,父进程所有Python对象都必须通过pickle序列化再传到子进程去,所有,如果multiprocessing在Windows下调用失败了,要先考虑是不是pickle失败了。
**小结**
在Unix/Linux下,可以使用fork()调用实现多进程。
要实现跨平台的多进程,可以使用multiprocessing模块。
进程间通信是通过Queue、Pipes等实现的。

确定要放弃本次机会?
福利倒计时
*:* *:*
 立减 ¥
普通VIP年卡可用
[立即使用](https://mall.csdn.net/vip)
[ u010660276](https://blog.csdn.net/u010660276)
[关注]() [关注]()
- [   0]()
点赞
- [ ]()
踩
- [   0]()
收藏
觉得还不错? 一键收藏 
- 
知道了
[ 0](https://blog.csdn.net/u010660276/article/details/50570289#commentBox)
评论
- [ 分享]()
[复制链接]()
[分享到 QQ]()
[分享到新浪微博]()
扫一扫
- []()
[ 举报]()
[ 举报]()
[专栏目录]()
[*Python*小工具:查看进程与杀死进程](https://blog.csdn.net/JimboYan/article/details/141503764)
[JimboYan的博客](https://blog.csdn.net/JimboYan)
08-24  629
[Ubuntu环境下经常能遇到清除pid的工作,后面可以试试我这个小工具啦~输入一个进程名称或关键字,展示与输入相关的进程信息,按需杀死进程。废话不多说,直接上才艺。](https://blog.csdn.net/JimboYan/article/details/141503764)
[*python**多进程*之进程的*terminate*() 函数](https://blog.csdn.net/m0_50481455/article/details/113749690)
[m0\_50481455的博客](https://blog.csdn.net/m0_50481455)
02-07  9673
[*python**多进程*之进程的*terminate*() 函数 *terminate*() 函数 是用来杀死子进程的 举例如下: from multi*process*ing import *Process* import time def task(name): print(f"{name} is running") time.sleep(2) print(f"{name} is gone") if \_\_name\_\_ == "\_\_main\_\_": \# 在windows环境下,开启进程必须](https://blog.csdn.net/m0_50481455/article/details/113749690)
参与评论 您还未登录,请先 登录 后发表或查看评论
[*Python* 多线程的退出/停止的一种是实现思路 热门推荐](https://blog.csdn.net/lccever/article/details/100119364)
[lccever的博客](https://blog.csdn.net/lccever)
08-28  1万+
[在*使用*多线程的过程中,我们知道,*python*的线程是没有stop/*terminate*方法的,也就是说它被启动后,你无法再主动去退出它,除非主进程退出了,注意,是主进程,不是线程的父进程. 一个比较合理的方式就是把原因需要放到threading.Thread的target中的线程函数,改写到一个继承类中,下面是一个实现例子 import threading import time imp...](https://blog.csdn.net/lccever/article/details/100119364)
[*python* from multi*process*ing import Pool,*Process*,Value,Array,Manager](https://blog.csdn.net/qq_30595231/article/details/50899640)
[Alof](https://blog.csdn.net/qq_30595231)
03-15  1991
[from multi*process*ing import Pool,*Process*,Value,Array,Manager import time import os def f(x): time.sleep(0.5) print(x) return x\*x \#窜行 print map(f,\[1,2,3\])\#map if \_\_name\_\_ == '\_\_main\_\_':](https://blog.csdn.net/qq_30595231/article/details/50899640)
[【*python*3】from multi*process*ing import *Process* 在window导入错误,源代码在linux 上是可以执行的](https://blog.csdn.net/doris_9800/article/details/105317032)
[甜芯玉米](https://blog.csdn.net/doris_9800)
04-04  2455
[multi*process*ing 模块导入创建进程。我在Linux 运行,完全没问题: from multi*process*ing import *Process* import time def foo(): print("hello") time.sleep(2) p = *Process*(target=foo) p.start() 以上的代码我...](https://blog.csdn.net/doris_9800/article/details/105317032)
[*python* *多进程*](https://download.csdn.net/download/weixin_41486636/11014331)
03-12
[*Python*程序实现*多进程*(multi*process*ing)在Unix/Linux下,multi*process*ing模块封装了fork()调用,使我们不需要关注fork()的细节。由于Windows没有fork调用,因此,multi*process*ing需要“模拟”出fork的效果,父进程...](https://download.csdn.net/download/weixin_41486636/11014331)
[*python**多进程*实现文件下载传输功能](https://download.csdn.net/download/weixin_38604916/12867393)
09-20
[\- \`if \_\_name\_\_ == "\_\_main\_\_":\`语句用于确保\`main()\`函数只在脚本直接运行时执行,而不是被其他模块导入时执行,这是*Python**多进程*程序的常见模式。 综上所述,这个*Python*程序利用*多进程*实现了文件夹及其内部文件...](https://download.csdn.net/download/weixin_38604916/12867393)
[*python**多进程*重复加载的解决方式](https://download.csdn.net/download/weixin_38523618/12857238)
09-18
[根据给定的内容,我们可以了解到解决*Python**多进程*重复加载问题的一种常见方法是将耗资源的加载操作封装在函数或者类中。这样做能够避免每次进程启动时都重新加载资源,因为*Python*的*多进程*是通过fork机制来实现的,当...](https://download.csdn.net/download/weixin_38523618/12857238)
[*Python**多进程*写入同一文件的方法](https://download.csdn.net/download/weixin_38660327/12865132)
09-19
[在*Python*编程中,有时我们需要处理大量...总的来说,*Python**多进程*写入同一文件时,可以通过*使用*锁或回调函数来解决并发访问带来的问题。在实际应用中,应根据具体情况选择合适的方法,同时注意跨平台兼容性*和*性能优化。](https://download.csdn.net/download/weixin_38660327/12865132)
[*python**多进程*访问多个摄像头](https://download.csdn.net/download/weixin_38720762/13739690)
12-20
[在*Python*编程中,*多进程*是一种常见的并发执行方式,尤其在处理资源密集型任务时,如访问多个摄像头。本文将深入探讨如何*使用**Python*的*多进程**和*OpenCV库来同时读取*和*处理多个摄像头的视频流。 首先,我们看到代码中...](https://download.csdn.net/download/weixin_38720762/13739690)
[【*Python**多进程*,通过from multi*process*ing import *Process*实现,需要多个独立的数据,更推荐进程池map 】 最新发布](https://blog.csdn.net/weixin_44162814/article/details/134178424)
[weixin\_44162814的博客](https://blog.csdn.net/weixin_44162814)
11-02  136
[前提知识: 进程是*python*中最小的资源分配单元,也就是进程中间的数据,内存是不共享的,每启动一个进程,都要独立分配资源*和*拷贝访问的数据,所以进程的启动*和*销毁的代价是比较大了,下面这个方法就是每个进程都需要copy一份数据,占内存大。总结:1.进程池map(第二种方法)适合爬虫爬取多个链接*和*处理多个图片数据。作用的是可迭代对象里面的每一个子元素。2.第一种方法*多进程*需要用到多份数据,占较多内存。](https://blog.csdn.net/weixin_44162814/article/details/134178424)
[*python**多进程*的理解 multi*process*ing *Process* join run](https://blog.csdn.net/weixin_30641465/article/details/95800429)
[weixin\_30641465的博客](https://blog.csdn.net/weixin_30641465)
05-05  250
[最近看了下*多进程*。 一种接近底层的实现方法是*使用* os.fork()方法,fork出子进程。但是这样做事有局限性的。比如windows的os模块里面没有 fork() 方法。 windows:。linux: 另外还有一个模块:sub*process*。这个没整过,但从vamei的博客里看到说也同样有局限性。 所以直接说主角吧 --- multi*process*ing模块。 multipro...](https://blog.csdn.net/weixin_30641465/article/details/95800429)
[多任务——进程](https://blog.csdn.net/weixin_30765505/article/details/98753385)
[weixin\_30765505的博客](https://blog.csdn.net/weixin_30765505)
11-26  222
[多任务 多任务:操作系统可以同时运行多个任务 并行:任务数小于cpu核数,任务一起执行 并发:任务数多于cpu核数,通过操作系统的各种任务调度算法,实现多个任务一起执行 进程 进程:操作系统分配资源*和*调度的单位,是一个执行中的程序,是资源分配最小单位 进程的创建:multi*process*ing模块就是跨平台版本的*多进程*模块,提供了一个*Process*类来创建进程对象 fr...](https://blog.csdn.net/weixin_30765505/article/details/98753385)
[*python* 进程的*使用*、multi*process*ing、*Process*](https://blog.csdn.net/yanhuatangtang/article/details/75249615)
[有塔耶奥多的专栏](https://blog.csdn.net/yanhuatangtang)
07-17  1546
[并行:看上去一起执行 并发:实际上一起执行 编写完毕的代码,在没有运行之前称为程序 正在运行的代码,就称为进程 import os ret=os.fork()\#linux平台有,window中没有,window*使用*mulit*process*ing 这里返回两个值:父子进程都会返回,父进程返回子进程的id,子进程返回0 主进程ret\>0 ret为子进程创建的pid getpi](https://blog.csdn.net/yanhuatangtang/article/details/75249615)
[*python*中*多进程*(multi*process*ing)](https://blog.csdn.net/weixin_30337157/article/details/97281146)
[weixin\_30337157的博客](https://blog.csdn.net/weixin_30337157)
09-01  297
[一、multi*process*ing中*使用*子进程概念 from multi*process*ing import *Process* 可以通过*Process*来构造一个子进程 p = *Process*(target=fun,args=(args)) 再通过p.start()来启动子进程 再通过p.join()方法来使得子进程运行结束后再执行父进程 from multipr...](https://blog.csdn.net/weixin_30337157/article/details/97281146)
[创建*多进程*之multi*process*包中的*process*模块](https://blog.csdn.net/diaoshou6264/article/details/101636414)
09-12  421
[创建*多进程*之multi*process*包中的*process*模块 1.*process*模块是一个创建进程的模块 *Process*(\[group \[, target \[, name \[, args \[, kwargs\]\]\]\]\]) 由该类实例化得到的对象,表示一个子进程中任务 强调: 需要*使用*关键字的方式来指定参数 args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号 ...](https://blog.csdn.net/diaoshou6264/article/details/101636414)
[*Python* *Process* *多进程* multi*process*ing](https://walle.blog.csdn.net/article/details/80545524)
[易水寒](https://blog.csdn.net/fox64194167)
06-02  670
[《*Python* 多线程》 可以跟这篇文章进行比较 from multi*process*ing import *Process* import time def work(x, n): print(x) time.sleep(2) print(n) def otherWork(x, n): print(x) time.sleep(2) print...](https://walle.blog.csdn.net/article/details/80545524)
[*Python*入门之——进程multi*process*ing(*Process* 类)简介](https://devpress.csdn.net/v1/article/detail/115618017)
[肥叔菌的博客](https://blog.csdn.net/asmartkiller)
04-12  8411
[os.fork()方法:创建新进程 要知道,每个 *Python* 程序在执行时,系统都会生成一个新的进程,该进程又称父进程(或主进程)。在此基础上,*Python* os 模块还提供有 fork() 函数,该函数可以在当前程序中再创建出一个进程(又称子进程)。也就是说,程序中通过引入 os 模块,并调用其提供的 fork() 函数,程序中会拥有 2 个进程,其中父进程负责执行整个程序代码,而通过 fork() 函数创建出的子进程,会从创建位置开始,执行后续所有的程序(包含创建子进程的代码)。 注意,os.fork](https://devpress.csdn.net/v1/article/detail/115618017)
[](https://blog.csdn.net/u010660276)
[u010660276](https://blog.csdn.net/u010660276 "u010660276")
博客等级 
码龄12年
[946 原创](https://blog.csdn.net/u010660276)
210
点赞
556
收藏
100
粉丝
[关注]()
[私信](https://im.csdn.net/chat/u010660276)
[](https://marketing.csdn.net/p/cae4122b7723eed7ae0db5e1e5390990%20)
[](https://ai.csdn.net/homework?utm_source=2048390893)
[](https://mpbeta.csdn.net/edit?utm_source=blog)
### 热门文章
- [Docker Daemon  39097](https://blog.csdn.net/u010660276/article/details/82049750)
- [最佳路径算法总结  9623](https://blog.csdn.net/u010660276/article/details/9841825)
- [树分治(点分治模板)poj-1741 Tree  7092](https://blog.csdn.net/u010660276/article/details/44920725)
- [java Label  5564](https://blog.csdn.net/u010660276/article/details/12207183)
- [OpenGL中点算法画圆弧、内接多边形算法画圆  5532](https://blog.csdn.net/u010660276/article/details/48649529)
### 分类专栏
- [ DFS](https://blog.csdn.net/u010660276/category_1543457.html)
40篇
- [ BFS](https://blog.csdn.net/u010660276/category_1543459.html)
23篇
- [ 背包](https://blog.csdn.net/u010660276/category_1543657.html)
15篇
- [ RMQ](https://blog.csdn.net/u010660276/category_1546129.html)
9篇
- [ 最小生成树](https://blog.csdn.net/u010660276/category_1548967.html)
18篇
- [ 树状数组/线段树](https://blog.csdn.net/u010660276/category_1552413.html)
143篇
- [ 最佳路径](https://blog.csdn.net/u010660276/category_1552789.html)
52篇
- [ 二分图](https://blog.csdn.net/u010660276/category_1558771.html)
19篇
- [ 网络流](https://blog.csdn.net/u010660276/category_1559417.html)
31篇
- [ KMP](https://blog.csdn.net/u010660276/category_1562283.html)
16篇
- [ 图的连通性](https://blog.csdn.net/u010660276/category_1566357.html)
23篇
- [ 字典树\|Trie树\|前缀树](https://blog.csdn.net/u010660276/category_1581911.html)
29篇
- [ codeforces](https://blog.csdn.net/u010660276/category_1614221.html)
91篇
- [ 动态规划](https://blog.csdn.net/u010660276/category_1620099.html)
121篇
- [ c++](https://blog.csdn.net/u010660276/category_1644585.html)
28篇
- [ 二分搜索](https://blog.csdn.net/u010660276/category_1644637.html)
51篇
- [ java](https://blog.csdn.net/u010660276/category_1660833.html)
27篇
- [ 贪心](https://blog.csdn.net/u010660276/category_1661945.html)
23篇
- [ 矩阵快速幂](https://blog.csdn.net/u010660276/category_1662107.html)
20篇
- [ 数据结构](https://blog.csdn.net/u010660276/category_1665077.html)
67篇
- [ 常用技巧](https://blog.csdn.net/u010660276/category_1772451.html)
91篇
- [ 差分约束系统](https://blog.csdn.net/u010660276/category_1818359.html)
3篇
- [ 后缀数组](https://blog.csdn.net/u010660276/category_1924685.html)
26篇
- [ 位运算](https://blog.csdn.net/u010660276/category_2136359.html)
3篇
- [ AC自动机](https://blog.csdn.net/u010660276/category_2141211.html)
28篇
- [ 拓扑排序](https://blog.csdn.net/u010660276/category_2317267.html)
7篇
- [ 数学](https://blog.csdn.net/u010660276/category_2327303.html)
50篇
- [ 欧拉回路](https://blog.csdn.net/u010660276/category_2364665.html)
6篇
- [ 图论](https://blog.csdn.net/u010660276/category_2367025.html)
13篇
- [ 字符串](https://blog.csdn.net/u010660276/category_2388191.html)
43篇
- [ LCA](https://blog.csdn.net/u010660276/category_2467091.html)
18篇
- [ 划分树](https://blog.csdn.net/u010660276/category_2500187.html)
4篇
- [ 主席树](https://blog.csdn.net/u010660276/category_2566335.html)
8篇
- [ 字符串hash](https://blog.csdn.net/u010660276/category_2596857.html)
10篇
- [ Dancing Links](https://blog.csdn.net/u010660276/category_2607781.html)
11篇
- [ Splay](https://blog.csdn.net/u010660276/category_2627247.html)
21篇
- [ 训练指南第一章](https://blog.csdn.net/u010660276/category_2675609.html)
5篇
- [ 高斯消元](https://blog.csdn.net/u010660276/category_2782861.html)
11篇
- [ 后缀自动机SAM](https://blog.csdn.net/u010660276/category_2806229.html)
9篇
- [ 树链剖分](https://blog.csdn.net/u010660276/category_2827451.html)
15篇
- [ treap](https://blog.csdn.net/u010660276/category_2889129.html)
9篇
- [ 平衡二叉树SBT](https://blog.csdn.net/u010660276/category_2889131.html)
7篇
- [ 左偏树](https://blog.csdn.net/u010660276/category_2920033.html)
3篇
- [ 替罪羊树](https://blog.csdn.net/u010660276/category_2924999.html)
1篇
- [ k-d树](https://blog.csdn.net/u010660276/category_2949277.html)
- [ 动态树LCT](https://blog.csdn.net/u010660276/category_3034259.html)
10篇
- [ 树分治](https://blog.csdn.net/u010660276/category_3087445.html)
7篇
- [ 分块数据结构](https://blog.csdn.net/u010660276/category_3244269.html)
6篇
- [ 莫队算法](https://blog.csdn.net/u010660276/category_5354447.html)
4篇
- [ 数位dp](https://blog.csdn.net/u010660276/category_5591295.html)
19篇
- [ python](https://blog.csdn.net/u010660276/category_5702151.html)
27篇
- [ 一般图匹配带花树](https://blog.csdn.net/u010660276/category_5768297.html)
3篇
- [ Linux](https://blog.csdn.net/u010660276/category_5941213.html)
6篇
- [ Hadoop](https://blog.csdn.net/u010660276/category_6142324.html)
10篇
- [ Docker](https://blog.csdn.net/u010660276/category_7883264.html)
4篇
- [ leetcode](https://blog.csdn.net/u010660276/category_7885462.html)
2篇
- [ 机器学习](https://blog.csdn.net/u010660276/category_8811252.html)
5篇
[展开全部 ]() [收起 ]()
上一篇:
[pyhton序列化](https://blog.csdn.net/u010660276/article/details/50382701)
下一篇:
[python ThreadLocal](https://blog.csdn.net/u010660276/article/details/50574180)
### 最新评论
- [Docker Daemon](https://blog.csdn.net/u010660276/article/details/82049750#comments_10407031)
[陈新月-Phyllis:](https://blog.csdn.net/csxypr) 感谢博主的分享,这个experimental是配置什么的呢?
- [树uva112](https://blog.csdn.net/u010660276/article/details/20489627#comments_8840573)
[J\_Baymax:](https://blog.csdn.net/J_Baymax) 交上去编译错误丫,楼主
- [重启之战](https://blog.csdn.net/u010660276/article/details/81255582#comments_8823433)
[Mr.Gzj:](https://blog.csdn.net/Endeavor_G) 大佬在做啥呢
- [后缀数组(好)uva10829](https://blog.csdn.net/u010660276/article/details/39274111#comments_8714294)
[同人于郊:](https://blog.csdn.net/nicdai) 为什么是len-1个字串符合条件呀?len是长度,答案求的是种数,想了好久,没弄明白
- [codeforces215 E. Periodical Numbers(数位dp)](https://blog.csdn.net/u010660276/article/details/46793279#comments_8431579)
[pxlsdz:](https://pxlsdz.blog.csdn.net/) x-(1\<\<(k-1))+1/\*此处加1是因为全0的原因\*/-(y\>m) 能解释下这个语句吗
### 大家在看
- [【CVPR2025】计算机视觉\|ORTrack:让无人机跟踪无惧遮挡!  447](https://blog.csdn.net/m0_51665349/article/details/149673158)
- [最后一个单词的长度和加一练习-leetCode](https://blog.csdn.net/2501_91344547/article/details/149697666)
- [Torchv Unstrustured 文档解析库](https://blog.csdn.net/weixin_67022862/article/details/149697522)
- [KNN 算法中的各种距离:从原理到应用](https://blog.csdn.net/2201_75607087/article/details/149697554)
- [运维学习(第八周)](https://blog.csdn.net/m0_63532703/article/details/149697011)
### 最新文章
- [真正的完全图解Seq2Seq Attention模型](https://blog.csdn.net/u010660276/article/details/102595236)
- [numpy.linalg.norm](https://blog.csdn.net/u010660276/article/details/95936916)
- [Numpy中的axis](https://blog.csdn.net/u010660276/article/details/95003629)
[2019年6篇](https://blog.csdn.net/u010660276?type=blog&year=2019&month=10)
[2018年8篇](https://blog.csdn.net/u010660276?type=blog&year=2018&month=12)
[2017年3篇](https://blog.csdn.net/u010660276?type=blog&year=2017&month=07)
[2016年19篇](https://blog.csdn.net/u010660276?type=blog&year=2016&month=10)
[2015年292篇](https://blog.csdn.net/u010660276?type=blog&year=2015&month=12)
[2014年408篇](https://blog.csdn.net/u010660276?type=blog&year=2014&month=12)
[2013年272篇](https://blog.csdn.net/u010660276?type=blog&year=2013&month=12)
### 目录
展开全部 
收起 
### 相关专栏
[关于python那些事儿 专栏 97 人学习 帮助初学者建立坚实的Python编程基础。 使有经验的开发者掌握Python的高级特性和最佳实践。 通过项目实践,提升解决实际问题的能力。](https://blog.csdn.net/weixin_43856625/category_12366739.html "关于python那些事儿")
[深入理解*Python**多进程*](https://blog.csdn.net/weixin_43856625/article/details/139624915)
[python 专栏 48 人学习 这不是一个python基础教程,而是python相关的各种应用以及优化介绍,包括深度学习、机器人学、代码加速等等。](https://blog.csdn.net/xiaozisheng2008_/category_7659094.html "python")
[*python* *多进程*共享普通对象的实例](https://blog.csdn.net/xiaozisheng2008_/article/details/104595516)
[python 专栏 0 人学习 python实用技巧](https://blog.csdn.net/kl1411/category_8077338.html "python")
[*python**多进程*multiprocessing.Pool](https://blog.csdn.net/kl1411/article/details/124188211)
### 目录
展开全部 
收起 
上一篇:
[pyhton序列化](https://blog.csdn.net/u010660276/article/details/50382701)
下一篇:
[python ThreadLocal](https://blog.csdn.net/u010660276/article/details/50574180)
### 分类专栏
- [ DFS](https://blog.csdn.net/u010660276/category_1543457.html)
40篇
- [ BFS](https://blog.csdn.net/u010660276/category_1543459.html)
23篇
- [ 背包](https://blog.csdn.net/u010660276/category_1543657.html)
15篇
- [ RMQ](https://blog.csdn.net/u010660276/category_1546129.html)
9篇
- [ 最小生成树](https://blog.csdn.net/u010660276/category_1548967.html)
18篇
- [ 树状数组/线段树](https://blog.csdn.net/u010660276/category_1552413.html)
143篇
- [ 最佳路径](https://blog.csdn.net/u010660276/category_1552789.html)
52篇
- [ 二分图](https://blog.csdn.net/u010660276/category_1558771.html)
19篇
- [ 网络流](https://blog.csdn.net/u010660276/category_1559417.html)
31篇
- [ KMP](https://blog.csdn.net/u010660276/category_1562283.html)
16篇
- [ 图的连通性](https://blog.csdn.net/u010660276/category_1566357.html)
23篇
- [ 字典树\|Trie树\|前缀树](https://blog.csdn.net/u010660276/category_1581911.html)
29篇
- [ codeforces](https://blog.csdn.net/u010660276/category_1614221.html)
91篇
- [ 动态规划](https://blog.csdn.net/u010660276/category_1620099.html)
121篇
- [ c++](https://blog.csdn.net/u010660276/category_1644585.html)
28篇
- [ 二分搜索](https://blog.csdn.net/u010660276/category_1644637.html)
51篇
- [ java](https://blog.csdn.net/u010660276/category_1660833.html)
27篇
- [ 贪心](https://blog.csdn.net/u010660276/category_1661945.html)
23篇
- [ 矩阵快速幂](https://blog.csdn.net/u010660276/category_1662107.html)
20篇
- [ 数据结构](https://blog.csdn.net/u010660276/category_1665077.html)
67篇
- [ 常用技巧](https://blog.csdn.net/u010660276/category_1772451.html)
91篇
- [ 差分约束系统](https://blog.csdn.net/u010660276/category_1818359.html)
3篇
- [ 后缀数组](https://blog.csdn.net/u010660276/category_1924685.html)
26篇
- [ 位运算](https://blog.csdn.net/u010660276/category_2136359.html)
3篇
- [ AC自动机](https://blog.csdn.net/u010660276/category_2141211.html)
28篇
- [ 拓扑排序](https://blog.csdn.net/u010660276/category_2317267.html)
7篇
- [ 数学](https://blog.csdn.net/u010660276/category_2327303.html)
50篇
- [ 欧拉回路](https://blog.csdn.net/u010660276/category_2364665.html)
6篇
- [ 图论](https://blog.csdn.net/u010660276/category_2367025.html)
13篇
- [ 字符串](https://blog.csdn.net/u010660276/category_2388191.html)
43篇
- [ LCA](https://blog.csdn.net/u010660276/category_2467091.html)
18篇
- [ 划分树](https://blog.csdn.net/u010660276/category_2500187.html)
4篇
- [ 主席树](https://blog.csdn.net/u010660276/category_2566335.html)
8篇
- [ 字符串hash](https://blog.csdn.net/u010660276/category_2596857.html)
10篇
- [ Dancing Links](https://blog.csdn.net/u010660276/category_2607781.html)
11篇
- [ Splay](https://blog.csdn.net/u010660276/category_2627247.html)
21篇
- [ 训练指南第一章](https://blog.csdn.net/u010660276/category_2675609.html)
5篇
- [ 高斯消元](https://blog.csdn.net/u010660276/category_2782861.html)
11篇
- [ 后缀自动机SAM](https://blog.csdn.net/u010660276/category_2806229.html)
9篇
- [ 树链剖分](https://blog.csdn.net/u010660276/category_2827451.html)
15篇
- [ treap](https://blog.csdn.net/u010660276/category_2889129.html)
9篇
- [ 平衡二叉树SBT](https://blog.csdn.net/u010660276/category_2889131.html)
7篇
- [ 左偏树](https://blog.csdn.net/u010660276/category_2920033.html)
3篇
- [ 替罪羊树](https://blog.csdn.net/u010660276/category_2924999.html)
1篇
- [ k-d树](https://blog.csdn.net/u010660276/category_2949277.html)
- [ 动态树LCT](https://blog.csdn.net/u010660276/category_3034259.html)
10篇
- [ 树分治](https://blog.csdn.net/u010660276/category_3087445.html)
7篇
- [ 分块数据结构](https://blog.csdn.net/u010660276/category_3244269.html)
6篇
- [ 莫队算法](https://blog.csdn.net/u010660276/category_5354447.html)
4篇
- [ 数位dp](https://blog.csdn.net/u010660276/category_5591295.html)
19篇
- [ python](https://blog.csdn.net/u010660276/category_5702151.html)
27篇
- [ 一般图匹配带花树](https://blog.csdn.net/u010660276/category_5768297.html)
3篇
- [ Linux](https://blog.csdn.net/u010660276/category_5941213.html)
6篇
- [ Hadoop](https://blog.csdn.net/u010660276/category_6142324.html)
10篇
- [ Docker](https://blog.csdn.net/u010660276/category_7883264.html)
4篇
- [ leetcode](https://blog.csdn.net/u010660276/category_7885462.html)
2篇
- [ 机器学习](https://blog.csdn.net/u010660276/category_8811252.html)
5篇
[展开全部 ]() [收起 ]()
### 目录
评论 
被折叠的 条评论 [为什么被折叠?](https://blogdev.blog.csdn.net/article/details/122245662) [到【灌水乐园】发言](https://bbs.csdn.net/forums/FreeZone)
[查看更多评论]()
添加红包

下一步

知道了
![]()
成就一亿技术人\!
领取后你会自动成为博主和红包主的粉丝 [规则]()
[](https://blog.csdn.net/u010660276/article/details/50570289)
hope\_wisdom
发出的红包
实付元
[使用余额支付]()
 点击重新获取
扫码支付
钱包余额 0

抵扣说明:
1\.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。
[余额充值](https://i.csdn.net/#/wallet/balance/recharge)
![]() |
| Readable Markdown | null |
| Shard | 8 (laksa) |
| Root Hash | 14895566225899102208 |
| Unparsed URL | net,csdn!blog,/u010660276/article/details/50570289 s443 |