python 进程之由浅入深

进程测试

import osimport time
while True:time.sleep(0.5)print("hahaha")print("self", os.getpid()) #获取自己的进程idprint("parent",os.getppid())  #parent 获取父进程的id

互斥锁

# """
#     当多个进程共享一个数据时,可能会造成数据错乱
#     1.使用join 来让这些进程 串行   但是这将造成 无法并发  并且 进程执行任务的顺序就固定了
#     2.使用锁  将需要共享的数据加锁   其他进程在访问数据时 就必须等待当前进程使用完毕
#
#     锁的本质 就是一个bool类型的数据   在执行代码前 会先判断 这个值
#     注意 在使用锁时 必须保证锁是同一个
#
#     互斥锁
#     互相排斥的锁
#
# """
#
from multiprocessing import Process,Lockimport random
import timedef task1(lock):lock.acquire()  # 是一个阻塞的函数  会等到别的进程释放锁才能继续执行lock.acquire()print("1my name is:bgon")time.sleep(random.randint(1,2))print("1my age is:78")time.sleep(random.randint(1, 2))print("1my sex is:femal")lock.release()def task2(lock):lock.acquire()print("2my name is:blex")time.sleep(random.randint(1, 2))print("2my age is:68")time.sleep(random.randint(1, 2))print("2my sex is:femal")lock.release()def task3(lock):pass
# 锁的实现原理 伪代码
# l = False
# def task3(lock):
#     global l
#     if l == False:
#         l = True
#         print("3my name is:常威")
#         time.sleep(random.randint(1, 2))
#         print("3my age is:68")
#         time.sleep(random.randint(1, 2))
#         print("3my sex is:femal")
#     l = Falseif __name__ == '__main__':lock = Lock()p1 = Process(target=task1,args=(lock,))p1.start()# p1.join()p2 = Process(target=task2,args=(lock,))p2.start()# p2.join()p3 = Process(target=task3,args=(lock,))p3.start()# p3.join()
#
# # 多个任务在共享一个数据时
# # 串行效率低 但是不会出问题
# # 并发效率高 但是数据可能错乱
#
#
## from multiprocessing import Lock,RLock,Process
#
# lock = Lock()
#
# lock.acquire()
# print("haha ")
# lock.acquire()
# print('test')
# lock.release()# RLock 表示可重入锁 特点是 可以多次执行acquire
# Rlock 在执行多次acquire时 和普通Lock没有任何区别
# 如果在多进程中使用Rlock  并且一个进程a 执行了多次acquire
# 其他进程b要想获得这个锁 需要进程a 把锁解开 并且锁了几次就要解几次
# 普通锁如果多次执行acquire将会锁死#
# lock = RLock()
# lock.acquire()
# lock.acquire()
# print("哈哈")
# lock.release()# import time
# def task(i,lock):
#     lock.acquire()
#     lock.acquire()
#     print(i)
#     time.sleep(3)
#     lock.release()
#     lock.release()
# #第一个过来 睡一秒  第二个过来了 睡一秒   第一个打印1  第二个打印2
#
# 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
import os#
def task(name):print(name)print("self",os.getpid())#66039print("parent", os.getppid())#66038print("task run")#  windows创建子进程时  子进程会将父进程的代码加载一遍  导致重复创建子进程
#  所以一定要将 创建子进程的代码放到main的下面
if __name__ == '__main__':print("self", os.getpid()) #66038print("parent", os.getppid()) #36520p = Process(target=task, name="这是子进程!",kwargs={"name":"bgon"})  # 创建一个表示进程的对象  但并不是真正的创建进程p.start()  # 给操作系统发送通知 要求操作系统开启进程# 创建进程的第二种方式  继承Process  覆盖run方法
# 在子进程启动以后会自动执行run方法
# 其优势是 可以自定义 进程的属性和行为 来完成一些额外任务 例如下载
# class MyProcess(Process):
#
#     def __init__(self,url):
#         self.url = url
#         super().__init__()
#
#     # 子类中的方法  只有run会被自动执行
#     def run(self):
#         print("下载文件...." , self.url)
#         print(" run run run!")
#
#     def task(self):
#         pass
#
# def task():
#     print(123)# if __name__ == '__main__':
#     p = MyProcess("www.baidu.com/xx.mp4")
#     p.start()

进程间内存相互独立

from multiprocessing import Processimport time
a = 1000000000000def task():global aprint(id(a))a = 0print("子进程的",a)if __name__ == '__main__':print(id(a))p = Process(target=task)p.start() # 给操作系统发送请求后 代码继续往下运行 至于子进程 什么时候创建 什么是执行 都跟当前进程没关系time.sleep(1)print("自己的",a)# 子进程中的数据修改 不会影响父进程

互斥锁的使用场景_抢票

import json
from multiprocessing import Process,Lock
import time
import random"""
join和锁的区别
1.join中顺序是固定的  不公平  
2.join是完全串行  而 锁可以使部分代码串行 其他代码还是并发 """# 查看剩余票数
def check_ticket(usr):time.sleep(random.randint(1,3))with open("ticket.json","r",encoding="utf-8") as f:dic = json.loads(f.read())print("%s查看 剩余票数:%s" % (usr,dic.get('count')))def buy_ticket(usr):with open("ticket.json","r",encoding="utf-8") as f:dic = json.load(f)if dic.get('count')> 0:time.sleep(random.randint(1,3))dic["count"] -= 1with open("ticket.json", "w", encoding="utf-8") as f2:json.dump(dic,f2)print("%s 购票成功!" % usr)else:print('剩余票:',dic.get('count'))print('Not Found of tiket!')def task(usr,lock):check_ticket(usr)# time.sleep(1)lock.acquire()buy_ticket(usr)lock.release()if __name__ == '__main__':lock = Lock()for i in range(10):p = Process(target=task,args=("用户%s" % i,lock))p.start()#p.join() # 只有第一个整个必须完毕 别人才能买 这是不公平的

父进程等待子进程结束


import time
from multiprocessing import Process# def task():
#     print("上传文件....")
#     time.sleep(3)
#     print("上传结束...")
#
#
# # [进程1,进程2,进程3]
#
# if __name__ == '__main__':
#     p = Process(target=task)
#     p.start()
#
#     p.join() # 本质上  是提高了子进程优先级   当CPU在切换时 会优先切子进程
#
#     print("上传文件成功!")def task(num):print("我是%s号 进程" % num)# time.sleep(1)print("=========")if __name__ == '__main__':start_time = time.time()ps = []for i in range(1,4):p = Process(target=task,args=(i,))p.start()print("----{}".format(i))# ps.append(p)for p in ps:p.join()print(time.time()-start_time)print("over")

process 常用属性

from multiprocessing import Processimport timedef task():# time.sleep(3)print("执行完毕!")if __name__ == '__main__':p = Process(target=task, name="alex")p.start()print(p.name)## # time.sleep(1)# print(p.is_alive())# #p.terminate()# #print(p.is_alive())# # print(p.pid)# p.terminate()  # 终止这个进程# print(p.pid)# print(p.is_alive())# p.daemon  # 守护进程

死锁

"""死锁 指的是 锁 无法打开了   导致程序死卡首先要明确  一把锁 时不会锁死的正常开发时 一把锁足够使用 不要开多把锁"""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("吃饭..")l1.release()l2.release()passdef task2(l1,l2,i):l2.acquire()print("筷子被%s抢走了" % i)l1.acquire()print("盘子被%s抢走了" % i)print("吃饭..")l1.release()l2.release()if __name__ == '__main__':l1 = Lock()l2 = Lock()Process(target=task1,args=(l1,l2,1)).start()Process(target=task2,args=(l1,l2,2)).start()

IPC 进程间通讯

"""IPC  进程间通讯由于进程之间内存是相互独立的 所以需要对应积极而方案 能够使得进程之间可以相互传递数据1.使用共享文件,多个进程同时读写同一个文件IO速度慢,传输数据大小不受限制2.管道 是基于内存的,速度快,但是是单向的 用起来麻烦(了解)3.申请共享内存空间,多个进程可以共享这个内存区域(重点)速度快但是 数据量不能太大
"""from multiprocessing import Manager,Process
#
# def task(m):
#
#     print(m["num"])
#
# if __name__ == '__main__':
#     # 开启了一个Manager
#     with Manager() as m:
#         m["num"] = 100 # 在这个空间中存储了一个num
#
#         for i in range(20):
#             p = Process(target=task,args=(m,))
#             p.start()
#
#from multiprocessing import Manager,Process,Lock
def work(d):# with lock:d['count']-=1if __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)

僵尸进程


import  time
from multiprocessing import  Process
def task1():print("子进程 run")if __name__ == '__main__':for i in range(10):p = Process(target=task1)p.start()time.sleep(100000)

队列

"""队列   不只用于进程间通讯也是一种常见的数据容器其特点是:先进先出其优点是:可以保证数据不会错乱 即使在多进程下  因为其put和get默认都是阻塞的对比堆栈刚好相反 :后进先出#"""from multiprocessing import Queue# q = Queue(1)  # 创建一个队列 最多可以存一个数据
#
# q.put("张三")
# print(q.get())
#
# q.put("李四") # put默认会阻塞 当容器中已经装满了
#
# print(q.get())
# print(q.get()) # get默认会阻塞 当容器中已经没有数据了
#
# print("over")q = Queue(1)  # 创建一个队列 最多可以存一个数据
#
q.put("张三")
# q.put("李四",False) # 第二个参数 设置为False表示不会阻塞 无论容器是满了 都会强行塞 如果满了就抛异常print(q.get())
print(q.get(timeout=3)) # timeout 仅用于阻塞时# q.put("李四") # put默认会阻塞 当容器中已经装满了
#
# print(q.get())
# print(q.get()) # get默认会阻塞 当容器中已经没有数据了
#
# print("over")

生产者消费者模型

"""什么是生产者 消费者 模型生产者 产生数据的一方消费者 处理数据的一方例如需要做一个爬虫1.爬取数据2.解析数据爬去和解析都是耗时操作,如果正常按照顺序来编写代码,将造成解析需要等待爬去  爬去取也需要等待解析这样效率是很低的要提高效率 就是一个原则 让生产者和消费解开耦合 自己干自己的如何实现:1.将两个任务分别分配给不同进程2.提供一个进程共享的数据容器"""
import random
from multiprocessing import Process,Queue
import time
# 爬数据
def get_data(q):for num in range(5):print("正在爬取第%s个数据" % num)time.sleep(random.randint(1,2))print("第%s个数据 爬取完成" % num)# 把数据装到队列中q.put("第%s个数据" % num)def parse_data(q):for num in range(5):# 取出数据data = q.get()print("正在解析%s" % data)time.sleep(random.randint(1, 2))print("%s 解析完成" % data)if __name__ == '__main__':# 共享数据容器q = Queue(5)#生产者进程produce =  Process(target=get_data,args=(q,))produce.start()#消费者进程customer = Process(target=parse_data,args=(q,))customer.start()

总结

1. 并发编程让你的程序可以同时处理多个任务2.并发的基石是 多道技术空间复用: 同一时间 内存存储了多个应用程序不同应用程序之间的内存是相互独立的时间复用: 当一个程序遇到了IO操作时 会切换到其他应用程序  ,以此来提高CPU的利用率多道技术的缺点: 当应用程序都是计算任务时 切换反而降低效率 (但是必须得切 才能保证多任务并发)3.并发 与 并行并发 多个事件 同时发生, 也称之为伪并行并行 多个事件 同时进行,阻塞和非阻塞 指的是程序的状态就绪  运行  阻塞4.两种使用进程的方式1.直接创建Process对象 指定target参数2.继承Process 覆盖run方法5.join函数提高优先级 使 父进程等待子进程结束6.孤儿进程与僵尸进程路径了解孤儿进程 是指 父进程已经终止了  但是自己还在运行  是无害的孤儿进程会自定过继给操作系统僵尸进程  是指 子进程执行完成所有任务 已经终止了但是 还残留一些信息(进程id 进程名)但是父进程 没有去处理这些残留信息 导致残留信息占用系统内存僵尸进程时有害的当出现大量的僵尸进程时 会占用系统资源 可以把它父进程杀掉  僵尸就成了孤儿 操作系统会负责回收数据

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/774913.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

LeetCode第五天(442. 数组中重复的数据)

给你一个长度为 n 的整数数组 nums ,其中 nums 的所有整数都在范围 [1, n] 内,且每个整数出现 一次 或 两次 。请你找出所有出现 两次 的整数,并以数组形式返回。 你必须设计并实现一个时间复杂度为 O(n) 且仅使用常量额外空间的算法解决此问…

C语言程序编译和链接

翻译环境和运行环境 我们程序员天天要写代码,那我们天天写的代码是什么呢?我们写的其实莫过于是一些test.c文件和test.h这样的文件。都是一些文本信息,这些如果直接交给机器去处理机器是看不懂的,就像我们和外国人语言不通一样&…

vue中src目录下views和components

在Vue项目中,src目录是项目的主要工作目录,其中包含项目的源代码。views和components是src目录下的两个重要子目录: views目录: views目录主要用于存放页面级别的Vue组件。这些组件通常与路由相对应,每个组件代表一个…

【LeetCode】21. 合并两个有序链表(Java自用版)

递归: 以下是使用递归方式实现的完整Java代码,用于将两个升序链表合并为一个新的升序链表: class ListNode {int val;ListNode next;ListNode(int x) { val x; } }class Solution {public ListNode mergeTwoLists(ListNode list1, ListNod…

团体程序设计天梯赛 L2-029 特立独行的幸福

L2-029 特立独行的幸福 分数 25 对一个十进制数的各位数字做一次平方和,称作一次迭代。如果一个十进制数能通过若干次迭代得到 1,就称该数为幸福数。1 是一个幸福数。此外,例如 19 经过 1 次迭代得到 82,2 次迭代后得到 68&…

如何使用ChatGPT准备即将到来的面试How to Use ChatGPT to Prepare for an Upcoming Interview

使用ChatGPT来准备即将到来的面试可以非常有帮助,因为它可以模拟真实的面试场景并提供反馈。以下是一些步骤和提示,说明如何利用ChatGPT进行面试准备: 研究职位和公司:在与ChatGPT对话之前,先对你申请的职位和公司进行…

物联网如何改善医疗保健服务和患者体验

物联网(IoT)在医疗保健领域的应用正在逐渐改变服务和患者体验的方式。通过物联网技术,医疗保健提供者能够实现更高效的患者管理、更精准的诊断以及更个性化的治疗方案。以下是物联网改善医疗保健服务和患者体验的几个方面: 远程监…

【计算机网络教程】(第六版)第2章课后习题答案

第二章 2-012-022-032-042-062-072-082-092-102-112-122-132-142-152-16 2-01 物理层要解决哪些问题?物理层的主要特点是什么? 答: 物理层要解决的主要问题: (1)物理层要尽可能地屏蔽掉物理设备和传输媒体&…

js算法记录

> 更多请前往 https://www.passerma.com/article/86 滑动窗口 1 给定一个矩阵,包含N*M个整数,和一个包含K个整数的数组。现在要求在这个矩阵中找一个宽度最小的子矩阵,要求子矩阵包含数组中所有的整数 function minSubmatrixWidth(mat…

JAVA面试大全之JVM和调休篇

目录 1、类加载机制 1.1、类加载的生命周期? 1.2、类加载器的层次? 1.3、Class.forName()和ClassLoader.loadClass()区别? 1.4、JVM有哪些类加载机制? 2、内存结构 2.1、说说JVM内存整体的结构?线程私有还是共享的? 2.2…

深入理解SSL协议:从理论到实践(二)

前言 这是一篇关于SSL协议的技术文章,有理论知识,但又兼具一定的实战性,文章的主要内容分享了SSL协议的核心概念、工作原理、常见的应用场景,以及就https这种实际应用场景,又着重分享具体的工作原理以及如何实现https…

鸿蒙HarmonyOS应用开发之使用Node-API接口创建ArkTs运行时环境

场景介绍 开发者通过pthread_create创建新线程后,可以通过napi_create_ark_runtime来创建一个新的ArkTs基础运行时环境,并通过该运行时环境加载ArkTs模块,目前仅支持在ArkTs模块中使用console接口打印日志,使用timer定时器功能。…

气体间隙的击穿强度

本篇为本科课程《高电压工程基础》的笔记。 气体间隙的击穿电压难以精确计算。工程应用中,大多参照一些典型的击穿电压试验数据来选择绝缘距离,要求较高的情况下感召实际电极布置,用实验方法来确定击穿电压。 稳态电压下的击穿 直流与工频…

SQL数据插入详解:单行与多行数据添加指南

在SQL(Structured Query Language,结构化查询语言)中,添加数据通常使用INSERT INTO语句。以下是如何使用INSERT INTO语句向数据库表中添加数据的详细步骤和示例。 基本语法 INSERT INTO table_name (column1, column2, column3,…

每天一个数据分析题(二百三十)

在神经网络的优化算法中,Adam优化算法是结合了哪两种优化技术的优点? A.动量 (Momentum) 和 Adagrad B.Nesterov 动量和 RMSprop C.RMSprop 和 动量 (Momentum) D.SGD 和 Nesterov 动量 题目来源于CDA模拟题库 点击此处获取答案

SpringBoot 多数据源及事务解决方案

1. 背景 一个主库和N个应用库的数据源,并且会同时操作主库和应用库的数据,需要解决以下两个问题: 如何动态管理多个数据源以及切换? 如何保证多数据源场景下的数据一致性(事务)? 本文主要探讨这两个问题的解决方案…

全量知识系统 详细设计 “祖传代码”之序 “元素周期表”(QA)之2

Q11.将三部分拿出来单独看一下:一、管理者-组传代码(祖传--宝藏:源头上保证): 二、代理者-软件代理(继承--差异:广度上扩展)。 三、提供者-AI组件(遗传--对齐:强度上增强…

第4章树与二叉树

属于二叉树 跟链表的不同:每个节点可以指向多个节点 所以直接改变next[n]就好 链表是树形结构特例 树的深度(高度): 层数 5 [1 4 5 7 8] 节点深度:从根节点开始,4的深度:[1 4] 1 节点高度:从叶子节点开始,4…

数字化时代下的电子元器件商城模式创新

在数字化时代,电子元器件商城可以通过以下方式进行模式创新: 智能化搜索与推荐: 引入人工智能和机器学习技术,提供智能化搜索和个性化推荐功能,根据客户的需求和历史购买记录推荐相关的电子元器件,以提高购…

全国植被类型分布数据

引言 全国植被类型分布数据利用 Landsat 卫星数据(Landsat TM,ETM和 OLI)完成了长时序的地表覆盖变化检测,并结合变化 检测结果实现了逐区域和逐期的地表覆盖动态更新,30米精细植被类型分布数据,共包含 2…