开启子进程的两种方式

# # # 方式一：
# 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(target=task,args=('子进程',)) # 如果args=(),括号内只有一个参数，一定记住加逗号
#     p.start() # 只是在操作系统发送一个开启子进程的信号
#
#     print('主')# 导入from multiprocessing import Process
# 相当于在windows系统中调用了CreateProcess接口
# CreateProcess既处理进程的创建，也负责把正确的程序装入新进程。
# p.start() # 只是在操作系统发送一个开启子进程的信号# 方式二：
# from multiprocessing import Process
# import time
#
# class Myprocess(Process):
#     def __init__(self,x):
#         super().__init__()
#         self.name=x
#
#     def run(self):
#         print('%s is running' %self.name)
#         time.sleep(3)
#         print('%s is done' %self.name)
#
# if __name__ == '__main__':
#     p=Myprocess('子进程1')
#     p.start()  #p.run()
#     print('主')from multiprocessing import Process
import timedef task(x,n):print('%s is running' % x)time.sleep(n)print('%s is done' % x)if __name__ == '__main__':# Process(target=task,kwargs={'x':'子进程'})p1 = Process(target=task, args=('子进程1',3))  # 如果args=(),括号内只有一个参数，一定记住加逗号p2 = Process(target=task, args=('子进程2',5))  # 如果args=(),括号内只有一个参数，一定记住加逗号p1.start()  # 只是在操作系统发送一个开启子进程的信号p2.start()  # 只是在操作系统发送一个开启子进程的信号print('主')

View Code

#1、join(让父进程在原地等待，等到子进程运行完毕后(会触发wait功能,将子进程回收掉)，才执行下一行代码)
# from multiprocessing import Process
# import time
#
# def task(name):
#     print('%s is running ' %name)
#     time.sleep(3)
#     print('%s is done ' % name)
#
#
# if __name__ == '__main__':
#     p=Process(target=task,args=('子进程1',))
#     p.start()  # 只是在操作系统发送一个开启子进程的信号,至于操作系统多久执行这个指令我们控制不了
#     p.join() # 让父进程在原地等待，等到子进程运行完毕后(会触发wait功能,将子进程回收掉)，才执行下一行代码
#               #  将p占用的操作系统的pid回收
#     print('主')# from multiprocessing import Process
# import time
#
# def task(name,n):
#     print('%s is running ' %name)
#     time.sleep(n)
#     print('%s is done ' % name)
#
#
# if __name__ == '__main__':
#     p1=Process(target=task,args=('子进程1',1))
#     p2=Process(target=task,args=('子进程2',2))
#     p3=Process(target=task,args=('子进程3',3))
#
#     start_time=time.time()
#     p1.start() # 只是在操作系统发送一个开启子进程的信号
#     p2.start() # 只是在操作系统发送一个开启子进程的信号
#     p3.start() # 只是在操作系统发送一个开启子进程的信号
#
#     p3.join()
#     p1.join()
#     p2.join()
#
#     stop_time=time.time()
#     print('主',(stop_time-start_time))# from multiprocessing import Process
# import time
#
# def task(name,n):
#     print('%s is running ' %name)
#     time.sleep(n)
#     print('%s is done ' % name)
#
#
# if __name__ == '__main__':
#     p1=Process(target=task,args=('子进程1',1))
#     p2=Process(target=task,args=('子进程2',2))
#     p3=Process(target=task,args=('子进程3',3))
#
#     start=time.time()
#     p1.start()
#     p1.join()
#     p2.start()
#     p2.join()
#     p3.start()
#     p3.join()
#                 #  这叫串行
#     stop=time.time()
#     print('主',(stop-start))# from multiprocessing import Process
# import time
#
# def task(name,n):
#     print('%s is running ' %name)
#     time.sleep(n)
#     print('%s is done ' % name)
#
#
# if __name__ == '__main__':
#     # p1=Process(target=task,args=('子进程1',1))
#     # p1.start()
#     # p2=Process(target=task,args=('子进程2',2))
#     # p2.start()
#     # p3=Process(target=task,args=('子进程3',3))
#     # p3.start()
#
#     p_l=[]
#     start=time.time()
#     for i in range(1,4):
#         p=Process(target=task,args=('子进程%s' %i,i))
#         p_l.append(p)
#         p.start()
#
#     # print(p_l)
#     for p in p_l:
#         p.join()
#
#     stop=time.time()
#
#     print('主',(stop-start))# pid
# from multiprocessing import Process
# import time
# import os
#
# def task(n):
#     print('%s is running ' %os.getpid())
#     time.sleep(n)
#     print('%s is done ' % os.getpid())
#
#
# if __name__ == '__main__':
#     p1=Process(target=task,args=(10,))
#     # print(p1.pid)
#     p1.start()
#     print(p1.pid) # 父进程内查看子pid的方式
#     print('主')from multiprocessing import Process
import time
import osdef task():print('自己的id：%s 父进程的id：%s ' %(os.getpid(),os.getppid()))time.sleep(200)if __name__ == '__main__':p1=Process(target=task)p1.start()print('主',os.getpid(),os.getppid())# 爹=》主--》儿子# 了解
# from multiprocessing import Process,current_process # 子进程的名字(current_process)
# import time
#
# def task():
#     print('子进程[%s]运行。。。。' %current_process().name)
#     time.sleep(200)
#
# if __name__ == '__main__':
#     p1=Process(target=task,name='子进程1')
#     p1.start()
#     # print(p1.name)
#     print('主')# from multiprocessing import Process,current_process
# import time
#
# def task():
#     print('子进程[%s]运行。。。。' %current_process().name)
#     time.sleep(2)
#
# if __name__ == '__main__':
#     p1=Process(target=task,name='子进程1')
#     p1.start()
#
#     # print(p1.is_alive())
#     # p1.join()
#     # print(p1.is_alive())
#
#     p1.terminate()  # 终止进程,应用程序给操作系统发送信号,让操作系统把这个子程序干掉
#                     # 至于多久能干死,在于操作系统什么时候执行这个指令
#     time.sleep(1)
#     print(p1.is_alive())  # 查看子进程是否存在,有返回值. True则存在,False则不存在
#     print('主')

进程对象的方法与属性

孤儿进程: 无害,会被孤儿院((linux的孤儿院)init)回收僵尸进程: 正常情况下无害(会掉用wait()方法进行回收操作), 在父进程无限循环,且不被回收的情况下会无限制的生成子进程从而占用大量的操作系统资源 　　 当操作系统被大量僵尸进程占满内存后,操作系统就无法在启动其他的程序守护进程

'''
1、守护进程守护进程其实就是一个“子进程”守护=》伴随守护进程会伴随主进程的代码运行完毕后而死掉2、为何用守护进程关键字就两个：进程：当父进程需要将一个任务并发出去执行，需要将该任务放到一个子进程里守护：当该子进程内的代码在父进程代码运行完毕后就没有存在的意义了，就应该将该子进程设置为守护进程，会在父进程代码结束后死掉
'''# from multiprocessing import Process
# import time,os
#
# def task(name):
#     print('%s is running' %name)
#     time.sleep(3)
#
# if __name__ == '__main__':
#     p1=Process(target=task,args=('守护进程',))
#     p2=Process(target=task,args=('正常的子进程',))
#
#     p1.daemon = True # 一定要放到p.start()之前
#     p1.start()
#     p2.start()
#
#     print('主')#主进程代码运行完毕,守护进程就会结束
from multiprocessing import Process
import time
def foo():print(123)time.sleep(1)print("end123")def bar():print(456)time.sleep(3)print("end456")if __name__ == '__main__':p1=Process(target=foo)p2=Process(target=bar)p1.daemon=Truep1.start()p2.start()print("main-------")'''main-------456enn456''''''main-------123456enn456''''''123main-------456end456'''

守护进程

互斥锁

#互斥锁：可以将要执行任务的部分代码（只涉及到修改共享数据的代码）变成串行
#join：是要执行任务的所有代码整体串行
from multiprocessing import Process,Lock    #  Lock 互斥锁模块
import json
import os
import time
import randomdef check():time.sleep(1) # 模拟网路延迟with open('db.txt','rt',encoding='utf-8') as f:dic=json.load(f)print('%s 查看到剩余票数 [%s]' %(os.getpid(),dic['count']))def get():with open('db.txt','rt',encoding='utf-8') as f:dic=json.load(f)time.sleep(2)if dic['count'] > 0:# 有票dic['count']-=1time.sleep(random.randint(1,3))with open('db.txt','wt',encoding='utf-8') as f:json.dump(dic,f)print('%s 购票成功' %os.getpid())else:print('%s 没有余票' %os.getpid())def task(mutex):# 查票
    check()#购票mutex.acquire() # 互斥锁不能连续的acquire，必须是release以后才能重新acquire
    get()mutex.release()  # 关闭互斥锁# with mutex:   # 开启与关闭互斥锁一种简单的写法#     get()if __name__ == '__main__':mutex=Lock()for i in  range(10):p=Process(target=task,args=(mutex,))p.start()# p.join()

互斥锁

IPC机制

#IPC：进程间通信，有两种实现方式
#1、pipe：管道
#2、queue：pipe+锁from multiprocessing import Queue# q=Queue(3) #先进先出
#注意：
#1、队列占用的是内存空间
#2、不应该往队列中放大数据，应该只存放数据量较小的消息
# 掌握的
q.put('first')
q.put({'k':'sencond'})
q.put(['third',])
# q.put(4)print(q.get())
print(q.get())
print(q.get())
print(q.get())
#

#了解的
# q=Queue(3) #先进先出
# q.put('first',block=True,timeout=3)
# q.put({'k':'sencond'},block=True,timeout=3)
# q.put(['third',],block=True,timeout=3)
# print('===>')
# # q.put(4,block=True,timeout=3)
#
#
# print(q.get(block=True,timeout=3))
# print(q.get(block=True,timeout=3))
# print(q.get(block=True,timeout=3))
# print(q.get(block=True,timeout=3))# q=Queue(3) #先进先出
# q.put('first',block=False,)
# q.put({'k':'sencond'},block=False,)
# q.put(['third',],block=False,)
# print('===>')
# # q.put(4,block=False,) # 队列满了直接抛出异常，不会阻塞
#
# print(q.get(block=False))
# print(q.get(block=False))
# print(q.get(block=False))
# print('get over')
# print(q.get(block=False))
#
q=Queue(3) #先进先出

q.put_nowait('first') #q.put('first',block=False,)
q.put_nowait(2)
q.put_nowait(3)
# q.put_nowait(4)  # 队列满了不会等待,直接抛出异常print(q.get_nowait())
print(q.get_nowait())
print(q.get_nowait())
print(q.get_nowait())  # 队列里没有数据了不会等待,直接抛出异常

IPC

生产者与消费者模型

'''
1 什么是生产者消费者模型生产者:比喻的是程序中负责产生数据的任务消费者:比喻的是程序中负责处理数据的任务生产者->共享的介质(队列)<-消费者2 为何用实现了生产者与消费者的解耦和,生产者可以不停地生产,消费者也可以不停地消费从而平衡了生产者的生产能力与消费者消费能力,提升了程序整体运行的效率什么时候用?当我们的程序中存在明显的两类任务,一类负责产生数据,另外一类负责处理数据此时就应该考虑使用生产者消费者模型来提升程序的效率'''
# from multiprocessing import Queue,Process
# import time
# import os
# import random
#
# def producer(q):
#     for i in range(10):
#         res='包子%s' %i
#         time.sleep(random.randint(1,3))
#         # 往队列里丢
#         q.put(res)
#         print('\033[45m%s 生产了 %s[0m' %(os.getpid(),res))
#     q.put(None)
#
# def consumer(q):
#     while True:
#         #从队列里取走
#         res=q.get()
#         if res is None:break
#         time.sleep(random.randint(1,3))
#         print('\033[46m%s 吃了 %s[0m' %(os.getpid(),res))
#
# if __name__ == '__main__':
#     q=Queue()
#     # 生产者们
#     p1=Process(target=producer,args=(q,))
#     # 消费者们
#     c1=Process(target=consumer,args=(q,))
#
#     p1.start()
#     c1.start()
#
#     print('主')# from multiprocessing import Queue,Process
# import time
# import os
# import random
#
# def producer(name,food,q):
#     for i in range(3):
#         res='%s%s' %(food,i)
#         time.sleep(random.randint(1,3))
#         # 往队列里丢
#         q.put(res)
#         print('\033[45m%s 生产了 %s\033[0m' %(name,res))
#     # q.put(None)
#
# def consumer(name,q):
#     while True:
#         #从队列里取走
#         res=q.get()
#         if res is None:break
#         time.sleep(random.randint(1,3))
#         print('\033[46m%s 吃了 %s\033[0m' %(name,res))
#
# if __name__ == '__main__':
#     q=Queue()
#     # 生产者们
#     p1=Process(target=producer,args=('egon','包子',q,))
#     p2=Process(target=producer,args=('杨军','泔水',q,))
#     p3=Process(target=producer,args=('猴老师','翔',q,))
#     # 消费者们
#     c1=Process(target=consumer,args=('Alex',q,))
#     c2=Process(target=consumer,args=('wupeiqidsb',q,))
#
#     p1.start()
#     p2.start()
#     p3.start()
#     c1.start()
#     c2.start()
#
#     p1.join()
#     p2.join()
#     p3.join()
#     # 在p1\p2\p3都结束后,才应该往队列里放结束信号,有几个消费者就应该放几个None
#     q.put(None)
#     q.put(None)# print('主')from multiprocessing import JoinableQueue,Process
import time
import os
import randomdef producer(name,food,q):for i in range(3):res='%s%s' %(food,i)time.sleep(random.randint(1,3))# 往队列里丢
        q.put(res)print('\033[45m%s 生产了 %s\033[0m' %(name,res))# q.put(None)def consumer(name,q):while True:#从队列里取走res=q.get()if res is None:breaktime.sleep(random.randint(1,3))print('\033[46m%s 吃了 %s\033[0m' %(name,res))q.task_done()  # 对主进程说我拿了一个数据走了if __name__ == '__main__':q=JoinableQueue()# 生产者们p1=Process(target=producer,args=('egon','包子',q,))p2=Process(target=producer,args=('杨军','泔水',q,))p3=Process(target=producer,args=('猴老师','翔',q,))# 消费者们c1=Process(target=consumer,args=('Alex',q,))c2=Process(target=consumer,args=('wupeiqidsb',q,))c1.daemon=Truec2.daemon=True  # 把消费者变成守护进程
p1.start()p2.start()p3.start()c1.start()c2.start()p1.join()p2.join()p3.join()q.join() #等待队列被取干净# q.join() 结束意味着# 主进程的代码运行完毕--->(生产者运行完毕)+队列中的数据也被取干净了->消费者没有存在的意义# print('主')

生产者与消费者模型

转载于:https://www.cnblogs.com/xiejintao0914/p/9302093.html

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

  1. linux 僵尸进程deffunc,多进程-开启子进程的两种方式，查看进程的pid与ppid，僵尸进程与孤儿进程...

    一.开启子进程的两种方式 方式一: # 方式一: from multiprocessing import Process import time def task(name): print(" ...

  2. 开启子进程的两种方式、进程间内存空间隔离、进程对象的方法或属性详解

    1.操作系统(推荐查看书籍:现代操作系统)     操作系统是位于计算机硬件与软件之间的控制程序     作用:         1.将硬件的复杂操作封装成简单的接口,给用户或者应用程序使用      ...

  3. 进程理论以及开启子进程的两种方式

    进程理论(book:现代操作系统) 为何开启子进程需要放在main下面:因为运行到start他会向操作系统发起启动子进程的信号,然后操作系统会把整个代码块执行下,找到子进程要执行的任务, 代码运行到最 ...

  4. 5.1.2 网络编程进阶---开启子进程的两种方式，进程之间内存空间是相互隔离的...

    当主进程开启子进程后,主进程会与子进程并行执行.当主进程执行后不会立马结束进程,而是会等子进程结束才结束,好去清理僵尸子进程(给子进程收尸). 进程之间内存是相互隔离的.当创建子进程时,会把父进程的内 ...

  5. python 开启子进程的两种方式

    进程: 是程序执行过程 启动进程,用某种方式开启子进程,帮咱们把咱们这个进程里的某一个任务并发执行以下 from multiprocessing import Process import timed ...

  6. 学习笔记(16):Python网络编程并发编程-开启子进程的两种方式

    立即学习:https://edu.csdn.net/course/play/24458/296424?utm_source=blogtoedu #方式一:使用python内置模块multiproces ...

  7. 开启子进程的两种方式

    方式一 from multiprocessing import Process import timedef task(name):print('%s is running' % name)time. ...

  8. 7 并发编程-(线程)-开启线程的两种方式

    thread/英 /θred/ 美 /θrɛd/  线程 1.threading模块介绍 multiprocess模块的完全模仿了threading模块的接口,二者在使用层面,有很大的相似性,因而不再 ...

  9. Python 35 线程（1）线程理论、开启线程的两种方式

    一:线程理论 1 什么是线程 进程其实一个资源单位,而进程内的线程才是cpu上的执行单位 线程其实指的就是代码的执行过程 2 为何要用线程    线程vs进程      1. 同一进程下的多个线程共享 ...

最新文章

  1. POPUP_TO_CONFIRM_WITH_VALUE
  2. python人脸识别环境搭建_怎样用3分钟搭建 Python 人脸识别系统
  3. ASP.NET 應用程式的安全性模型
  4. mysql 免费前端_MySQL
  5. php 流（Stream）
  6. HDU——2768 Cat vs. Dog
  7. Linus：“免费”不是最重要的，“源代码公开”才是，Linux 30岁生日快乐！
  8. 从零实现深度学习框架——逻辑回归简介
  9. 值得收藏的30道Python练手题（附详细答案）
  10. CDH运维常见问题-cloudera-scm-agent 已死,但 pid 文件存在
  11. 匹配查询（Match）
  12. 查看树莓派openwrt路由器 CPU 架构
  13. zealer情感机器人_你曾经想象的到来——中文版temi机器人
  14. 从反人工智能到反无人机，谁在左右科技的进步？
  15. 全文检索（elasticsearch入门）
  16. 【python】gensim corpora的简单使用
  17. Centos8使用yum安装Mysql
  18. 那些搁浅的爱情和梦想
  19. numpy均匀分布_Numpy的基本操作
  20. 通讯工程有必要考计算机二级吗,通信工程专业学生注意 你需要考这些证书！...

热门文章

  1. hadoop和spark主备HA配置说明
  2. PCB设计3W、20H、五五规则
  3. 矩阵乘法计算方法总结
  4. python3 笔记6 字符串
  5. Web端实现邮件发送
  6. wex5 教程之 图文讲解 Cloudx5一键部署
  7. AirPods 2支持无限充电只要15分钟充满
  8. PS基础入门（一.橡皮檫的介绍)
  9. 简单图文解释冯诺依曼体系结构（通俗易懂版）
  10. 【论文阅读】Efficient Illuminant Estimation for Color Constancy Using Grey Pixels