day33——进程的创建方式、pid、空间隔离、join方法、其他属性、守护进程
day33
进程创建的两种方式
在windows环境下,开启进程必须在______name______ == "main"下面
p.start(): 只是向操作系统发出一个开辟子进程的信号,然后就执行下一行了。
这个信号操作系统接收到之后,会从内存中开辟一个子进程空间,然后再将主进程所有数据copy加载到子进程,然后再调用cpu去执行
开辟子进程开销是狠大的,所以永远会先执行主进程的代码
开启进程的第一种方式
from multiprocessing import Process
import time
def task(name):
print(f"{name} is running")
time.sleep(2)
print(f"{name} is gone")
if __name__ == '__main__':
p = Process(target=task, args=("常鑫", ))
p.start()
time.sleep(0.3)
print("===主开始")
开启进程的第二种方式
一
from multiprocessing import Process
import time
class MyProcess(Process):
def run(self):
print(f"{self.name} is running")
time.sleep(2)
print(f"{self.name} is gone")
if __name__ == '__main__':
p = MyProcess()
p.start()
print("===主")
结果:
===主
MyProcess-1 is running
MyProcess-1 is gone
二
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
print(f"{self.name} is running")
time.sleep(2)
print(f"{self.name} is gone")
if __name__ == '__main__':
p = MyProcess("常鑫")
p.start()
print("===主")
结果:
===主
常鑫 is running
常鑫 is gone
简单应用
from multiprocessing import Process
import time
def task(name):
print(f"{name} is running")
time.sleep(3)
print(f"{name} is gone")
def task1(name):
print(f"{name} is running")
time.sleep(1)
print(f"{name} is gone")
def task2(name):
print(f"{name} is running")
time.sleep(2)
print(f"{name} is gone")
if __name__ == '__main__':
# 一个进程串行的执行三个任务
# start_time = time.time()
# task("常鑫")
# task1("离远点也")
# task("海狗")
# print(f"结束时间{time.time() - start_time}")
# 三个进程 并发或者并行的执行三个任务
start_time = time.time()
p1 = Process(target=task, args=("常鑫",))
p2 = Process(target=task1, args=("离远点也",))
p1.start()
p2.start()
task2("海狗")
print(f"结束时间{time.time() - start_time}")
进程pid
如何区分内存中的这些进程
- 命令行获取所有的进程的pid tasklist
代码级别如果获取一个进程pid
import os
print(os.getpid())
如何获取父进程(主进程)的pid?
import os
import time
print(f"子进程:{os.getpid()}")
print(f"主(父)进程:{os.getppid()})
time.sleep(50)
验证进程之间的空间隔离
from multiprocessing import Process
import os
import time
name = "太白"
def task():
global name
name = "刚子sb"
print(f"子进程:{name}")
if __name__ == '__main__':
p = Process(target=task)
p.start()
time.sleep(3)
print(f"主:{name}")
结果:
子进程:刚子sb
主:太白
from multiprocessing import Process
import os
import time
lst = ["丽丽"]
def task():
lst.append("怼姐")
print(f"子进程{lst}")
if __name__ == '__main__':
p = Process(target=task)
p.start()
time.sleep(3)
print(f"主:{lst}")
结果:
子进程['丽丽', '怼姐']
主:['丽丽']
进程对象join方法
join就是阻塞,主进程有join,join下面的代码一律不执行,直到子进程执行完毕之后再执行
单进程使用join
from multiprocessing import Process
import time
def task(name):
print(f"{name} is running")
time.sleep(2)
print(f"{name} is gone")
if __name__ == '__main__':
p = Process(target=task, args=("常鑫",))
p.start()
p.join()
print("===主开始")
结果:
常鑫 is running
常鑫 is gone
===主开始
多个子进程使用join
# 一
from multiprocessing import Process
import time
def task(name, sec):
print(f"{name} is running")
time.sleep(sec)
print(f"{name} is gone")
if __name__ == '__main__':
start_time = time.time()
p1 = Process(target=task, args=("常鑫",3))
p2 = Process(target=task, args=("李业",2))
p3 = Process(target=task, args=("海狗",1))
p1.start()
p2.start()
p3.start()
p1.join()
p2.join()
p3.join()
print(f"主:{time.time() - start_time}")
结果:
常鑫 is running
李业 is running
海狗 is running
海狗 is gone
李业 is gone
常鑫 is gone
主:3.1368300914764404
# 二
from multiprocessing import Process
import time
def task(name, sec):
print(f"{name} is running")
time.sleep(sec)
print(f"{name} is gone")
if __name__ == '__main__':
start_time = time.time()
p1 = Process(target=task, args=("常鑫", 1))
p2 = Process(target=task, args=("李业", 2))
p3 = Process(target=task, args=("海狗", 3))
p1.start()
p2.start()
p3.start()
p1.join()
print(f"p1:{time.time() - start_time}")
p2.join()
print(f"p2:{time.time() - start_time}")
p3.join()
print(f"主:{time.time() - start_time}")
结果:
常鑫 is running
李业 is running
海狗 is running
常鑫 is gone
p1:1.1349449157714844
李业 is gone
p2:2.14038348197937
海狗 is gone
主:3.1495747566223145
# 三
from multiprocessing import Process
import time
def task(name, sec):
print(f"{name} is running")
time.sleep(sec)
print(f"{name} is gone")
if __name__ == '__main__':
start_time = time.time()
p1 = Process(target=task, args=("常鑫", 3))
p2 = Process(target=task, args=("李业", 2))
p3 = Process(target=task, args=("海狗", 1))
p1.start()
p2.start()
p3.start()
p1.join()
print(f"p1:{time.time() - start_time}")
p2.join()
print(f"p2:{time.time() - start_time}")
p3.join()
print(f"主:{time.time() - start_time}")
结果:
常鑫 is running
李业 is running
海狗 is running
海狗 is gone
李业 is gone
常鑫 is gone
p1:3.1304543018341064
p2:3.1309428215026855
主:3.1309428215026855
面试题
# from multiprocessing import Process
# import time
#
# def task(name,sec):
# print(f'{name}is running')
# time.sleep(sec)
# print(f'{name} is gone')
#
#
# if __name__ == '__main__':
# start_time = time.time()
# p1 = Process(target=task,args=('常鑫',3))
# p2 = Process(target=task,args=('李业',2))
# p3 = Process(target=task,args=('海狗',1))
#
# p1.start()
# p2.start()
# p3.start()
# # join就是阻塞
#
# p1.join() # 等2s
# print(f'==主1:{time.time()-start_time}')
# p2.join()
# print(f'===主2:{time.time()-start_time}')
# p3.join()
# print(f'==主3:{time.time()-start_time}')
优化上面的代码
# 错误的示范
from multiprocessing import Process
import time
def task(sec):
print("is running")
time.sleep(sec)
print("is gone")
if __name__ == '__main__':
start_time = time.time()
for i in range(1,4):
p = Process(target=task, args=(i,))
p.start()
p.join()
print(f"总时间:{time.time() - start_time}")
# 正确的示范
from multiprocessing import Process
import time
def task(sec):
print("is running")
time.sleep(sec)
print("is gone")
if __name__ == '__main__':
l1 = []
start_time = time.time()
for i in range(1,4):
p = Process(target=task, args=(i,))
l1.append(p)
p.start()
for i in l1:
i.join()
print(f"总时间:{time.time() - start_time}")
进程对象其他属性
p.terminate():杀死子进程
p.is_alive():查看子进程是否存活,或者返回True,否则False
from multiprocessing import Process
import time
def task(name):
print(f"{name} is running")
time.sleep(2)
print(f"{name} is gone")
if __name__ == '__main__':
p = Process(target=task, args=("常鑫",))
# p = Process(target=task, args=("常鑫",), name="alex")
p.start()
# p.terminate()
print(p.is_alive())
# print(p.name) # alex
print("===主")
守护进程
例子:古时候,太监守护皇帝,如果皇帝驾崩了,太监直接也就死了。
子进程守护着主进程,只要主进程结束,子进程跟着就结束
from multiprocessing import Process
import time
def task(name):
print(f"{name} is running")
time.sleep(2)
print(f"{name} is gone")
if __name__ == '__main__':
p = Process(target=task, args=("常鑫",))
p.daemon = True # 将p子进程设置成守护进程,只要主进程结束,守护进程马上结束
p.start()
# p.daemon = True # 一定要在子进程开启之前设置
print("===主")
结果:===主
from multiprocessing import Process
import time
def task(name):
print(f"{name} is running")
time.sleep(2)
print(f"{name} is gone")
if __name__ == '__main__':
p = Process(target=task, args=("常鑫",))
p.daemon = True # 将p子进程设置成守护进程,只要主进程结束,守护进程马上结束
p.start()
# p.daemon = True # 一定要在子进程开启之前设置
time.sleep(1)
print("===主")
结果:
常鑫 is running
===主
day33——进程的创建方式、pid、空间隔离、join方法、其他属性、守护进程的更多相关文章
- 进程之 Process join方法其他属性与进程Queue
Process join方法 以及其他属性 在主进程运行过程中如果想并发地执行其他的任务,我们可以开启子进程,此时主进程的任务与子进程的任务分两种情况 情况一:在主进程的任务与子进程的任务彼此独立的情 ...
- python并发编程02 /多进程、进程的创建、进程PID、join方法、进程对象属性、守护进程
python并发编程02 /多进程.进程的创建.进程PID.join方法.进程对象属性.守护进程 目录 python并发编程02 /多进程.进程的创建.进程PID.join方法.进程对象属性.守护进程 ...
- 并发编程 - 进程 - 1.开启子进程的两种方式/2.查看pid/3.Process对象的其他属性或方法/4.守护进程
1.开启子进程的两种方式: # 方式1: from multiprocessing import Process import time def task(name): print('%s is ru ...
- 在C#/.NET应用程序开发中创建一个基于Topshelf的应用程序守护进程(服务)
本文首发于:码友网--一个专注.NET/.NET Core开发的编程爱好者社区. 文章目录 C#/.NET基于Topshelf创建Windows服务的系列文章目录: C#/.NET基于Topshelf ...
- Linux进程理解与实践(五)细谈守护进程
一. 守护进程及其特性 守护进程最重要的特性是后台运行.在这一点上DOS下的常驻内存程序TSR与之相似.其次,守护进程必须与其运行前的环境隔离开来.这些环境包括未关闭的文件描述符,控制终端, ...
- python网络编程--线程join和Daemon(守护进程)
一:什么情况下使用join join([timeout])调用join函数会使得主调线程阻塞,直到被调用线程运行结束或超时. 参数timeout是一个数值类型,用来表示超时时间,如果未提供该参数,那么 ...
- python学习笔记——线程threading (二)重写run()方法和守护进程daemon()
1 run()方法 1.1 单个线程 在threading.Thread()类中有run()方法. from time import ctime,sleep import threading # 定义 ...
- 进程和创建线程的两种方法(threading.Thread)
进程 如QQ 要以一个整体的形式暴露给操作系统管理,里面包含对各种资源的调用,内存的管理, 网络接口的调用等,进程就是各种资源管理的集合 线程:是操作系统最小的调度单位,是一串指令的结合 进程 要操作 ...
- 8.9 day30 并发编程 进程理论 进程方法 守护进程 互斥锁
多道技术 1.空间上的复用 多个程序共用一套计算机硬件 多道技术原理 2.时间上的复用 切换+保存状态 1.当一个程序遇到IO操作 操作系统会剥夺该程序的CPU执行权限( 提高了CPU的利用率 ...
随机推荐
- 使用vault pki 为nginx 生成tls 证书文件
关于vault pki 管理的使用的可以参考官方文档或者docker-vault 以下演示一个简单的基于vault pki 为nginx 提供tls 证书 项目环境配置 nginx 配置文件 wo ...
- RookeyFrame bin 目录
如果把bin目录删掉,重新生成的话,还需要加载很多东西哦,具体可以对比一下下载下来的文件
- 用pandas进行数据清洗(二)(Data Analysis Pandas Data Munging/Wrangling)
在<用pandas进行数据清洗(一)(Data Analysis Pandas Data Munging/Wrangling)>中,我们介绍了数据清洗经常用到的一些pandas命令. 接下 ...
- Mac下删除自己安装的Python
删除Python框架sudo rm -rf /Library/Frameworks/Python.framework/Versions/x.x 删除Python程序sudo rm -rf “/Appl ...
- Android程序员问答题
前言 最近三个月内,不断地进行移动应用开发在线测试题,也积累了不一样的知识.这也将对android studio有很好的掌握,对将来面试也很有好处.那么我就分享给大家.分享是一种幸福,这是一种质的飞越 ...
- 龙格-库塔法解常微分方程(c++)
用龙格库塔法计算 #include <iostream> #include<iomanip> #include <cmath> using namespace st ...
- 记一次edusoho问题
问题描述:Edusoho如何迁移到本地windows或另外一台Linux服务器上 解决问题步骤: 1.参考官方文档官方文档地址如下:http://www.qiqiuyu.com/my/course/3 ...
- JVM探究之 —— OOM异常
在Java虚拟机规范的描述中,除了程序计数器外,虚拟机内存的其他几个运行时区域都有发生OutOfMemoryError(下文称OOM)异常的可能.本节探究主要基于jdk1.8的内存结构. 1. Jav ...
- Nginx配置简单基于域名的虚拟主机
首先修改hosts文件,让浏览器在看到a.com或是www.a.com的网址时知道上哪里去找: # Copyright (c) 1993-2009 Microsoft Corp. # # This i ...
- shell case例子
-- --