并发

内容回顾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	erminate 异步非阻塞
    # 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
    # 但是他提供的listdict这些数据类型是数据不安全的
        # 针对 += -= *= /=
    # 需要加锁来保证安全

# 用到了进程之间的通信
    # 队列 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