多进程
守护进程(daemon)
'''
进程是一个正在运行的程序
守护进程也是一个普通进程,意思是一个进程可以守护另一个进程
守护进程会随着被守护进程的结束而结束
'''
import multiproecssing
import time
def task():
print('进程开始')
time.sleep(50)
print('进程结束')
if __name__ == '__main__':
print('准备创建进程')
p = multiprocessing.Process(target = task)
p.deamon = True
p.start()
time.sleep(3)
print('进程结束')
互斥锁
'''
并发带来的资源的竞争问题,当多个进程同时要操作同一个资源时,将会导致数据错乱
如果资源已经被锁了,那么别的进程就无法使用
互斥锁并不是把文件或者说资源锁起来,只是在代码层面限制了代码的执行
'''
from multiproecssing import Process,Lock
import time,random
def task1(lock)
lock.acquire()
print('hello world')
print('i am lilei')
print('i am boy')
lock.release()
def task2()
lock.acquire()
print('hello world')
print('i am lilei')
print('i am boy')
lock.release()
def task3()
lock.arquire()
print('hello world')
print('i am lilei')
print('i am boy')
lock.release()
if __name__ == '__main__':
p1 = Process(target = task1,args = (lock,))
p2 = Process(target = task2,args = (lock,))
p3 = Process(target = task3,args = (lock,))
IPC(进程间通讯)
'''
进程之间内存是相互隔离的,当一个进程想要把数据给另外一个进程,就需要考虑IPC
管道(subprosecc):只能单项通讯
文件:在硬盘上创建共享文件,速度慢
socket:编程复杂度较高
共享内存:由操作系统来分配,速度快,数据量不能太大
'''
from multiprocessing import Process Manager,Lock
import time
def task(data,l):
l.acquire()
num = data['num']
time.sleep(0,1)
data['num'] = num-1
l.release()
if __name__ == '__main__':
m = Manager()
data = m.dict({'num':10})
l = lock()
for i in range(10):
p = Process(target=task,args=(data,l))
p.start()
time.sleep(2)
print(data)
Queue队列
'''
队列是一种特殊的数据结构,先存储的先取出
相反的是堆栈,先存储的后取出
函数嵌套调用时,执行顺序时先进后出,称为函数栈
调用函数时,函数入栈,函数结束就出栈
'''
from multiprocessing import Queue
生产者消费者模型
"""
解决某种问题的一贯方法
生产者:产生数据的一方
消费者:处理数据的一方
"""
import time,random
from mlutporcessing import Process,Queue
import socket
def eat(q):
for i in range(10):