同步异步

用来表达任务的提交方式

同步:提交任务之后原地等待任务的返回结果 期间不做任何事

异步:提交任务之后不愿等待任务的返回结果 直接去做其他事 有结果自动通知

eg:

​ 同步:客户端发送请求给服务端,在等待服务端响应的请求时,客户端不做其他的事情。当服务端做完了才返回到客户端。这样的话客户端需要一直等待

​ 异步:当客户端发送给服务端请求时,在等待服务端响应的时候,客户端可以做其他的事情,这样节约了时间,提高了效率

阻塞与非阻塞

用来表达任务的执行状态

阻塞和非阻塞这两个概念与程序(线程)等待消息通知(无所谓同步或者异步)时的状态有关 也就是说阻塞与非阻塞主要是程序(线程)等待消息通知时的角度来说的

阻塞:阻塞态

非阻塞:就绪态、运行态

综合使用

同步阻塞:效率最低 你一直在原地专心等待啥事也不干

异步阻塞:异步操作是可以被阻塞的 只不过他不是在处理消息时阻塞 而是在等待消息通知时被阻塞

同步非阻塞:需要在这两种不同的行为之间来回切换 效率低下

异步非阻塞:效率最高

总结:阻塞和非阻塞描述的是程序在等待调用结果(消息 返回值)时的状态;同步和异步描述的是消息通信的机制

创建进程的多种方式之multiprocess.process模块

  1. '''
  2. 1.鼠标双击软件图标
  3. 2.python代码创建进程
  4. '''
  5. multiprocess.process模块
  6. process模块是一个创建进程的模块
  7. from multiprocessing import Process
  8. import time
  9. def task():
  10. print('task is running')
  11. time.sleep(3)
  12. print('task is over')
  13. p1 = Process(target=task)
  14. p1.start()
  15. print('主进程')
  16. '''
  17. 在不同操作系统中穿创建进程底层原理不一样
  18. windows
  19. 以导入模块的形式创建进程
  20. linux/mac
  21. 以拷贝代码的形式创建进程
  22. '''

方式一

  1. from multiprocessing import Process
  2. import time
  3. def task(name):
  4. print('task is running', name)
  5. time.sleep(3)
  6. print('task is over', name)
  7. if __name__ == '__main__':
  8. # p1 = Process(target=task, args=('jason',)) # 位置参数
  9. p1 = Process(target=task, kwargs={'name': 'jason'}) # 关键字参数
  10. p1.start() # 异步 告诉操作系统创建一个新的进程 并在该进程中执行task函数
  11. print('主进程')

方式二

  1. from multiprocessing import Process
  2. import time
  3. class MyProcess(Process):
  4. def run(self):
  5. print('run is running')
  6. time.sleep(3)
  7. print('run is over')
  8. if __name__ == '__main__':
  9. obj = MyProcess()
  10. obj.start()
  11. print('我是主进程的')
  12. # 传参
  13. from multiprocessing import Process
  14. import time
  15. class MyProcess(Process):
  16. def __init__(self, name, age): # 传值需要从新重写双下init方法
  17. super().__init__() # 这里init括号不传参是因为 父类init里面的形参全是默认参数 需注意super所放的位置
  18. self.name = name # 这里的self是进程对象 给新产生的进程对象新增两个对象独有的属性name、age
  19. self.age = age
  20. # super().__init__()
  21. def run(self):
  22. print('run is running', self.name, self.age)
  23. time.sleep(3)
  24. print('run is over', self.name, self.age)
  25. if __name__ == '__main__':
  26. obj = MyProcess('jason', 123)
  27. obj.start()
  28. print('我是主进程的')

进程间数据隔离

  1. 同一台计算机上的多个进程数据是严格意义上的物理隔离(默认情况下)
  2. from multiprocessing import Process
  3. import time
  4. money = 10000
  5. def task():
  6. global money
  7. money = 888
  8. print('子进程的task函数查看money', money)
  9. if __name__ == '__main__':
  10. p1 = Process(target=task)
  11. p1.start()
  12. time.sleep(3)
  13. print(money)

上面我们看到,在windows中创建进程是相当于导模块的操作,因此可以看成子进程的代码相当于在另外一个py文件中执行,虽然用上了global改变全局变量,因为跟主进程不在一个文件,可以看成产生了数据隔离

进程的join方法

  1. from multiprocessing import Process
  2. import time
  3. def task(name):
  4. print('%s is running' % name)
  5. time.sleep(3)
  6. print('%s is over' % name)
  7. if __name__ == '__main__':
  8. P = Process(target=task, args=('jason',))
  9. P.start() # 异步
  10. P.join() # 主进程代码等待子进程代码运行结束再执行
  11. print('我是主进程的') # 这样主进程的永远都是最后打印
  12. # 变形
  13. from multiprocessing import Process
  14. import time
  15. def task(name, n):
  16. print('%s is running' % name)
  17. time.sleep(n)
  18. print('%s is over' % name)
  19. if __name__ == '__main__':
  20. p1 = Process(target=task, args=('jason1', 1))
  21. p2 = Process(target=task, args=('jason2', 2))
  22. p3 = Process(target=task, args=('jason3', 3))
  23. start_time = time.time()
  24. p1.start() # 主进程同时创建了3个子进程P1 P2 P3 在第一个P1进程执行时 时间为1秒 那么其他子进程P2 P3异步也执行了1秒 同理到在P2子进程时执行2秒 P3也执行了2秒了
  25. # p1.join()
  26. p2.start()
  27. # p2.join()
  28. p3.start()
  29. # p3.join() # 按顺序的话就是一个个来轮流执行 时间6秒多
  30. p1.join()
  31. p2.join()
  32. p3.join()
  33. print(time.time() - start_time) # 3秒多
  34. 打印结果:
  35. jason1 is running
  36. jason2 is running
  37. jason3 is running
  38. jason1 is over
  39. jason2 is over
  40. jason3 is over
  41. 3.097902297973633

IPC机制

  1. IPC:进程间通信
  2. 消息队列:储存数据的地方 所有人都可以存 也都可以取
  3. from mutiprocessing import Queue
  4. q = Queue(3) # 括号内可以指定存储数据的个数
  5. q.put(999) # 往队列里存放数据
  6. q.put(666)
  7. q.put(888)
  8. print(q.full()) # True 判断队列是否已满
  9. print(q.get()) # 999 从消息队列中取数据 按照先进先出取值
  10. print(q.empty()) # Flase 判断队列里是否为空
  11. from multiprocessing import Process,Queue
  12. def product(q):
  13. q.put('子进程获取队列中的数据' q.get())

full() empty() 在多进程中都不能使用


  1. from multiprocessing import Process, Queue
  2. def product(q):
  3. q.put('子进程p添加的数据')
  4. def consumer(q):
  5. print('子进程获取队列中的数据', q.get())
  6. if __name__ == '__main__':
  7. q = Queue()
  8. # 主进程往队列中添加数据
  9. # q.put('我是主进程添加的数据')
  10. p1 = Process(target=consumer, args=(q,))
  11. p2 = Process(target=product, args=(q,))
  12. p1.start()
  13. p2.start()
  14. print('我是主进程')

生产者 消费者模型

1.生产者

​ 负责生产数据的人

2.消费者

​ 负责处理数据的人

该模型除了有生产者和消费者之外还必须有消息队列(只有能够提供数据保存服务和提取服务的理论上都可以)

进程对象的多种方法

1.如何查看进程号

  1. 方式一
  2. from multiprocessing import Process, current_process
  3. def task():
  4. print(current_process())
  5. print(current_process().pid) # 获取当前进程的进程
  6. if __name__ == '__main__':
  7. p = Process(target=task)
  8. p.start()
  9. print(current_process())
  10. print(current_process().pid) # 获取当前进程的进程
  11. 方式二
  12. from multiprocessing import Process
  13. import os
  14. def task():
  15. print('我是子进程', os.getpid()) # 我是子进程 34604
  16. if __name__ == '__main__':
  17. p = Process(target=task)
  18. p.start()
  19. print('我是主进程', os.getpid()) # 我是主进程 40604
  20. print('我是pycharm进程编号', os.getppid) # 我是pycharm进程编号 33528 获取主进程的父进程

2.终止进程

  1. from multiprocessing import Process, current_process
  2. import time
  3. def task():
  4. print('子进程',current_process().pid) # 获取当前进程的进程
  5. if __name__ == '__main__':
  6. p = Process(target=task)
  7. p.start()
  8. # time.sleep(0.1)
  9. p.terminate() # 终止p子进程 也是异步操作
  10. print('主进程', current_process().pid) # 获取当前进程的进程



3.判断进程是否存活

  1. from multiprocessing import Process, current_process
  2. import time
  3. def task():
  4. print('子进程',current_process().pid) # 获取当前进程的进程
  5. if __name__ == '__main__':
  6. p = Process(target=task)
  7. p.start()
  8. # p.terminate()
  9. print(p.is_alive()) # 判断子进程是否存活
  10. # time.sleep(0.1)
  11. # p.terminate() # 终止p子进程 也是异步操作
  12. print('主进程', current_process().pid) # 获取当前进程的进程

守护进程

主进程创建守护进程

  其一:守护进程会在主进程代码执行结束后就终止

  其二:守护进程内无法再开启子进程,否则抛出异常:

AssertionError: daemonic processes are not allowed to have children

注意:进程之间是互相独立的,主进程代码运行结束,守护进程随即终止

  1. 守护进程会随着守护的进程结束而立刻结束
  2. eg: 吴勇是张红的守护进程 一旦张红嗝屁了 吴勇立刻嗝屁
  3. from multiprocessing import Process
  4. import time
  5. def task(name):
  6. print('德邦总管:%s' % name)
  7. time.sleep(3)
  8. print('德邦总管:%s' % name)
  9. if __name__ == '__main__':
  10. p1 = Process(target=task, args=('大张红',))
  11. p1.daemon = True
  12. p1.start()
  13. time.sleep(1)
  14. print('恕瑞玛皇帝:小吴勇嗝屁了')

僵尸进程与孤儿进程

  1. 僵尸进程
  2. 进程执行完毕后并不会立刻销毁所有的数据 会有一些信息短暂保留下来‘
  3. 比如进程号、进程执行时间、进程消耗功率等给父进程查看
  4. ps:所有的进程都会变成僵尸进程
  5. 孤儿进程
  6. 子进程正常运行 父进程意外死亡 操作系统针对孤儿进程会派遣福利院管理

多进程数据错乱问题

  1. 模拟抢票软件
  2. from multiprocessing import Process
  3. import time
  4. import json
  5. import random
  6. # 查票
  7. def search(name):
  8. with open(r'data.json', 'r', encoding='utf8') as f:
  9. data = json.load(f)
  10. print('%s在查票 当前余票为:%s' % (name, data.get('ticket_num')))
  11. # 买票
  12. def buy(name):
  13. # 再次确认票
  14. with open(r'data.json', 'r', encoding='utf8') as f:
  15. data = json.load(f)
  16. # 模拟网络延迟
  17. time.sleep(random.randint(1, 3))
  18. # 判断是否有票 有就买
  19. if data.get('ticket_num') > 0:
  20. data['ticket_num'] -= 1
  21. with open(r'data.json', 'w', encoding='utf8') as f:
  22. json.dump(data, f)
  23. print('%s买票成功' % name)
  24. else:
  25. print('%s很倒霉 没有抢到票' % name)
  26. def run(name):
  27. search(name)
  28. buy(name)
  29. if __name__ == '__main__':
  30. for i in range(10):
  31. p = Process(target=run, args=('用户%s'%i, ))
  32. p.start()
  33. """
  34. 多进程操作数据很可能会造成数据错乱>>>:互斥锁
  35. 互斥锁
  36. 将并发变成串行 牺牲了效率但是保障了数据的安全
  37. """

同步异步、mutiprocessing创建进程process模块及进程对象的多种方法、消息队列Queue的更多相关文章

  1. 第三十天- 进程 Process模块 空间隔离

    1.进程: 进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础.在早期面向进程设计的计算机结构中,进程是程序的基本执行实体: ...

  2. python中datetime模块中datetime对象的使用方法

    本文只讲述datetime模块中datetime对象的一些常用的方法,如果读者需要更多datetime模块的信息,请查阅此文档. datetime模块的对象有如下: timedelta date da ...

  3. GCD,用同步/异步函数,创建并发/串行队列

    队列  第一个参数:C语言字符串,标签 第二个参数: DISPATCH_QUEUE_CONCURRENT:并发队列 DISPATCH_QUEUE_SERIAL:串行队列 dispatch_queue_ ...

  4. 鸿蒙内核源码分析(消息队列篇) | 进程间如何异步传递大数据 | 百篇博客分析OpenHarmony源码 | v33.02

    百篇博客系列篇.本篇为: v33.xx 鸿蒙内核源码分析(消息队列篇) | 进程间如何异步传递大数据 | 51.c.h .o 进程通讯相关篇为: v26.xx 鸿蒙内核源码分析(自旋锁篇) | 自旋锁 ...

  5. C# ABP - 创建自己的模块

    本篇文章介绍怎么创建自己的模块,并且使用依赖注入方法进行模块间的无缝结合. 我们创建一下自己的一个会员模块,针对不同的系统都可以用.你们可以看看我是怎么做的,或者从中得到启发. 目录 1.开始创建项目 ...

  6. python---基础知识回顾(十)进程和线程(进程)

    前戏:进程和线程的概念 若是学过linux下的进程,线程,信号...会有更加深刻的了解.所以推荐去学习下,包括网络编程都可以去了解,尤其是对select,poll,epoll都会有更多的认识. 进程就 ...

  7. 8.7 进程间的通讯:管道、消息队列、共享内存、信号量、信号、Socket

    进程间的通讯 进程间为什么需要通讯? 共享数据.数据传输.消息通知.进程控制 进程间的通讯有哪些类型? 首先,联系前面讲过的知识,进程之间的用户地址空间是相互独立的,不能进行互相访问,但是,内核空间却 ...

  8. linux 进程学习笔记-消息队列messagequeue

    可以想象,如果两个进程都可以访问同一个队列:其中一个进程(sender)向其中写入结构化数据,另外一个进程(receiver)再从其中把结构化的数据读取出来.那么这两个进程就是在利用这个队列进行通信了 ...

  9. day43-python消息队列二-queue模块

    Python提供了Queue模块来专门实现消息队列Queue对象 Queue对象实现一个fifo队列(其他的还有lifo.priority队列,这里不再介绍).queue只有maxsize一个构造参数 ...

  10. {Python之进程} 背景知识 什么是进程 进程调度 并发与并行 同步\异步\阻塞\非阻塞 进程的创建与结束 multiprocess模块 进程池和mutiprocess.Poll

    Python之进程 进程 本节目录 一 背景知识 二 什么是进程 三 进程调度 四 并发与并行 五 同步\异步\阻塞\非阻塞 六 进程的创建与结束 七 multiprocess模块 八 进程池和mut ...

随机推荐

  1. Git Review + Gerrit 安装及使用完成 Code-Review

    转载自:https://cloud.tencent.com/developer/article/1010615 1.Code Review 介绍 Code Review 代码评审是指在软件开发过程中, ...

  2. 11_Swagger

    一. 引言 Swagger 是一个规范和完整的框架,用于生成.描述.调用和可视化 RESTful 风格的 Web 服务. 总体目标是使客户端和文件系统作为服务器以同样的速度来更新.文件的方法.参数和模 ...

  3. 密码学奇妙之旅、03 HMAC单向散列消息认证码、Golang代码

    HMAC 单向散列消息认证码 消息认证码MAC是用于确认完整性并进行认证的技术,消息认证码的输入包括任意长度的消息和一个发送者和接收者之间共享的密钥(可能还需要共享盐值). HMAC是使用单向散列函数 ...

  4. Java实现6种常见排序

    1.冒泡排序(Bubble Sort) 第0轮 3 1 4 1 5 9 2 6 5 3 5 8 9 第1轮 1 3 1 4 5 2 6 5 3 5 8 9 9 第2轮 1 1 3 4 2 5 5 3 ...

  5. SpringBoot实战派读书笔记---响应式编程

    1.什么是WebFlux? WebFlux不需要Servlet API,在完全异步且无阻塞,并通过Reactor项目实现了Reactor Streams规范. WebFlux可以在资源有限的情况下提高 ...

  6. 谣言检测(DUCK)《DUCK: Rumour Detection on Social Media by Modelling User and Comment Propagation Networks》

    论文信息 论文标题:DUCK: Rumour Detection on Social Media by Modelling User and Comment Propagation Networks论 ...

  7. 6.pygame-搭建主程序

    职责明确 新建plane_main.py 封装主游戏类 创建游戏对象 启动游戏   新建plane_sprites.py 封装游戏中所有需要使用的精灵子类 提供游戏的相关工具 #plane_sprit ...

  8. 17_Vue列表过滤_js模糊查询

    列表过滤 需求分析 这里呢有张列表,假设这个列表有一百多条数据 当我在这个 搜索框当中 搜索 单个关键字的时候 (冬,周,伦),它能把带了这几个关键字的信息都给我罗列出来 === 跟数据库的 模糊查询 ...

  9. 栈溢出漏洞利用流程——以syncbrs为例

    0x1 缓冲区溢出漏洞攻击简介 缓冲区溢出攻击是针对程序设计缺陷,向程序输入缓冲区写入使之溢出的内容(通常是超过缓冲区能保存的最大数据量的数据),从而破坏程序的堆栈,使程序转而执行其他指令,以达到攻击 ...

  10. 现代 CSS 指南 -- at-rule 规则扫盲

    大部分同学都用过 CSS 的屏幕宽度媒体查询,像是这样: @media screen and (min-width: 900px) { div { padding: 1rem 3rem; } } 这里 ...