每日测验

  • 开启线程的两种方式

  • TCP服务端实现并发

  • 阐述互斥锁的概念

  • 什么是GIL

上周五内容回顾

  • 开启线程的两种方式

    ```python “”” 开进程和开线程的步骤基本都是一样的 只是导入的模块不一样而已 开进程代码必须写在main下面而开线程则无需这么做

类的对象调用方法 类的继承重写run方法 “””

  2. -    
  3. <a name="133451d9-1"></a>
  4. #### TCP服务端实现并发
  5. ```python
  6. """将接客与服务的活分开"""

  • 线程对象的join方法

    1. """等待当前线程对象结束之后 再继续往下执行"""

  • 同一个进程内的多个线程数据是共享的

    1. """
    2. 同一个进程内可以开设多个线程
    3. 进程:资源单位
    4. 线程:执行单位
    5. """

  • 线程对象属性和方法

    1. """
    2. current_thread
    3. active_count
    4. """

  • 守护线程

    ```python “”” 主线程必须等待所有非守护线程的结束才能结束 t.daemon = True t.start()

稍微迷惑人的例子 “””

  2. -    
  3. <a name="f91b35d9"></a>
  4. #### 线程互斥锁
  5. ```python
  6. """
  7. 当多个线程在操作同一份数据的时候可能会造成数据的错乱
  8. 这个时候为了保证数据的安全 我们通常都会加锁处理
  9. 锁:
  10.     将并发变成串行，降低了程序的运行效率但是保证了数据的安全
  12. 锁的问题在我们后面写代码的过程中一般都不会遇到，都是别人底层封装好的，无需你考虑
  14. 行锁 表锁
  15. """

  • GIL全局解释器锁

    1. """
    2. 1.GIL是CPython解释器的特点 不是python的特点！！！
    3. 2.GIL本质也是一把互斥锁 但是它是解释器级别的锁
    4. 3.它的存在是因为CPython解释器内存管理不是线程安全的
    5. 垃圾回收机制
    6.    引用计数
    7.    标记清除
    8.    分代回收
    9. 4.也就以为着GIL的存在导致了用一个进程下的多个线程无法利用多核优势(不能同时运行)
    10. 5.针对不同的数据应该加不同的锁来保证安全
    11. """

  • 验证python多线程是否有用

    ```python “”” 应该结合任务的具体类型再做判断 应该对任务分两种情况讨论

IO密集型 多线程更加节省资源 计算密集型 多进程更加合理

多进程多线程都是有用的，并且后面的操作都是多进程加上多线程从而达到效率的最大化 “””

  2. <a name="c7a1dd9a"></a>
  3. # 今日内容概要
  5. - 死锁与递归锁(了解)
  6. - 信号量(了解)
  7. - Event事件(了解)
  8. - 线程q(了解)
  9. - 进程池与线程池(掌握)
  10. - 协程(了解)
  11. - 协程实现TCP服务端的并发效果(了解)
  13. <a name="69f4f6b4"></a>
  14. # 今日内容详细
  16. <a name="55b2e629"></a>
  17. ### 死锁与递归锁(了解)
  19. 当你知道锁的使用抢锁必须要释放锁，其实你在操作锁的时候也极其容易产生死锁现象(整个程序卡死 阻塞)
  21. ```python
  22. from threading import Thread, Lock
  23. import time
  26. mutexA = Lock()
  27. mutexB = Lock()
  28. # 类只要加括号多次 产生的肯定是不同的对象
  29. # 如果你想要实现多次加括号等到的是相同的对象 单例模式
  32. class MyThead(Thread):
  33.     def run(self):
  34.         self.func1()
  35.         self.func2()
  37.     def func1(self):
  38.         mutexA.acquire()
  39.         print('%s 抢到A锁'% self.name)  # 获取当前线程名
  40.         mutexB.acquire()
  41.         print('%s 抢到B锁'% self.name)
  42.         mutexB.release()
  43.         mutexA.release()
  45.     def func2(self):
  46.         mutexB.acquire()
  47.         print('%s 抢到B锁'% self.name)
  48.         time.sleep(2)
  49.         mutexA.acquire()
  50.         print('%s 抢到A锁'% self.name)  # 获取当前线程名
  51.         mutexA.release()
  52.         mutexB.release()
  55. if __name__ == '__main__':
  56.     for i in range(10):
  57.         t = MyThead()
  58.         t.start()

递归锁(了解)

  1. """
  2. 递归锁的特点    
  3.     可以被连续的acquire和release
  4.     但是只能被第一个抢到这把锁执行上述操作
  5.     它的内部有一个计数器 每acquire一次计数加一 每realse一次计数减一
  6.     只要计数不为0 那么其他人都无法抢到该锁
  7. """
  8. # 将上述的
  9. mutexA = Lock()
  10. mutexB = Lock()
  11. # 换成
  12. mutexA = mutexB = RLock()

信号量(了解)

信号量在不同的阶段可能对应不同的技术点

在并发编程中信号量指的是锁!!!

  1. """
  2. 如果我们将互斥锁比喻成一个厕所的话
  3. 那么信号量就相当于多个厕所
  4. """
  5. from threading import Thread, Semaphore
  6. import time
  7. import random
  10. """
  11. 利用random模块实现打印随机验证码(搜狗的一道笔试题)
  12. """
  13. sm = Semaphore(5)  # 括号内写数字 写几就表示开设几个坑位
  16. def task(name):
  17.     sm.acquire()
  18.     print('%s 正在蹲坑'% name)
  19.     time.sleep(random.randint(1, 5))
  20.     sm.release()
  23. if __name__ == '__main__':
  24.     for i in range(20):
  25.         t = Thread(target=task, args=('伞兵%s号'%i, ))
  26.         t.start()

Event事件(了解)

一些进程/线程需要等待另外一些进程/线程运行完毕之后才能运行，类似于发射信号一样

  1. from threading import Thread, Event
  2. import time
  5. event = Event()  # 造了一个红绿灯
  8. def light():
  9.     print('红灯亮着的')
  10.     time.sleep(3)
  11.     print('绿灯亮了')
  12.     # 告诉等待红灯的人可以走了
  13.     event.set()
  16. def car(name):
  17.     print('%s 车正在灯红灯'%name)
  18.     event.wait()  # 等待别人给你发信号
  19.     print('%s 车加油门飙车走了'%name)
  22. if __name__ == '__main__':
  23.     t = Thread(target=light)
  24.     t.start()
  26.     for i in range(20):
  27.         t = Thread(target=car, args=('%s'%i, ))
  28.         t.start()

线程q(了解)

  1. """
  2. 同一个进程下多个线程数据是共享的
  3. 为什么先同一个进程下还会去使用队列呢
  4. 因为队列是
  5.     管道 + 锁
  6. 所以用队列还是为了保证数据的安全
  7. """
  8. import queue
  10. # 我们现在使用的队列都是只能在本地测试使用
  12. # 1 队列q  先进先出
  13. # q = queue.Queue(3)
  14. # q.put(1)
  15. # q.get()
  16. # q.get_nowait()
  17. # q.get(timeout=3)
  18. # q.full()
  19. # q.empty()
  22. # 后进先出q
  23. # q = queue.LifoQueue(3)  # last in first out
  24. # q.put(1)
  25. # q.put(2)
  26. # q.put(3)
  27. # print(q.get())  # 3
  29. # 优先级q   你可以给放入队列中的数据设置进出的优先级
  30. q = queue.PriorityQueue(4)
  31. q.put((10, '111'))
  32. q.put((100, '222'))
  33. q.put((0, '333'))
  34. q.put((-5, '444'))
  35. print(q.get())  # (-5, '444')
  36. # put括号内放一个元祖  第一个放数字表示优先级
  37. # 需要注意的是 数字越小优先级越高!!!

进程池与线程池(掌握)

先回顾之前TCP服务端实现并发的效果是怎么玩的

每来一个人就开设一个进程或者线程去处理

  1. """
  2. 无论是开设进程也好还是开设线程也好 是不是都需要消耗资源
  3. 只不过开设线程的消耗比开设进程的稍微小一点而已
  5. 我们是不可能做到无限制的开设进程和线程的 因为计算机硬件的资源更不上！！！
  6. 硬件的开发速度远远赶不上软件呐
  8. 我们的宗旨应该是在保证计算机硬件能够正常工作的情况下最大限度的利用它
  9. """
  10. # 池的概念
  11. """
  12. 什么是池?
  13.     池是用来保证计算机硬件安全的情况下最大限度的利用计算机
  14.     它降低了程序的运行效率但是保证了计算机硬件的安全 从而让你写的程序能够正常运行
  15. """

基本使用

  1. from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
  2. import time
  3. import os
  6. # pool = ThreadPoolExecutor(5)  # 池子里面固定只有五个线程
  7. # 括号内可以传数字 不传的话默认会开设当前计算机cpu个数五倍的线程
  8. pool = ProcessPoolExecutor(5)
  9. # 括号内可以传数字 不传的话默认会开设当前计算机cpu个数进程
  10. """
  11. 池子造出来之后 里面会固定存在五个线程
  12. 这个五个线程不会出现重复创建和销毁的过程
  13. 池子造出来之后 里面会固定的几个进程
  14. 这个几个进程不会出现重复创建和销毁的过程
  16. 池子的使用非常的简单
  17. 你只需要将需要做的任务往池子中提交即可 自动会有人来服务你
  18. """
  21. def task(n):
  22.     print(n,os.getpid())
  23.     time.sleep(2)
  24.     return n**n
  26. def call_back(n):
  27.     print('call_back>>>:',n.result())
  28. """
  29. 任务的提交方式
  30.     同步:提交任务之后原地等待任务的返回结果 期间不做任何事
  31.     异步:提交任务之后不等待任务的返回结果 执行继续往下执行
  32.         返回结果如何获取？？？
  33.         异步提交任务的返回结果 应该通过回调机制来获取
  34.         回调机制
  35.             就相当于给每个异步任务绑定了一个定时炸弹
  36.             一旦该任务有结果立刻触发爆炸
  37. """
  38. if __name__ == '__main__':
  39.     # pool.submit(task, 1)  # 朝池子中提交任务  异步提交
  40.     # print('主')
  41.     t_list = []
  42.     for i in range(20):  # 朝池子中提交20个任务
  43.         # res = pool.submit(task, i)  # <Future at 0x100f97b38 state=running>
  44.         res = pool.submit(task, i).add_done_callback(call_back)
  45.         # print(res.result())  # result方法   同步提交
  46.         # t_list.append(res)
  47.     # 等待线程池中所有的任务执行完毕之后再继续往下执行
  48.     # pool.shutdown()  # 关闭线程池  等待线程池中所有的任务运行完毕
  49.     # for t in t_list:
  50.     #     print('>>>:',t.result())  # 肯定是有序的
  51. """
  52. 程序有并发变成了串行
  53. 任务的为什么打印的是None
  54. res.result() 拿到的就是异步提交的任务的返回结果
  55. """

总结

  1. from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
  2. pool = ProcessPoolExecutor(5)
  3. pool.submit(task, i).add_done_callback(call_back)

协程

  1. """
  2. 进程:资源单位
  3. 线程:执行单位
  4. 协程:这个概念完全是程序员自己意淫出来的 根本不存在
  5.         单线程下实现并发
  6.         我们程序员自己再代码层面上检测我们所有的IO操作
  7.         一旦遇到IO了 我们在代码级别完成切换
  8.         这样给CPU的感觉是你这个程序一直在运行 没有IO
  9.         从而提升程序的运行效率
  11. 多道技术
  12.     切换+保存状态
  13.     CPU两种切换
  14.         1.程序遇到IO
  15.         2.程序长时间占用
  17. TCP服务端 
  18.     accept
  19.     recv
  21. 代码如何做到
  22.     切换+保存状态
  24. 切换
  25.     切换不一定是提升效率 也有可能是降低效率
  26.     IO切            提升
  27.     没有IO切 降低
  29. 保存状态
  30.     保存上一次我执行的状态 下一次来接着上一次的操作继续往后执行
  31.     yield
  32. """

验证切换是否就一定提升效率

  1. # import time
  2. #
  3. # # 串行执行计算密集型的任务   1.2372429370880127
  4. # def func1():
  5. #     for i in range(10000000):
  6. #         i + 1
  7. #
  8. # def func2():
  9. #     for i in range(10000000):
  10. #         i + 1
  11. #
  12. # start_time = time.time()
  13. # func1()
  14. # func2()
  15. # print(time.time() - start_time)
  17. # 切换 + yield  2.1247239112854004
  18. # import time
  19. #
  20. #
  21. # def func1():
  22. #     while True:
  23. #         10000000 + 1
  24. #         yield
  25. #
  26. #
  27. # def func2():
  28. #     g = func1()  # 先初始化出生成器
  29. #     for i in range(10000000):
  30. #         i + 1
  31. #         next(g)
  32. #
  33. # start_time = time.time()
  34. # func2()
  35. # print(time.time() - start_time)

gevent模块(了解)

安装

  1. pip3 install gevent
from gevent import monkey;monkey.patch_all()
import time
from gevent import spawn

"""
gevent模块本身无法检测常见的一些io操作
在使用的时候需要你额外的导入一句话
from gevent import monkey
monkey.patch_all()
又由于上面的两句话在使用gevent模块的时候是肯定要导入的
所以还支持简写
from gevent import monkey;monkey.patch_all()
"""


def heng():
    print('哼')
    time.sleep(2)
    print('哼')


def ha():
    print('哈')
    time.sleep(3)
    print('哈')

def heiheihei():
    print('heiheihei')
    time.sleep(5)
    print('heiheihei')


start_time = time.time()
g1 = spawn(heng)
g2 = spawn(ha)
g3 = spawn(heiheihei)
g1.join()
g2.join()  # 等待被检测的任务执行完毕 再往后继续执行
g3.join()
# heng()
# ha()
# print(time.time() - start_time)  # 5.005702018737793
print(time.time() - start_time)  # 3.004199981689453   5.005439043045044

协程实现TCP服务端的并发

# 服务端
from gevent import monkey;monkey.patch_all()
import socket
from gevent import spawn


def communication(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0: break
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()


def server(ip, port):
    server = socket.socket()
    server.bind((ip, port))
    server.listen(5)
    while True:
        conn, addr = server.accept()
        spawn(communication, conn)


if __name__ == '__main__':
    g1 = spawn(server, '127.0.0.1', 8080)
    g1.join()


# 客户端
from threading import Thread, current_thread
import socket


def x_client():
    client = socket.socket()
    client.connect(('127.0.0.1',8080))
    n = 0
    while True:
        msg = '%s say hello %s'%(current_thread().name,n)
        n += 1
        client.send(msg.encode('utf-8'))
        data = client.recv(1024)
        print(data.decode('utf-8'))


if __name__ == '__main__':
    for i in range(500):
        t = Thread(target=x_client)
        t.start()

总结

"""
理想状态:
    我们可以通过
    多进程下面开设多线程
    多线程下面再开设协程序
    从而使我们的程序执行效率提升
"""

作业

  • 针对了解知识点 过一遍 记到博客上即可
  • 正在进程池线程池需要掌握 那三句代码
  • 协程代码无需掌握 体验它的牛逼之处即可！！！
  • 复习巩固基础阶段的知识点