多进程

Posted 2020-11-21 amou

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了多进程相关的知识，希望对你有一定的参考价值。

Python36 多线程、多进程的使用场景

代码老兵 2人评论1026人阅读 2018-03-15 21:17:02

多线程与多进程的使用场景

io 操作不占用CPU（从硬盘、从网络、从内存读数据都算io）
计算占用CPU（如1+1计算）

python中的线程是假线程，不同线程之间的切换是需要耗费资源的，因为需要存储线程的上下文，不断的切换就会耗费资源。。

python多线程适合io操作密集型的任务（如socket server 网络并发这一类的）；
python多线程不适合cpu密集操作型的任务，主要使用cpu来计算，如大量的数学计算。
那么如果有cpu密集型的任务怎么办，可以通过多进程来操作（不是多线程）。
假如CPU有8核，每核CPU都可以用1个进程，每个进程可以用1个线程来进行计算。
进程之间不需要使用gil锁，因为进程是独立的，不会共享数据。
进程可以起很多个，但是8核CPU同时只能对8个任务进行操作。

多进程

测试多进程

import multiprocessing
import time

def run(name):
time.sleep(2)
print (‘heelo‘,name)

if __name__ == ‘__main__‘:

for i in range(10): #起了10个进程
p = multiprocessing.Process(target=run,args=(‘bob%s‘ %i,))
p.start()

执行结果：
heelo bob1
heelo bob0
heelo bob2
heelo bob3
heelo bob5
heelo bob4
heelo bob6
heelo bob7
heelo bob8
heelo bob9

##2秒左右就执行完成了，有几核CPU，同时就可以处理几个进程；当然要考虑你的电脑还开启了N多个其他应用程序，不过CPU计算比较快。

import multiprocessing
import time,threading

def thread_run():
print (threading.get_ident()) #get_ident获取当前线程id

def run(name):
time.sleep(2)
print (‘heelo‘,name)
t = threading.Thread(target=thread_run,) #在每个进程中又起了1个线程
t.start()

if __name__ == ‘__main__‘:

for i in range(10): #起了10个进程
p = multiprocessing.Process(target=run,args=(‘bob%s‘ %i,))
p.start()

执行结果：
heelo bob0
16684
heelo bob1
15052
heelo bob2
15260
heelo bob3
6192
heelo bob4
6748
heelo bob7
13980
heelo bob5
6628
heelo bob6
3904
heelo bob9
2328
heelo bob8
17072

import os

def info(title):
print(title)
print(‘module name:‘, __name__)
print(‘parent process:‘, os.getppid()) #获取父进程的id
print(‘process id:‘, os.getpid()) #获取自身的id
print("

def f(name):
info(‘33[31;1mfunction f33[0m‘)
print(‘hello‘, name)

if __name__ == ‘__main__‘:
info(‘33[32;1mmain process line33[0m‘) ##直接调用函数
# p = Process(target=f, args=(‘bob‘,))
# p.start()
# p.join()

执行结果：
main process line
module name: __main__
parent process: 1136 #父进程ID，这个父进程就是pycharm
process id: 16724 #这个子进程就是python的代码程序
##每个进程都会有一个父进程。

from multiprocessing import Process
import os

def info(title):
print(title)
print(‘module name:‘, __name__)
print(‘parent process:‘, os.getppid()) #获取父进程的id
print(‘process id:‘, os.getpid()) #获取自身的id
print("

def f(name):
info(‘33[31;1mcalled from child process function f33[0m‘)
print(‘hello‘, name)

if __name__ == ‘__main__‘:
info(‘33[32;1mmain process line33[0m‘)
p = Process(target=f, args=(‘bob‘,)) #设置子进程
p.start() #启动子进程
# p.join()

执行结果：
main process line
module name: __main__
parent process: 1136 #主进程pycharm
process id: 14684 #子进程python代码

called from child process function f
module name: __mp_main__
parent process: 14684 #主进程python代码（1136的子进程）
process id: 15884 #python代码（主进程14684）中的子进程的子15884
## 每个进程都有主进程（父进程）

hello bob

进程间通讯

默认进程之间数据是不共享的，如果一定要实现互访可以通过Queue来实现，这个Queue和线程中的Queue使用方法一样，不过线程中的Queue只能在线程之间使用。

线程

import queue
import threading

def f():
q.put([42,None,‘heelo‘])

if __name__ == ‘__main__‘:
q = queue.Queue()
p = threading.Thread(target=f,)

p.start()

print (q.get())
p.join()

执行结果：
[42, None, ‘heelo‘]
## 通过子线程put进去数据，然后在主线程get出内容，表明线程之间数据是可以共享的。

进程

import queue
from multiprocessing import Process

def f():
q.put([42,None,‘heelo‘]) #这里的q属于主进程

if __name__ == ‘__main__‘:
q = queue.Queue() #主进程起的q
p = Process(target=f,)
## 在主进程中来定义子进程；如果在主进程中启动了子进程，那么主进程和子进程之间内存是独立的。
## 因为内存独立，子进程p是无法访问主进程def f()中的q的。
p.start()

print (q.get())
p.join()

执行结果：
Process Process-1:
Traceback (most recent call last):
File "D:python3.6.4libmultiprocessingprocess.py", line 258, in _bootstrap
self.run()
File "D:python3.6.4libmultiprocessingprocess.py", line 93, in run
self._target(*self._args, **self._kwargs)
File "E:python代码练习A3.py", line 7, in f
q.put([42,None,‘heelo‘])
NameError: name ‘q‘ is not defined

##可以看到已经报错，这是因为子进程不能访问主进程的q

import queue
from multiprocessing import Process

def f(qq):
qq.put([42,None,‘heelo‘])

if __name__ == ‘__main__‘:
q = queue.Queue()
p = Process(target=f,args=(q,)) #将父进程q传给子进程

p.start()

print (q.get())
p.join()

执行结果：

Traceback (most recent call last):
File "E:/python/代码练习/A3.py", line 13, in <module>
p.start()
File "D:python3.6.4libmultiprocessingprocess.py", line 105, in start
self._popen = self._Popen(self)
File "D:python3.6.4libmultiprocessingcontext.py", line 223, in _Popen
return _default_context.get_context().Process._Popen(process_obj)
File "D:python3.6.4libmultiprocessingcontext.py", line 322, in _Popen
return Popen(process_obj)
File "D:python3.6.4libmultiprocessingpopen_spawn_win32.py", line 65, in __init__
reduction.dump(process_obj, to_child)
File "D:python3.6.4libmultiprocessing
eduction.py", line 60, in dump
ForkingPickler(file, protocol).dump(obj)
TypeError: can‘t pickle _thread.lock objects

## 这是因为我们将线程的q传给另一个进程，这是不可以的，线程只属于当前进程，不能传给其他进程。
## 如果想将q传给子进程，那么必须将进程q传进去，而不是线程q。

from multiprocessing import Process,Queue
##大写的Queue是进程队列； queue是线程队列
##大写的Queue需要从multiprocessing导入

def f(qq):
qq.put([42,None,‘heelo‘])

if __name__ == ‘__main__‘:
q = Queue()
p = Process(target=f,args=(q,)) #将父进程q传给子进程

p.start()

print (q.get()) #父进程去get子进程的内容
p.join()

执行结果：
[42, None, ‘heelo‘]
##父进程可以get子进程put进去的内容了；从表面上看感觉是两个进程共享了数据，其实不然。

## 现在已经实现了进程间的通讯。父进程将q传给子进程，其实是克隆了一份q给子进程，此时子进程就多了一个q进程队列；但是父进程又为什么能够get子进程put进去的数据呢，这是因为当前两个进程在内存空间依然是独立的，只不过子进程put的数据通过pickle序列化放到内存中一个中间的位置，然后父进程从这个中间的位置取到数据（而不是从子进程中取的数据）。所以进程间的通讯不是共享数据，而是一个数据的传递。

进程之间的数据还可以通过管道的方式来通讯