并发
内容回顾1
day31 操作系统
day32 并发进程阻塞第一天
# 74个人 8组 9/9/9/9/9/9/10/10
# 基于原生socket的udp协议实现将client端发送过来的消息放到字典中
# 字典的key是所有客户端的地址,value是一个列表
# io :输入输出,
# 输入到内存,向内存输入
# 从内存中向外(硬盘,网络)输出
# 操作系统的发展史
# 多道操作系统
# 分时操作系统
# 并发和并行
# 并发 : 多个程序在一个cpu上交替运行
# 并行 : 在多个cpu上同时有多个程序在执行
# 阻塞和非阻塞
# 指CPU是否在工作
# 在工作 :非阻塞
# 不在工作 :阻塞
# 同步和异步
# 调一个任务,需要等待这个任务执行完并返回结果,现在的代码才能继续
# 调一个任务,不关心这个任务是否执行是否完毕,只负责调用,余下的内容和我当前的代码是各自执行的
# 进程和程序
# 运行中的程序
# 是计算机中最小的资源分配单位
# 多个进程之间的数据互相隔离
# pid能够在操作系统中唯一标识一个进程
# 进程的三状态图 : 就绪 运行 阻塞
# 进程的创建和结束
# 进程的调度
# 先来先服务
# 短作业优先
# 分时/多道
# 多级反馈队列
# 登录
# input()
# input()
# 判断用户名密码
# import sys
# print(sys.argv)
# if sys.argv[1] == 'alex' and sys.argv[2] == 'alex3714':
# print('登录成功')
总结
# 1.开启子进程
# tartget
# args
# if __name__ == '__main__'
# start()
# 2.其他的方法
# 方法 :
# terminate()
# is_alive()
# 属性
# pid
# name
# 3.开启多个子进程
# 4.join
# 阻塞等待一个子进程结束
# 阻塞等待多个子进程结束
# 5.守护进程
# 6.面向对象的方式实现多进程
import os
from multiprocessing import Process
class MyProcess(Process):
def run(self): # 希望在子进程中执行的代码就放在run方法中
print(os.getpid())
if __name__ == '__main__':
for i in range(10):
MyProcess().start()
# import os
# from multiprocessing import Process
# class MyProcess(Process):
# def __init__(self, a, b):
# super().__init__()
# self.a = a
# self.b = b
#
# def func(self):
# print(1)
#
# def run(self): # 希望在子进程中执行的代码就放在run方法中
# print(os.getpid(), self.a, self.b)
# self.func()
#
# if __name__ == '__main__':
# for i in range(10):
# MyProcess(1,2).start() # 通知操作系统开进程,执行run方法
# import sys
# print(sys.modules[__name__])
# print(__name__)
# print(sys.modules)
# 明天要默写
# 0.内容回顾的概念
# 1.使用multiprocess起一个最简单的子进程,执行查看子进程的进程id
# 2.使用多进程实现socket tcp协议的并发server端
# 博客上有答案
# __main__': <module '__main__' from 'D:/program/feiq/Recv Files/python脱产班20期/day32 并发进程阻塞第一天/day32/5.Process类的总结.py'>
day33 生产者消费者
# 几个问题
# 1.概念多,练习少
# 2.不问问题
# 概念?代码?
# Process类
# 1.并发并行
# 并发 是同一时间段内多个任务交替使用同一个cpu
# 并行 是在同一个时刻多个任务在不同的cpu上同时执行
# 2.同步异步
# 同步 发布一个任务,要等待这个任务结束之后才能继续
# 异步 发布一个任务,不等待这个任务的结束就可以继续执行当前的内容
# 3.阻塞非阻塞
# 阻塞 : 在当前任务中cpu不工作
# 非阻塞 : cpu还在继续为当前程序在执行
# 4.start terminate join
# start\terminate 异步非阻塞
# join 同步阻塞
# 5.io操作
# i :输入到内存
# o :从内存向外(网络 硬盘)输出
# join
# import time
# import random
# from multiprocessing import Process
# def done(name):
# num = random.uniform(1, 3)
# print('start buy %s'%name,num)
# time.sleep(num)
# print('end buy %s' % name)
#
#
# if __name__ == '__main__':
# l = []
# p1 = Process(target=done,args=('橘子',))
# p1.start()
# l = [p1]
# p2 = Process(target=done, args=('苹果',))
# p2.start()
# l = [p1,p2]
# p3 = Process(target=done, args=('榴莲',))
# p3.start()
# l = [p1, p2,p3]
# p1.join() # 等买橘子的那个人回来 只关心p1这个子进程是否执行完
# print('买橘子的那个人回来了')
# p2.join() # 等买苹果的人回来
# print('买苹果的那个人回来了')
# p3.join() # 等待榴莲的人回来
# print('买榴莲的那个人回来了')
# import time
# import random
# from multiprocessing import Process
# def done(name):
# num = random.uniform(1, 3)
# print('start buy %s'%name,num)
# time.sleep(num)
# print('end buy %s' % name)
#
#
# if __name__ == '__main__':
# l = ['橘子','苹果','榴莲']
# p_l = []
# for fruit in l:
# p = Process(target=done,args=(fruit,))
# p.start()
# p_l.append(p)
# print(p_l)
# for p in p_l:
# p.join() # 阻塞 等橘子回来;阻塞 等苹果回来;阻塞 等榴莲回来
# join Process模块提供给我们的 对子进程同步管理的方法
# import time
# import random
# from multiprocessing import Process
# def done(name):
# num = random.uniform(1, 3)
# print('start buy %s'%name,num)
# time.sleep(num)
# print('end buy %s' % name)
#
#
# if __name__ == '__main__':
# l = ['橘子','苹果','榴莲']
# for fruit in l:
# p = Process(target=done,args=(fruit,))
# p.start()
# p.join()
# 开启进程 Process类
# 实例化的时候引用的参数 : target = 函数名,args=(参数1,)
# 方法 : start 开启进程 terminate 结束进程 join等待子进程结束
# 属性 :
# name 进程名 pid进程id
# daemon 一定要在start之前设置,设置一个子进程为守护进程,守护进程在主进程的代码结束之后结束
# 使用类的方式开启子进程
# from multiprocessing import Process
# class 类名(Process):
# def __init__(self,参数1,参数2):
# super().__init__()
# self.参数1 = 参数1
# self.参数2 = 参数2
# def run(self):
# '''要写在子进程中的代码
# 可以使用self中的所有参数'''
# pass
# if __name__ == '__main__':
# p = 类名('参数1','参数2')
# p.start()
# from multiprocessing import Process
# def func():pass
#
# if __name__ == '__main__':
# Process(target=func).start()
# a = 1
# print(a)
day34 线程bing'fa
# 2个人 5个题 面试题
# 7点 考试题
# 五一之前 要考试
# 其他内容(40%) 网编并发数据库(60%)
# 锁
# 互斥锁
# 能够保护数据的安全性
# 保证对于数据的修改操作同一时刻多个进程只有一个进程执行
# 进程数据不安全 : 同时修改文件/数据库/其他共享资源的数据
# 队列 -- 实现了进程之间的通信(IPC)
# 进程队列 -- 进程安全
# 从multiprocessing导入Queue
# q = Queue()
# put/get/put_nowait(丢数据)/get_nowait
# 基于 管道 + 锁,管道进程不安全
# 管道 基于文件级别的socket实现的
import queue
from multiprocessing import Queue
# q = Queue(5)
# q.put(1)
# q.put(1)
# q.put(1)
# q.put(1)
# q.put(1)
# print('________')
# try:
# q.put_nowait(1)
# except queue.Full:
# pass
# print('********')
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())
# try:
# print(q.get_nowait())
# except queue.Empty:
# pass
# 生产者消费者模型
# 一个生产数据和消费数据的完整的流程解耦成为两个部分 : 生产 和 消费
# 由于生产速度和消费速度不一致,所以需要我们调整生产者和消费者的个数来达到效率平衡
day35 线程守护线程——锁
# 互斥锁
# 在同一个进程中连续锁两次以上会死锁
# 进程的数据共享
# 进程之间可以共享数据
# 提供共享数据的类是Manager
# 但是他提供的list\dict这些数据类型是数据不安全的
# 针对 += -= *= /=
# 需要加锁来保证安全
# 用到了进程之间的通信
# 队列 queue
# 管道
# manager
# lock
# Process
# 线程
# 概念
# 进程和线程的区别
# 进程 开销大 数据隔离
# 是计算机中最小的资源分配单位
# 线程 轻量级 共享数据
# 是计算机中能被CPU调度的最小单位
# 正常的线程是什么样子
# 能同时被多个CPU执行
# Cpython解释器下的线程
# GIL锁
# 全局解释器锁
# 是Cpython解释器中的
# 会导致同一时刻只能有一个线程访问CPU
# 代码threading模块
# Thread类
# 开启线程
# 传参数
# join
# 没有terminate
# active_count int 当前程序中正在执行的线程个数
# current_thread 线程对象 能够获取当前线程的对象
# from multiprocessing import Process
# class MyProcess(Process):
# def __init__(self,args):
# super().__init__()
# self.args = args
#
# def run(self):
# print('子进程要执行',self.name)
#
# if __name__ == '__main__':
# p = MyProcess(1)
# p.start()
# p.name
#
# p2 = MyProcess(2)
# p2.start()
# p2.name
总结
# 守护线程
# 锁
# 互斥
# 递归
# 死锁现象
# 队列 线程安全的数据类型
# 先进先出
# 后进先出
# 优先级队列
# 池
# 控制进程的数量
# 节省资源开销
day36 协程 线程池
# 1.11:30
# 2.码云 :王老师检查作业+定期抽查
# 注册账号
# 3.考试的时间
# threading.enumerate(),能够获取到当前正在运行的所有线程对象列表
# 守护线程
# 守护线程会等待所有的非守护线程结束之后结束
# 守护线程的结束是因为主进程的结束
# 在start之前设置daemon = True
# 锁
# GIL锁 : 全局解释器锁,在Cpython解释器中,同一时刻同一个进程内只能有一个线程访问CPU
# 互斥锁
# 锁的是代码,一段代码被多个线程执行,并且要对全局的变量进行非原子性操作
# 互斥锁 : 在同一个线程中,不能连续acquire多次,并且可以做到多个线程中被锁的代码同时只有一个线程执行
# 递归锁 : 在同一个线程中,能连续acquire多次,并且可以做到多个线程中被锁的代码同时只有一个线程执行
# 从一定程度上可以避免死锁现象
# 使用递归锁也会产生死锁现象
# 死锁现象 : 只要实例化多把锁,并交替使用,都有可能产生死锁现象
# 只要是1把锁,递归锁永远不死锁
# 只要是2以及以上,交替使用,
# 只要是2以及以上,交替使用,递归锁互斥锁都可能死锁
# 队列
# from queue import Queue,LifoQueue,PriorityQueue
# queue这个模块提供的所有队列都是线程安全的
# 先进先出 Queue
# 后进先出 LifoQueue
# 优先级队列 PriorityQueue
# 进程池
# call_back回调函数
# concurrent.futures
# ProcessPoolExecutor
# from concurrent.futures import ProcessPoolExecutor
# pool = ProcessPoolExecutor(5)
# pool进程池对象
# ret = pool.map(func,iter)
# ret是一个可迭代对象,迭代器(惰性运算),可以直接通过for循环从ret中获取返回值
# submit
#1. for + submit(func,arg1,arg2) = map
# 任务对象task
#2. task = submit(func)
#3. task.result() 获取任务函数的返回值 (阻塞方法)
#4. task.add_done_callback(回调函数)
# shutdown
# pool.shutdown() 等待进程池中所有的任务都执行完毕之后结束阻塞
# import time
# from concurrent.futures import ProcessPoolExecutor
#
# def func():
# time.sleep(1)
# return '*'*20
#
# if __name__ == '__main__':
# p = ProcessPoolExecutor(4)
# task = p.submit(func)
# time.sleep(2)
# print('---->')
#
# print(task.result()) # 阻塞方法
# 池
# time/random 在任务中睡一会儿,在主线程可以睡一会儿
# threading.current_thread().ident
