标签：概念 代码 消费 self image 应用 closed 互斥 alt
进程：正在进行的过程或者一个任务，是系统进行资源调度和分配的基本单元。进程是操作系统中最基本、最重要的概念。是多道程序系统出现后，为了刻画系统内部出现的动态情况，描述系统内部各道程序的活动规律引进的一个抽象的概念，所有多道程序设计操作系统都建立在进程的基础上。
进程与程序的区别：程序仅仅是一堆代码，而进程表示程序的运行过程。同一个程序被运行多次表示开启了多个进程。
在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入：就绪、运行和阻塞三个阶段
就绪：当进程已经分配到除CPU外的所有必要资源，子要获得处理机就可以立即执行。
执行/运行：程序获得处理机，其程序正在运行。
阻塞：正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起阻塞原因包括（等待I/O完成、申请缓冲不能满足、等待信号等）。
Python中创建进程主要应用Process类:
Process(group , target , name , args , kwargs)，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动） 强调：
创建进程的两种方式：
#开启进程方式一 from multiprocessing import Process import time def test(name): print(‘%s is running‘ %name) time.sleep(3) print(‘%s is done‘ %name) if __name__==‘__main__‘: p=Process(target=test,args=(‘hello‘,)) p.start() print(‘main‘) #开启子进程方式二 from multiprocessing import Process import time class MyProcess(Process): def __init__(self,name): super(MyProcess, self).__init__() self.name=name def run(self): print(‘%s is running‘ %self.name) time.sleep(3) print(‘%s is done‘ %self.name) if __name__==‘__main__‘: p=MyProcess(‘hi‘) p.start() print(‘main‘)
from multiprocessing import Process import os n=100 def test(): global n n=0 print(‘%s进程中n=%s‘ %(os.getpid(),n)) if __name__ == ‘__main__‘: p=Process(target=test) p.start() print(‘主进程中n=%s‘ %n) #主进程中n=100，没有被修改 #子进程n=0,
from multiprocessing import Process import time def test(name): print(‘%s为守护子进程staring‘%name) time.sleep(3) print(‘%s为守护子进程ending‘ % name) if __name__==‘__main__‘: p1=Process(target=test,args=(‘Hi‘,)) p1.daemon=True p1.start() print(‘main‘) #仅输出main
from multiprocessing import Process import time def test(name): print(‘%s is running‘ %name) time.sleep(3) print(‘%s is done‘ %name) if __name__==‘__main__‘: p=Process(target=test,args=(‘hello‘,)) p.start() p.join() print(‘main‘) #hello is running #hello is done #main
一个主进程中各子进程间数据是不能互相通信的，但可以通过访问外部同一个文件来实现共享，但共享带来的是竞争，竞争带来的结果就是混乱。解决方式就是加锁。
from multiprocessing import Process, Lock import time import json import random import os def search(): time.sleep(random.randint(1,3)) dic=json.load(open(‘1.txt‘,‘r‘,encoding=‘utf-8‘)) print(‘%s 查询到余票%s‘ %(os.getpid(),dic[‘count‘])) def get(): time.sleep(random.randint(1,3)) dic=json.load(open(‘1.txt‘,‘r‘,encoding=‘utf-8‘)) if(dic[‘count‘]>0): dic[‘count‘]-=1 time.sleep(random.randint(1,3)) json.dump(dic, open(‘1.txt‘, ‘w‘, encoding=‘utf-8‘)) print(‘%s购票成功‘%os.getpid()) def task(mutex): search() mutex.acquire() get() mutex.release() if __name__==‘__main__‘: mutex=Lock() #设置锁 for i in range(10): p=Process(target=task,args=(mutex,)) p.start()
存在问题：加锁可以保证多个进程修改同一块数据时，只允许自有一个任务是可以修改，即串行修改，运行速度慢却保证了数据安全。该方式效率低（数据基于共享文件，而文件在磁盘上）、需要自己加锁处理。
队列是一种先进先出存储方式，
from multiprocessing import Queue q=Queue(3)#定义一个队列大小，可以不指定 q.put(‘first‘) #插入数据，当队列满时会阻塞 q.put({‘count‘:1}) q.put(1) q.put(‘de‘,block=True,timeout=3) print(q.get()) #拿数据
队列实现进程通信：
from multiprocessing import Process,Queue def f1(q): q.put(‘hi‘) def f2(q): print(q.get()) if __name__==‘__main__‘: q=Queue() p=Process(target=f1,args=(q,)) p1=Process(target=f2,args=(q,)) p.start() p1.start()
在并发编程中使用生产者消费者模式可以解决大多数并发问题。通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者间不直接通信，而阻塞队列来进行通信，所以生产者生产玩数据后不用等待消费者的处理，直接扔给阻塞队列，消费者不用找生产者要数据，而直接从阻塞队列中取。阻塞队列就相当于一个缓冲区，平衡了消费者和生产者的能力。
import time import random from multiprocessing import Process,Queue,JoinableQueue def producer(name,q): for i in range(3): r=‘包子%s‘ %i print(‘%s制作包子%s‘ %(name,i)) time.sleep(random.randint(1, 3)) q.put(r) def consumer(name,q): while True: res=q.get() if res==‘NULL‘:break print(‘%s吃包子%s‘ %(name,res)) time.sleep(random.randint(1, 3)) q.task_done() if __name__=="__main__": #q=Queue() q=JoinableQueue() p=Process(target=producer,args=(‘gg‘,q,)) p1 = Process(target=producer, args=(‘gg1‘, q,)) c=Process(target=consumer,args=(‘cc‘,q)) c1 = Process(target=consumer, args=(‘cc1‘, q)) c2= Process(target=consumer, args=(‘cc2‘, q)) p.start() p1.start() c.daemon=True c1.daemon=True c2.daemon=True c.start() c1.start() c2.start() p.join() p1.join() q.join() print(‘main‘)
标签：概念 代码 消费 self image 应用 closed 互斥 alt
原文地址：https://www.cnblogs.com/2019zjp/p/12165877.html
