守护进程,互斥锁,IPC,队列,生产者与消费者模型

小知识点:在子进程中不能使用input输入!

一.守护进程

守护进程表示一个进程b 守护另一个进程a 当被守护的进程结束后,那么守护进程b也跟着结束了

应用场景:之所以开子进程,是为了帮助主进程完成某个任务,然而,如果主进程认为自己的事情一旦做完了就没有必要使用子进程了,就可以将子进程设置为守护进程

例如:在运行qq的过程,开启一个进程,用于下载文件,然而文件还没有下载完毕,qq就退出了,下载任务也应该跟随qq的退出而结束.

from multiprocessing import Process
import time
def task():
  print(‘妃子的一生‘)
  time.sleep(3)
  print(‘妃子88了‘)
if __name__ == ‘__main__‘:
  fz = Process(target=task)
  fz.daemon = True # bool类型 将子进程作为主进程的守护进程,注意:必须在开启子进程前设置!
  fz.start()
  print(‘皇帝登基!‘)
  print(‘当了三年皇帝!‘)
  time.sleep(1)
  print(‘皇帝驾崩了!‘)

二.互斥锁

当多个进程共享一个数据时,可能会造成数据错乱

1.使用join来让这些进程串行,但是这样就造成了无法并发,并且进程执行的顺序就固定了

2.使用锁 将需要共享的数据增加锁 其他的进程在访问数据时,就必须等待当前进程使用完毕

不使用锁:
多个任务在共享一个数据时
串行效率低 但是不会出问题
并发效率高 但是数据可能错乱
使用锁:
from multiprocessing import Process,Lock
import time,random
def task1(lock):
  lock.acquire() #是一个阻塞函数,会等到别的子进程释放锁才能继续执行
  print(‘name1:henry‘)
  time.sleep(random.randint(1,2))
  print(‘age1:29‘)
  time.sleep(random.randint(1, 2))
  print(‘sex1:man‘)
  lock.release()
def task2(lock):
  lock.acquire()
  print(‘name2:wendy‘)
  time.sleep(random.randint(1, 2))
  print(‘age2:24‘)
  time.sleep(random.randint(1, 2))
  print(‘sex2:woman‘)
  lock.release()
def task3(lock):
  lock.acquire()
  print(‘name3:irene‘)
  time.sleep(random.randint(1, 2))
  print(‘age3:27‘)
  time.sleep(random.randint(1, 2))
  print(‘sex3:woman‘)
  lock.release()
if __name__ == ‘__main__‘:
  lock = Lock()
  p1 = Process(target=task1,args=(lock,))
  p1.start()
  p2 = Process(target=task2,args=(lock,))
  p2.start()
  p3 = Process(target=task3,args=(lock,))
  p3.start()

join 和 锁的区别

1.join中顺序是固定的,不公平

2.join是完全的串行,而锁可以使部分代码串行 其他代码还是并发

互斥锁的使用场景_抢票
from multiprocessing import Process,Lock
import json,time,random
def check_ticket(user):
  time.sleep(random.randint(1,3))
  with open(‘ticket.json‘,mode=‘rt‘,encoding=‘utf-8‘) as f:
    dic = json.load(f)
    print(‘用户%s,您好!还剩%s张票!‘%(user,dic[‘count‘]))
def buy_ticket(user):
  with open(‘ticket.json‘,mode=‘rt‘,encoding=‘utf-8‘) as f:
    dic = json.load(f)
    if dic[‘count‘] > 0:
      time.sleep(random.randint(1,3))
      dic[‘count‘] -= 1
      with open(‘ticket.json‘,mode=‘wt‘,encoding=‘utf-8‘) as f2:
        json.dump(dic,f2)
        print(‘用户%s购票成功!‘%user)
def task(user,lock):
  check_ticket(user)
  lock.acquire()
  buy_ticket(user)
  lock.release()

if __name__ == ‘__main__‘:
  lock = Lock()
  for i in range(1,11):
    p = Process(target=task,args=(i,lock))
    p.start()

锁的本质是一个bool类型的数据,在执行代码前会先判断这个值

注意 在使用锁的时候必须保证是同一个锁

锁的实现原理 伪代码
l = False
def task(lock):
  global l
  if l == False:
    l = True
    print(‘你好!‘)
  l = False

Lock和Rlock的区别:

from multiprocessing import Lock
lock = Lock()
lock.acquire()
lock.acquire()
print(‘我出来了!‘)
lock.release()
#这个程序会卡死

from multiprocessing import RLock
lock = RLock()
lock.acquire()
lock.acquire()
print(‘我出来了!‘)
lock.release()
#这个程序会打印出结果

Rlock表示可重复锁,特点是可以多次执行acquire
Rlock在执行多次acquire时和普通Lock没有任何区别
而Lock如果多次执行acquire就会被锁死
还要注意的一点是Rlock在一个子进程中执行了几次acquire就要执行几次release,这样才会执行下一个子进程

from multiprocessing import Process,RLock
import time
def task(i,lock):
  lock.acquire()
  lock.acquire()
  print(i)
  time.sleep(3)
  lock.release()
  lock.release()
if __name__ == ‘__main__‘:
  lock = RLock()
  p1 = Process(target=task,args=(1,lock))
  p1.start()
  p2 = Process(target=task,args=(2,lock))
  p2.start()

死锁:

指的是锁无法打开导致程序卡死 首先要明确的是一把锁是无法锁死的,正常开发时一把锁足够使用,不需要开多把锁

from multiprocessing import Process,Lock
import time
def task1(l1,l2,i):
  l1.acquire()
  print(‘%s抢走了碗!‘%i)
  time.sleep(1)
  l2.acquire()
  print(‘%s抢走了筷子!‘%i)
  print(‘%s开始吃饭!‘%i)
  l1.release()
  l2.release()
def task2(l1,l2,i):
l2.acquire()
  print(‘%s抢走了筷子!‘%i)
  l1.acquire()
  print(‘%s抢走了碗!‘%i)
  print(‘%s开始吃饭!‘%i)
  l2.release()
  l1.releaase()
if __name__ == ‘__main__‘:
  l1 = Lock()
  l2 = Lock()
  p1 = Process(target=task1,args=(l1,l2,‘henry‘))
  p1.start()
  p2 = Process(target=task2,args=(l1,l2,‘seulgi‘))
  p2.start()

三.IPC

由于进程之间是相互独立的,所以需要设立方案使得各个进程之间可以相互传递数据

1.使用共享文件,多个进程同时读写一个文件

IO速度慢,传输数据大小不受限制

2.管道 是基于内存的,速度快,但是是单向的,用起来麻烦

3.申请共享内存空间,多个进程可以共享这个内存区域(重点)

速度快,但数据量不能太大

from multiprocessing import Manager,Process
def work(d):
  d[‘count‘] -= 1
if __name__ == ‘__main__‘:
  with Manager() as m:
    dic = m.dict({‘count‘:100}) #创建一个共享的字典
    p_l = []
    for i in range(100):
    p = Process(target=work,args=(dic,))
    p_l.append(p)
    p.start()

  for P in p_l:
    p.join()
  print(dic)

四.队列

队列不只用于进程间通讯,也是一种常见的数据容器

特点:先进先出

优点:即使在多进程下,也可以保证数据不会错乱,因为put和get默认都是阻塞的

堆栈:先进后出

from multiprocessing import Queue
q = Queue(1)#创建一个对列,最多可以存一个数据
q.put(‘henry‘)
q.put(‘wendy‘) #当容器中已经填满的时候,put默认会阻塞
print(‘over‘)

from multiprocessing import Queue
q = Queue(1)#创建一个对列,最多可以存一个数据
q.put(‘henry‘)
print(q.get())
print(q.get())#当容器中已经没有数据时,get默认会阻塞
print(‘over‘)

from multiprocessing import Queue
q = Queue(1)#创建一个对列,最多可以存一个数据
q.put(‘henry‘)
q.put(‘wendy‘,False) #第二个参数设置为False表示不会阻塞,无论容器满了没满都会强行往里面塞,如果满了抛出异常

from multiprocessing import Queue
q = Queue(1)#创建一个对列,最多可以存一个数据
q.put(‘henry‘)
print(q.get())
print(q.get(timeout=3))#timeout 仅用于阻塞时

五.生产者与消费者模型

什么是生产者消费者模型?

生产者产生数据的一方

消费者处理数据的一方

例如需要做一个爬虫?

1.爬取数据

2.解析数据

爬取和解析都是耗时的操作,如果正常按照顺序来编写代码,会造成解析需要等待爬取,爬取也需要等待解析,这样的话效率就会很低

要提高效率,就是让生产者和消费者解开耦合,自己干自己的

如何实现:

1.将两个任务分配给不同的进程

2.提供一个进程共享的数据容器

from multiprocessing import Process,Queue
import time,random
# 爬数据
def get_data(q):
  for num in range(1,6):
    print(‘正在爬取第%s个数据...‘%num)
    time.sleep(random.randint(1,2))
    print(‘第%s个数据爬取完成!‘%num)
    #把数据装到队列中
    q.put(‘第%s个数据‘%num)
#解析数据
def parse_data(q):
  for num in range(1,6):
    #取出数据
    data = q.get()
    print(‘正在解析%s...‘%data)
    time.sleep(random.randint(1,2))
    print(‘%s解析完成!‘%data)
if __name__ == ‘__main__‘:
  #共享数据容器
  q = Queue()
  #生产者进程
  produce = Process(target=get_data,args=(q,))
  produce.start()
  #消费者进程
  customer = Process(target=parse_data,args=(q,))
  customer.start()

原文地址:https://www.cnblogs.com/lizeqian1994/p/10197875.html

时间: 2024-08-12 01:25:00

守护进程,互斥锁,IPC,队列,生产者与消费者模型的相关文章

开启子进程的两种方式,孤儿进程与僵尸进程,守护进程,互斥锁,IPC机制,生产者与消费者模型

开启子进程的两种方式 # # # 方式一: # from multiprocessing import Process # import time # # def task(x): # print('%s is running' %x) # time.sleep(3) # print('%s is done' %x) # # if __name__ == '__main__': # # Process(target=task,kwargs={'x':'子进程'}) # p=Process(tar

35 守护进程 互斥锁 IPC 共享内存 的方式 生产者消费者模型

守护进程 进程:一个正在运行的程序. 主进程创建守护进程: 1.守护进程会在主进程代码执行结束后就终止, 2.守护进程内无法再开启子进程,否则抛出异常. 注意:进程之间是互相独立的,主进程代码运行结束,守护进程随即终止. 例子:from multiprocessing import Processimport time def task(): print('老了....') time.sleep(2) print('睡了一会..') if __name__ == '__main__': prin

进程 >> 互斥锁、队列与管道、生产者消费者模型

目录 1.互斥锁 2.队列与管道 3.生产者消费者模型(Queue) 4.生产者消费者模型(JoinableQueue) 1.互斥锁 首先导入Lock模块 实例化一把锁 但是每次生成子进程的时候都会重新实例化一把锁,我们的目的是想让所有的子进程使用同一把锁,所以需要把锁传递给子进程在使用 锁名.acquire():开锁->所有子进程开始抢位置 锁名.release():关锁->位置排好了,开始执锁起来执行. join与互斥锁的区别:join是把所有的子进程代码变为串行的,而互斥锁则可以规定那几

20181229(守护进程,互斥锁,IPC,生产者和消费者模型)

一.守护进程 守护进程:一个进程B守护另一个进程A,当被守护的进程A结束,进程B也就结束了.(不一定同生,但会同死) 两个特点: ①守护进程会在主进程代码执行结束后就终止 ②守护进程内无法再开启子进程,否则抛出异常. 注意:进程之间是互相独立的,主进程代码运行结束,守护进程随即终止 应用场景:如果主进程认为一旦自己结束,子进程也就没有继续运行的必要了,就可以将子进程设置为守护进程.(例如:qq正在调用自身的下载文件功能,但是此时退出了qq,下载进程也就可以直接关闭了) 方法为:process.d

守护进程,互斥锁,IPC,生产者与消费者模型

守护进程: b 进程守护 a进程,当a进程执行完毕时,b进程会跟着立马结束 守护进程用途: 如果父进程结束了,子进程无需运行了,就可以将子进程设置为父进程的守护进程 例如我们qq视频聊天时,当我们退出qq时,视频界面会跟着退出,视频就是qq的守护进程 守护进程语法: p.daemon = True #1.未设置守护进程 from multiprocessing import Process import time def task(): print("子进程run") time.sle

python并发编程-进程理论-进程方法-守护进程-互斥锁-01

操作系统发展史(主要的几个阶段) 初始系统 1946年第一台计算机诞生,采用手工操作的方式(用穿孔卡片操作) 同一个房间同一时刻只能运行一个程序,效率极低(操作一两个小时,CPU一两秒可能就运算完了) 联机批处理系统 脱机批处理系统 多道程序系统 1.空间上的复用 ? 多个程序公用一套计算机硬件 2.时间上的复用 ? 切换+保存状态 ? 保存状态:保存当前的运行状态,下次接着该状态继续执行 ? 切换的两种情况 ? (1) 当一个程序遇到 I/O 操作(不需要使用CPU),操作系统会剥夺该程序的C

10.22进程互斥锁,队列,堆栈,线程

进程互斥锁 让并发变成串行,牺牲了执行效率,保证了数据的安全. 在程序并发执行时,如果需要修改数据就使用互斥锁. 队列 相当于内存中的空间. 可以存放多个数据,必须排队,遵循先进先出的顺序. from multiprocessing import Queue #调用队列类,实例化队列对象q q = Queue(5) #若传参,队列中就可以存放5个数据 q = Queue() #若不传参,则队列中可以存放无限个数据 q.get() #获取数据 q.put() #添加数据,满了就报错 q.empty

Python并发编程03/僵尸孤儿进程,互斥锁,进程之间的通信

目录 Python并发编程03/僵尸孤儿进程,互斥锁,进程之间的通信 1.昨日回顾 2.僵尸进程和孤儿进程 2.1僵尸进程 2.2孤儿进程 2.3僵尸进程如何解决? 3.互斥锁,锁 3.1互斥锁的应用 3.2Lock与join的区别 4.进程之间的通信 进程在内存级别是隔离的 4.1基于文件通信 (抢票系统) 4.2基于队列通信 Python并发编程03/僵尸孤儿进程,互斥锁,进程之间的通信 1.昨日回顾 1.创建进程的两种方式: 函数, 类. 2.pid: os.getpid() os.get

Java使用FileLock实现Java进程互斥锁

原理:JDK的nio包中FileLock实现类似Linux fcntl的文件锁, 可使文件被进程互斥访问.  借助此功能, 可以实现强大的Java进程互斥锁, 从而在应用层面保证同一时间只有惟一的Jar应用进程在运行! 避免某些因素导致jar重复执行, 多个进程产生竞争,破坏业务数据. (当然, 你可以借助类似ubuntu的upstart脚本或者ps -p <pid>之类的做法来做到相同的功能).实现: package test; import java.io.File; import jav