并发编程之多进程
进程:
进程是正在进行的一个过程或者一个任务。负责执行这个任务的是cpu
进程与程序的区别:
程序:仅仅只是一堆代码
进程:是程序运行的过程
并发与并行
并发只能达到伪并行，看上去是同时进行的，其实并不是，单个cpu+多道技术就可以实现并发
并行:是同时运行，必须具备多个cpu，才能实现并行的功能
进程的状态
其实在两种情况下会导致一个进程在逻辑上不能运行，
1、进程挂起是自身原因，遇到I/O阻塞，便要让出CPU让其他进程去执行，这样保证CPU一直在工作
2、与进程无关，是操作系统层面，可能会因为一个进程占用时间过多，或者优先级等原因，而调用其他的进程去使用CPU。
开启进程的两种方式
# 1、第一种方式
from multiprocessing import Process,current_process
def task(name):
print("%s is running, 进程名:%s" % (name, current_process().name))
if __name__ == '__main__':
p = Process(target=task, args=(1,) ,name="子进程")
p.start() # 向操作系统发送一个开启一个进程的请求
print("主")
'''
打印结果:
主
1 is running, 进程名:子进程
'''
# 2、第二种方式
class MyProcess(Process):
def __init__(self, process, name):
super().__init__()
self.process = process
self.name = name
def run(self): # 将需要调用进程的方法写入run中, 函数名run不能修改
print("%s is running, 进程名:%s" % (self.process, current_process().name))
if __name__ == '__main__':
p = MyProcess("xu","子进程")
p.start()
print("主")
'''
打印结果:
主
1 is running, 进程名:子进程
'''
进程的join方法:
# join方法
from multiprocessing import Process, current_process
import time
def task(name):
print("%s is running, 进程名:%s" % (name, current_process().name))
time.sleep(1)
'''
执行结果:
1 is running, 进程名:子进程1
1 is end, 进程名:子进程1
主
'''
进程的p.join()方法是当p进程结束之后，才会执行join方法后面的程序
# Process的其他属性和方法
1、terminate和is_alive
from multiprocessing import Process
import time
import random
def task(name):
print('%s is piaoing' %name)
time.sleep(random.randrange(1,5))
print('%s is piao end' %name)
if __name__ == '__main__':
p1=Process(target=task,args=('egon',))
p1.start()
p1.terminate()#关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
print(p1.is_alive()) #结果为True
# is_alive()为判断进程是否还存活
print('主')
print(p1.is_alive()) # 此时p1进程已经关闭，所以结果为False
'''
执行结果:
True
主
False
'''
2、name与pid
from multiprocessing import Process
import time
import random
import os
def task(name):
print('%s is running' %name)
time.sleep(random.randrange(1,5))
print("父进程pid:%s, 子进程pid:%s" %(os.getppid(), os.getpid()))
print('%s is end' % name)
if __name__ == '__main__':
p1=Process(target=task,args=('xu',), name="子进程1") # name属性设置进程的名称
p1.start()
print(p1.name) # 打印p1进程的名称
print('主', os.getpid())
'''
打印结果:
子进程1
主 15752
xu is running
父进程pid:15752, 子进程pid:15753
xu is end
'''
僵尸进程:
当子进程结束掉后,并不是完完整整清除掉,其还会保留它的pid,供给主进程查看,只有当主进程结束掉以后,才会被回收掉。
1、子进程结束掉以后,会保留一些子进程的状态信息,如pid,当主进程结束掉以后,才会被回收掉
2、僵尸进程有害,当子进程结束后,会保留pid,其他进程无法使用,会使得服务器负载量过大。
孤儿进程
1、当子进程未结束，主进程结束，则会使得子进程变成孤儿进程
2、在linux系统中,有一个init进程,此进程是所有进程的父亲，当一个进程变成孤儿进程后,会被init接管,由此进程将那些孤儿进程结束掉。
守护进程
1、守护进程会在主进程执行结束后结束。
2、守护进程内无法再开启子进程，否则会抛出异常。
from multiprocessing import Process,current_process
import time
def task():
print("%s is running" % current_process().name)
time.sleep(2)
print("%s is end" % current_process().name)
if __name__ == '__main__':
p1 = Process(target=task, name="进程1")
p1.daemon = True # 开启守护进程，开启的动作必须要在start之前
p1.start()
print("主") # 当此程序执行后,主进程便执行结束了,那么守护线程也需要结束
'''
打印结果:
主
'''
互斥锁
进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争，竞争带来的结果就是错乱
from multiprocessing import Process, current_process
import time
def task():
print("%s is running" % current_process().name)
time.sleep(2)
print("%s is end" % current_process().name)
if __name__ == '__main__':
for i in range(3):
p = Process(target=task, name="进程%s" %i)
p.start()
'''
打印结果:
进程0 is running
进程1 is running
进程2 is running
进程0 is end
进程1 is end
进程2 is end
'''
如果没有发生错乱,那么应该打印结果为:
进程0 is running
进程0 is end
进程1 is running
进程1 is end
进程2 is running
进程2 is end
如何控制其行为呢,就需要加锁,而这把锁就为互斥锁
from multiprocessing import Process, current_process, Lock
import time
def task(mutex):
mutex.acquire()
print("%s is running" % current_process().name)
time.sleep(2)
print("%s is end" % current_process().name)
mutex.release()
if __name__ == '__main__':
mutex = Lock() # 创建互斥锁对象,需要保证每个进程里面的锁是同一把,所以需要将此对象传给task
for i in range(3):
p = Process(target=task, args=(mutex, ), name="进程%s" %i)
p.start()
'''
打印结果:
进程0 is running
进程0 is end
进程1 is running
进程1 is end
进程2 is running
进程2 is end
'''
互斥锁模拟抢票功能
# 模拟抢票功能
from multiprocessing import Process, Lock
import time
import json
def show_ticket():
time.sleep(1)
ticket_dict = json.load(open("ticket_num.json", "r", encoding="utf-8"))
print("票数为:%s" %(ticket_dict["count"]))
def pay_ticket(mutex):
show_ticket()
mutex.acquire()
time.sleep(1)
dict = json.load(open("ticket_num.json", "r", encoding="utf-8"))
if dict["count"] > 0:
print("购票成功")
dict["count"] -= 1
json.dump(dict, open("ticket_num.json", "w", encoding="utf-8"))
else:
print("没有票了, 购票失败")
mutex.release()
if __name__ == '__main__':
mutex = Lock()
for i in range(10):
p = Process(target=pay_ticket, args=(mutex, ))
p.start()
队列
from multiprocessing import Process,Queue
q=Queue(3) # 3为队列中允许最大项数，省略则无大小限制
#put ,get ,put_nowait,get_nowait,full,empty
q.put(1) # 在队列中放置数据
q.put(2)
q.put(3)
print(q.full()) #满了
# q.put(4) #再放就阻塞住了
print(q.get())
print(q.get())
print(q.get())
print(q.empty()) #空了
# print(q.get()) #再取就阻塞住了
ps:
1、队列内存放的是消息而非大数据
2、队列占用的是内存空间，因而maxsize即便是无大小限制也受限于内存大小
# 两个队列形成一个栈 ''' 队列特性:先进先出 堆栈特性:先进后出 实现思路: # 存数据阶段 1、先创建两个队列 2、将数据存入第一个队列中 # 取数据阶段 1、判断第一个队列是否为空, 若为空，则返回None 2、将第一个队列中的数据与挨个取出存入第二个队列,当第一个队列中的数量为最后一个的时候,这最后一个数据便是最后存储进队列中的,将其取出，然后返回,然后将第一个队列和第二个队列对调，一直循环,这样就能形成先进后出 ''' import queue class Stack(object,): def __init__(self): self.one_queue = queue.Queue() self.two_queue = queue.Queue() def push(self, data): """ 将数据放入第一个队列中 :return: """ self.one_queue.put(data) def getdata(self): """ 将数据取出 :return: """ if self.one_queue.qsize() == 0: return None while 1: if self.one_queue.qsize() == 1: value = self.one_queue.get() break self.two_queue.put(self.one_queue.get())
# 将队列对换 temp = self.one_queue self.one_queue = self.two_queue self.two_queue = temp return value if __name__ == '__main__': stack = Stack() stack.push("xu") stack.push("sy") stack.push("songy") print(stack.getdata()) print(stack.getdata()) print(stack.getdata())
生产者消费者模型
用多进程和队列实现生产者消费者模型
from multiprocessing import Process, Queue
import time
def producer(name, q):
for i in range(3):
print("生产者%s生产了%s包子" %(name, i))
q.put({name: i})
time.sleep(0.5)
def consumer(name, q):
while True:
package = q.get()
print("消费者%s吃了包子%s" %(name, package))
time.sleep(1)
if __name__ == '__main__':
q = Queue()
producers = ["xu", "sy", "songyuan"]
consumers = ["guang", "chong",]
# 生产者们
for one_producer in producers:
p = Process(target=producer, args=(one_producer, q, ))
p.start()
# 消费者们
for one_consumer in consumers:
p = Process(target=consumer, args=(one_consumer, q, ))
p.start()
这就产生了一个问题, 如果消费者将队列中的包子取完了, 那么消费者就会一直阻塞在q.get()阶段,无发退出。
所以就有了一个模块JoinableQueue
from multiprocessing import Process, JoinableQueue
import time
def producer(name, q):
for i in range(3):
print("生产者%s生产了%s包子" %(name, i))
q.put({name: i})
time.sleep(0.5)
q.join() # q没取完, 则进程便会在此阻塞住
def consumer(name, q):
while True:
package = q.get()
print("消费者%s吃了包子%s" %(name, package))
time.sleep(1)
q.task_done() # 给q.join()发送一个已经取走一个包子的消息
if __name__ == '__main__':
q = JoinableQueue()
producers = ["xu", "sy", "songyuan"]
consumers = ["guang", "chong",]
# 生产者们
p1 = Process(target=producer, args=("xu", q, ))
p2 = Process(target=producer, args=("sy", q, ))
p3 = Process(target=producer, args=("songy", q, ))
# 消费者们
c1 = Process(target=consumer, args=("guang", q, ))
c2 = Process(target=consumer, args=("chong", q, ))
c1.daemon = True
c2.daemon = True
p1.start()
p2.start()
p3.start()
c1.start()
c2.start()
p1.join()
p2.join()
p3.join()
