进程的其他方法

P = Process(target=f,)

P.Pid 查看进程号  查看进程的名字p.name

P.is_alive()  返回一个true或者False

P.terminate()  给操作系统发送一个结束进程的信号

验证进程之间是空间隔离的

from multiprocessing importProcess

num= 100

deff1():globalnum

num= 3

print(num) #结果 3

if __name__ == '__main__':

p= Process(target=f1,)

p.start()

p.join()print(num) #结果 100

守护进程

主进程的代码运行完毕设置为守护进程的子进程会随之结束

P.daemon = True

importtimefrom multiprocessing importProcessdeff1():

time.sleep(3)print('xxxx')deff2():

time.sleep(5)print('普通子进程的代码')if __name__ == '__main__':

p= Process(target=f1,)

p.daemon=True

p.start()

p2= Process(target=f2,)

p2.start()print('主进程结束') #守护进程会跟跟着父进程的代码运行结束,就结束

进程锁

数据共享  manager

多进程操作共享数据(文件内容)的时候,会造成数据不安全的问题

保证数据安全,但是牺牲了效率,加锁的这段代码大家变成了(同步)串行执行的状态,又叫同步锁\互斥锁

两种锁的方式

l = Lock()

1).with l:

锁中内容

2).

l.acquire()

锁中内容

l.release()

importtimefrom multiprocessing importProcess,Manager,Lockdeff1(m_d,l2):

with l2:#l2.acquire()

tmp = m_d['num']

tmp-= 1time.sleep(0.1)

m_d['num'] =tmp#l2.release()

if __name__ == '__main__':

m=Manager()

l2=Lock()

m_d= m.dict({'num':100})

p_list=[]for i in range(10):

p= Process(target=f1,args=(m_d,l2))

p.start()

p_list.append(p)

[pp.join()for pp inp_list]print(m_d['num'])

队列

Queue()

Q = Queue(10)

Q.put() 放数据

Q.get() 取数据

Q.qsize() 返回的是当前队列中内容的长度

Q.put_nowait()  不等待,但是报错

Q.get_nowait()  不等待,也是报错

Q.full()  q.empty()

用队列实现消费者生产者模型 : 缓冲用,解耦用的,

defproducer(q):for i in range(10):

time.sleep(0.2)

s= '大包子%s号'%iprint(s+'新鲜出炉')

q.put(s)

q.join()#就等着task_done()信号的数量,和我put进去的数量相同时,才继续执行

print('所有的任务都被处理了')#消费者

defconsumer(q):while 1:

time.sleep(0.5)

baozi=q.get()print(baozi+'被吃了')

q.task_done()#给队列发送一个取出的这个任务已经处理完毕的信号

if __name__ == '__main__':#q = Queue(30)

q = JoinableQueue(30) #同样是一个长度为30的队列

pro_p= Process(target=producer,args=(q,))

con_p= Process(target=consumer,args=(q,))

pro_p.start()

con_p.daemon=True

con_p.start()

pro_p.join()print('主进程结束')