一，进程的理论基础
一个应用程序，归根结底是一堆代码，是静态的，而进程才是执行中的程序，在一个程序运行的时候会有多个进程并发执行。
进程和线程的区别：
进程与线程的共同点：
都是为了提高程序运行效率，都有执行的优先权
二，python的多进程（ multiprocessing模块）
创建一个进程(和创建线程类似)
方法一：创建process对象，通过对象调用start()方法启动进程
我要评论
from multiprocessing import process
def foo(name):
print('hello,%s'%name)
if __name__ == '__main__':
p1=process(target=foo,args=('world',))
p2 = process(target=foo, args=('china',))
p1.start()
p2.start()
print('=====主进程=====')
# == == =主进程 == == =
# hello, world
# hello, china
#主进程和子进程并发执行
注意：process对象只能在在 if __name__ == '__main__':下创建，不然会报错。
方法二：自定义一个类继承process类，并重写run()方法,将执行代码放在其内
from multiprocessing import process
class myprocess(process):
def __init__(self,name):
super().__init__()
self.name = name
def run(self):
print('hello,%s'%self.name)
if __name__ == '__main__':
myprocess1 = myprocess('world')
myprocess2 = myprocess('world')
myprocess1.start()
myprocess2.start()
process内置方法
实例方法:
p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回true
p.join([timeout]):主线程等待p终止。timeout是可选的超时时间
process属性
p.daemon：默认值为false，如果设为true，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为true后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid
p.exitcode:进程在运行时为none、如果为–n，表示被信号n结束(了解即可)
守护进程
类似于守护线程，只不过守护线程是对象的一个方法，而守护进程封装成对象的属性。
from multiprocessing import process
import time
class myprocess(process):
def __init__(self,name):
super().__init__()
self.name = name
def run(self):
time.sleep(3)
print('hello,%s'%self.name)
if __name__ == '__main__':
myprocess1=myprocess('world')
myprocess1.daemon = true
myprocess1.start()
print('结束')
#不会输出‘hello world'，因为设置为守护进程，主进程不会等待
也可以使用join方法，使主进程等待
from multiprocessing import process
import time
class myprocess(process):
def __init__(self,name):
super().__init__()
self.name = name
def run(self):
time.sleep(3)
print('hello,%s'%self.name)
if __name__ == '__main__':
myprocess1=myprocess('world')
myprocess1.daemon = true
myprocess1.start()
myprocess1.join() #程序阻塞
print('结束')
join()
进程同步和锁
进程虽然不像线程共享资源，但是这并不意味着进程间不 需要加锁，比如不同进程会共享同一个终端 （ 屏幕），或者操作同一个文件，数据库，那么数据安全还是很有必要的，因此我们可以加锁,
from multiprocessing import process,lock
import time
def a_print(l): #需要传入对象，因为信息不共享
l.acquire()
print('我要打印信息')
time.sleep(1)
print('我打印完了')
l.release()
if __name__ == '__main__':
l = lock()
for i in range(20):
p = process(target=a_print,args=(l,))
p.start()
信号量（semaphore）
能够并发执行的进程数，超出的进程阻塞，直到有进程运行完成。
semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞进程直到其他进程调用release()。
from multiprocessing import process,queue,semaphore
import time,random
def seat(s,n):
s.acquire()
print('学生%d坐下了'%n)
time.sleep(random.randint(1,2))
s.release()
if __name__ == '__main__':
s = semaphore(5)
for i in range(20):
p = process(target=seat,args=(s,i))
p.start()
print('-----主进程-------')
注意：其实信号量和锁类似，只是限制进程运行某个代码块的数量（锁为1个），并不是能限制并发的进程，如上述代码，一次性还是创建了20个进程
事件（event）
from multiprocessing import process,event
import time, random
def eating(event):
event.wait()
print('去吃饭的路上...')
def makeing(event):
print('做饭中')
time.sleep(random.randint(1,2))
print('做好了，快来...')
event.set()
if __name__ == '__main__':
event=event()
t1 = process(target=eating,args=(event,))
t2 = process(target=makeing,args=(event,))
t1.start()
t2.start()
# 做饭中
# 做好了，快来...
# 去吃饭的路上...
和线程事件几乎一致
进程队列（queue）
进程队列是进程通讯的方式之一。使用multiprocessing 下的queue
from multiprocessing import process,queue
import time
def func1(queue):
while true:
info=queue.get()
if info == none:
return
print(info)
def func2(queue):
for i in range(10):
time.sleep(1)
queue.put('is %d'%i)
queue.put(none) #结束的标志
if __name__ == '__main__':
q = queue()
p1 = process(target=func1,args=(q,))
p2 = process(target=func2, args=(q,))
p1.start()
p2.start()
queue类的方法，源码如下：
class queue(object):
def __init__(self, maxsize=-1): #可以传参设置队列最大容量
self._maxsize = maxsize
def qsize(self): #返回当前时刻队列中的个数
return 0
def empty(self): #是否为空
return false
def full(self): 是否满了
return false
def put(self, obj, block=true, timeout=none): #放值,blocked和timeout。如果blocked为true（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出queue.full异常。如果blocked为false，但该queue已满，会立即抛出queue.full异常
pass
def put_nowait(self, obj): #=put(false)
pass
def get(self, block=true, timeout=none): 获取值,get方法有两个可选参数：blocked和timeout。如果blocked为true（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出queue.empty异常。如果blocked为false，有两种情况存在，如果queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出queue.empty异常.
pass
def get_nowait(self): # = get(false)
pass
def close(self): #将队列关闭
pass
def join_thread(self): #略，几乎不用
pass
def cancel_join_thread(self):
pass
进程队列源码注释
进程池
进程的消耗是很大的，因此我们不能无节制的开启新进程，因此我们可以 通过维护一个进程池来控制进程的数量 。这就不同于信号量，进程池可以从源头控制进程数量。在python中可以通过如下方法使用
同步调用
from multiprocessing import pool
import time, random, os
def func(n):
pid = os.getpid()
print('进程%s正在处理第%d个任务'%(pid,n),'时间%s'%time.strftime('%h-%m-%s'))
time.sleep(2)
res = '处理%s'%random.choice(['成功','失败'])
return res
if __name__ == '__main__':
p = pool(4) #创建4个进程，
li = []
for i in range(10):
res = p.apply(func,args=(i,)) 交给进程池处理，处理完成才返回值，会阻塞，即使池内还有空余进程，相当于顺序执行
li.append(res)
for i in li:
print(i)
#进程1916正在处理第0个任务 时间21-02-53
#进程1240正在处理第1个任务 时间21-02-55
#进程3484正在处理第2个任务 时间21-02-57
#进程7512正在处理第3个任务 时间21-02-59
#进程1916正在处理第4个任务 时间21-03-01
#进程1240正在处理第5个任务 时间21-03-03
#进程3484正在处理第6个任务 时间21-03-05
#进程7512正在处理第7个任务 时间21-03-07
#进程1916正在处理第8个任务 时间21-03-09
#进程1240正在处理第9个任务 时间21-03-11
从结果可以发现两点：
因此进程池提供了 异步处理 的方式
from multiprocessing import pool
import time, random, os
def func(n):
pid = os.getpid()
print('进程%s正在处理第%d个任务'%(pid,n),'时间%s'%time.strftime('%h-%m-%s'))
time.sleep(2)
res = '处理%s'%random.choice(['成功','失败'])
return res
if __name__ == '__main__':
p = pool(4)
li = []
for i in range(10):
res = p.apply_async(func,args=(i,)) 结果不会立刻返回，遇到阻塞，开启下一个进程，在这，相当于几乎同时出现四个打印结果（一个线程处理一个任务，处理完下个任务才能进来）
li.append(res)
p.close() #join之前需要关闭进程池
p.join() #因为异步，所以需要等待池内进程工作结束再继续
for i in li:
print(i.get()) #i是一个对象，通过get方法获取返回值，而同步则没有该方法
关于回调函数
from multiprocessing import pool
import time, random, os
def func(n):
pid = os.getpid()
print('进程%s正在处理第%d个任务'%(pid,n),'时间%s'%time.strftime('%h-%m-%s'))
time.sleep(2)
res = '处理%s'%random.choice(['成功','失败'])
return res
def foo(info):
print(info) #传入值为进程执行结果
if __name__ == '__main__':
p = pool(4)
li = []
for i in range(10):
res = p.apply_async(func,args=(i,)，callback = foo) callback()回调函数会在进程执行完之后调用（主进程调用）
li.append(res)
p.close()
p.join()
for i in li:
print(i.get())
有回调函数
总结
以上所述是小编给大家介绍的python并发之多进程的方法实例代码，希望对大家有所帮助
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
07 ，df 列操作，行操作 ： 增，删，改，查，计算，列过滤
网友评论