并发编程

多道技术

单核实现并发的效果

必备知识点

• 并发

  看起来像同时运行的就可以称之为并发

• 并行

  真正意义上的同时执行

空间与时间上的复用

​ 空间上：多个程序公用一套计算机硬件

​ 时间上：切换+保存状态

ps：

• 并行肯定算并发
• 单核的计算机肯定不能实现并行，但是可以实现并发

补充：假设单核就是一个核，不考虑CPU的内核数

多道技术图解

多道技术重点知识

"""
切换（cpu）分为两种情况
    1.当一个程序遇到IO操作的时候，操作系统会剥夺该程序的CPU执行权限
            作用：提高了CPU的利用率，并且也不影响程序的执行效率
            
    2.当一个程序长时间占用CPU的时候，操作系统也会剥夺该程序的CPU执行权限
            作用：降低了程序的执行效率（程序运行时间+切换时间）
"""

进程理论

必备知识点

进程与程序的区别

"""
程序就是一堆躺在硬盘上的代码，是“死”的
进程则表示程序正在执行的过程，是“活”的
"""

进程调度

• 先来先服务调度算法

  ​ 对长作业有利，对短作业无益

• 短作业优先调度算法

  ​ 对短作业有利，对长作业无益

• 时间片轮转法+多级反馈队列

进程运行的三状态图

示例：

两对重要概念

• 同步和异步

  描述的是任务的提交方式

  同步：任务提交之后，原地等待任务的返回结果，等待的过程中不做任何事（干等）

  ​ 程序层面上表现的感觉就是卡住了

  异步：任务提交之后，不原地等待任务的返回结果，直接去做其他事

​ 我提交的任务结果如何获取？

​ 任务的返回结果会有一个异步回调机制自动处理

• 阻塞非阻塞

  描述的程序的运行状态

  阻塞：阻塞态

  非阻塞：就绪态、运行态

上述概念的组合：最高效的一种组合就是 <u>异步非阻塞</u>

理想状态：我们写的代码永远处于就绪态和运行态之间切换（但基本不可能）

开启进程的两种方式

# 第一种 直接定义函数 常用
from multiprocessing import Process
import time


def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over' % name)


if __name__ == '__main__':
    # 1、创建一个进程对象
    p = Process(target=task, args=('jason',))
    """
    target=要运行的函数
    args=(函数需要的参数)
    """
    # 2、开启进程
    p.start()  # 告诉操作系统帮你创建一个进程 异步
    print('主')
"""
windows操作系统下 创建进程一定要在main内创建
因为windows下创建进程类似于模块导入的方式
会从上往下依次执行代码
Linux中则是直接将代码完整拷贝一份
"""

# 第二种方式 类的继承 不常用
from multiprocessing import Process
import time


class MyProcess(Process):  # 定义一个类继承自Process，类名可以自定义
    def run(self):  # 将要运行的功能写入函数，函数名必须叫run！！
        print('hello beautiful girl!')
        time.sleep(1)
        print('get out!')


if __name__ == '__main__':
    p = MyProcess()
    p.start()
    print('主')

总结

创建进程就是在内存中申请一块内存空间将需要运行的代码丢进去

一个进程对应在内存中就是一块独立的内存空间

多个进程对应在内存中就是多块独立的内存空间

进程与进程之间数据默认情况下是无法直接交互，想交互可以借助第三方工具、模块

join方法

join是让主进程的代码等待子进程代码运行结束之后，再继续运行。不影响其他子进程的执行

from multiprocessing import Process
import time


def task(name, n):
    print('%s is running' % name)
    time.sleep(n)
    print('%s is over' % name)


if __name__ == '__main__':
    # p1 = Process(target=task, args=('jason', 1))
    # p2 = Process(target=task, args=('egon', 2))
    # p3 = Process(target=task, args=('tank', 3))
    # start_time = time.time()
    # p1.start()
    # p2.start()
    # p3.start()  # 仅仅是告诉操作系统要创建进程
    # p1.join()  # 主进程等待子进程p运行结束之后再继续往后执行
    # p2.join()
    # p3.join()
    start_time = time.time()
    p_list = []
    for i in range(1, 4):
        p = Process(target=task, args=('子进程%s' % i, i))
        p.start()
        p_list.append(p)  # 将起起来的所有进程对象放入一个列表中
    for p in p_list:
        p.join()  # 主进程等待每一个子进程p运行结束之后再继续往后执行
    print('主', time.time() - start_time)


    
>>>:子进程1 is running
    子进程3 is running
    子进程2 is running
    子进程1 is over
    子进程2 is over
    子进程3 is over
    主 3.059741973876953

进程间数据隔离（默认情况下）

from multiprocessing import Process

money = 100


def task():
    global money  # 局部修改全局
    money = 666
    print('子', money)


if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()
    print(money)

进程对象及其他方法

一台计算机上面运行着很多进程，那么计算机是如何区分并管理这些进程服务端的呢？

计算机会给每一个运行的进程分配一个PID号

如何查看

​ Windows 进入 cmd 输入tasklist查看全部进程，tasklist |findstr PID查看具体的进程（PID是具体的进程号）

​ Mac 进入 终端 输入ps aux查看全部进程，ps aux|grep PID查看具体的进程（PID是具体的进程号）

from multiprocessing import Process, current_process
import os

current_process().pid  # 查看当前进程号
os.getpid()  # 查看当前进程号
os.getppid()  # 查看当前进程的父进程号

from multiprocessing import Process, current_process
import time


def task():
    print('%s is running' % current_process().pid)  # current_process().pid 查看当前进程的进程号
    time.sleep(3)


if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    print('主', current_process().pid)

from multiprocessing import Process
import time
import os


def task():
    print('%s is running' % os.getpid())  # 查看当前进程的进程号
    print('子进程的主进程号：%s' % os.getppid())  # 查看当前进程的父进程的进程号
    time.sleep(3)


if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    print('主', os.getpid())
    print('主主', os.getppid())

p.terminate()  # 杀死当前进程
# 告诉操作系统帮你去杀死当前进程 但是需要一定的时间 而代码的运行速度极快
time.sleep(0.1)  # 加入一个 time.sleep() 就可以得到正确结果
print(p.is_alive())  # 判断当前进程是否存活

僵尸进程与孤儿进程

• 僵尸进程

  死了但是没有死透

  当你开设了子进程之后 该进程死后不会立刻释放占用的进程号

  因为我要让父进程能够查看到它开设的子进程的一些基本信息（占用的pid号、运行时间等）

  所有的进程都会步入僵尸进程

  ​ 有害的情况：父进程不死并且在无限制的创建子进程并且子进程也不结束

  ​ 回收子进程占用的pid号两种情况：

  ​ 1、父进程等待子进程运行结束

  ​ 2、父进程调用 join 方法（等同于等待子进程运行结束）

• 孤儿进程

  子进程存活，父进程意外死亡

  操作系统会开设一个“儿童福利院”专门管理孤儿进程回收相关资源

守护进程

from multiprocessing import Process
import time


def task(name):
    print('%s 总管正在活着' % name)
    time.sleep(3)
    print('%s 总管正在死亡' % name)


if __name__ == '__main__':
    p = Process(target=task, args=('纵观',))
    p.daemon = True  # 将进程 p 设置成守护进程 这一句代码要放在 p.start 上面才有效
    p.start()
    print('皇帝寿终正寝')

互斥锁

多个进程操作同一份数据的时候，会出现数据错乱的问题

针对上述问题，解决方式就是加锁处理：将并发变成串行，牺牲效率但是保证了数据的安全

from multiprocessing import Process, Lock
import json
import time
import random


# 查票
def search(i):
    # 文件操作读取票数
    with open('data', 'r', encoding='utf8') as f:
        dic = json.load(f)
    print('用户 %s 查询余票：%s' % (i, dic.get('ticket_num')))  # 字典取值不要用[]，要用.get()


# 买票  1、先查  2、再买
def buy(i):
    # 先查票
    with open('data', 'r', encoding='utf8') as f:
        dic = json.load(f)
    # 模拟网络延迟
    time.sleep(random.randint(1, 3))
    # 判断当前是否有票
    if dic.get('ticket_num') > 0:
        # 修改数据库买票
        dic['ticket_num'] -= 1
        # 写入数据库
        with open('data', 'w', encoding='utf8') as f:
            json.dump(dic, f)
        print('用户 %s 买票成功！' % i)
    else:
        print('用户 %s 买票失败' % i)


# 整合上面两个函数
def run(i, mutex):
    search(i)
    # 给买票环节加锁处理
    # 抢锁
    mutex.acquire()  # 所有人随机抢锁，一个人抢到，程序继续运行
    buy(i)
    # 释放锁
    mutex.release()  # 买完票，将锁释放，供剩下的人抢


if __name__ == '__main__':
    # 在主进程中生成一把锁 让所有的子进程抢 谁先抢到谁先买票
    mutex = Lock()
    for i in range(1, 11):
        p = Process(target=run, args=(i, mutex))
        p.start()

注意：

​ 1、锁不要轻易使用，容易造成死锁现象（一般不会用到，都是内部封装好的）

​ 2、锁只在处理数据的部分来保证数据安全（只在争抢数据的环节加锁处理即可）

进程间通信

进程之间是无法直接进行数据交互的，但是可以通过队列或管道实现数据交互

队列Queue模块

​ 管道：subprocess(stdin stdout stderr)

​ 队列：管道 + 锁

​ 队列：先进先出

​ 堆栈：先进后出

from multiprocessing import Queue
# import queue 也可以


# 创建一个队列
q = Queue(5)  # 括号内可以传数字 表示生成的队列最大可以同时存放的数据量

# 往队列中存数据
q.put(111)
q.put(222)
q.put(333)
print(q.full())  # 判断当前队列是否满了
print(q.empty())  # 判断当前队列是否空了
q.put(444)
q.put(555)
print(q.full())  # 判断当前队列是否满了
# q.put(666)  # 当队列数据放满了之后 如果还有数据要放 程序会阻塞 直到有位置让出来

# 去队列中取数据
v1 = q.get()
v2 = q.get()
v3 = q.get()
v4 = q.get()
v5 = q.get()
print(q.empty())  # 判断当前队列是否空了
# v6 = q.get_nowait()  # 没有数据直接报错 queue.Empty
# v6 = q.get(timeout=3)  # 没有数据之后原地等待三秒 没有再报错
# v6 = q.get()  # 队列中如果已经没有数据的话 get方法会原地阻塞
# print(v1, v2, v3, v4, v5, v6)

"""
q.full()
q.empty()
q.get_nowait()
在多进程的情况下是不精确的
本地测试的时候才可能会用到Queue，实际生产用的都是别人封装好的功能非常强大的工具
"""

IPC机制

研究思路

1、主进程跟子进程借助于队列通信：

from multiprocessing import Queue, Process


def producer(q):
    q.put('我是23号技师 很高兴为您服务')  # 在子进程中向主进程的队列中添加值
    print('hello big baby')


if __name__ == '__main__':
    q = Queue()  # 在主进程中创建一个队列
    p = Process(target=producer, args=(q,))  # 将producer函数当作子进程创建
    p.start()
    print(q.get())  # 在主进程中获取并打印队列里的值

2、子进程跟子进程借助于队列通信：

from multiprocessing import Queue, Process


def producer(q):
    q.put('我是23号技师 很高兴为您服务')  # 往队列里放数据


def consumer(q):
    print(q.get())  # 在子进程中获取队列中的数据


if __name__ == '__main__':
    q = Queue()  # 在主进程中创建一个队列
    p = Process(target=producer, args=(q,))  # 将producer函数当作子进程创建
    p1 = Process(target=consumer, args=(q,))  # 将consumer函数当作子进程创建
    p.start()
    p1.start()

生产者消费者模型

生产者：生产/制造东西的

消费者：消费/处理东西的

该模型除了上述两个之外还需要一个媒介

生活中的例子：做包子的将包子做好后放在蒸笼里，买包子的去蒸笼里拿

​ 厨师做好的菜用盘子装着，给消费者端过去

生产者和消费者之间不是直接做交互的，而是借助于媒介做交互

生产者（做包子的）+ 消息队列（蒸笼）+ 消费者（吃包子的）

消息队列的存在是为了解决供需不平衡的问题

from multiprocessing import Process, Queue, JoinableQueue
import time
import random


# 生产者
def producer(name, food, q):
    for i in range(5):
        data = '%s 生产了 %s%s' % (name, food, i)
        # 模拟延迟
        time.sleep(random.randint(1, 3))
        print(data)
        # 将数据放入队列中
        q.put(data)


# 消费者
def consumer(name, q):
    # 消费者胃口很大 光盘行动
    while True:
        food = q.get()  # 没有数据就会卡住
        # 判断当前是否有结束的标识
        # if food is None: break
        time.sleep(random.randint(1, 3))
        print('%s吃了%s' % (name, food))
        q.task_done()  # 告诉队列你已经从里面取出了一个数据并且处理完毕了


if __name__ == '__main__':
    # q = Queue()
    q = JoinableQueue()
    p1 = Process(target=producer, args=('大厨1号', '包子', q))
    p2 = Process(target=producer, args=('大厨2号', '泔水', q))
    c1 = Process(target=consumer, args=('春哥', q))
    c2 = Process(target=consumer, args=('新哥', q))
    p1.start()
    p2.start()
    # 将消费者设置成守护进程
    c1.daemon = True
    c2.daemon = True
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    # 等待生产者生产完毕之后 往队列中添加特定的结束符号
    # q.put(None)  # 肯定在所有生产者生产的数据的末尾
    # q.put(None)  # 有两个消费者 所以要放两个 None
    q.join()  # 等待队列中所有的数据被取完了再往下执行代码
    """
    JoinableQueue 每当你往该队列中存入数据的时候 内部会有一个计数器+1
    每当你调用 task_done 的时候 计数器-1
    q.join() 当计数器为0的时候 才往后运行
    """
    # 只要 q.join() 执行完毕 说明消费者已经处理完数据了 消费者就没有存在的必要了
    # 因此可以在主程序中将消费者设置为守护进程

线程理论

致命三问

• 什么是线程

  进程：资源单位

  线程：执行单位

  • 将操作系统比喻成一个大的工厂，进程就相当于工厂里面的车间，线程就是车间里面的流水线
  • 每一个进程肯定自带一个线程

  总结：起一个进程只是在内存空间中开辟一块独立的空间，真正被CPU执行的其实是进程里面的线程，线程指的就是代码的执行过程，执行代码中所需要使用到的资源都找所在的进程要。

  进程和线程都是虚拟单位，只是为了我们更加方便的描述问题

• 为何要有线程

  开设进程

  ​ 1、申请内存空间 耗资源

  ​ 2、“拷贝代码” 耗资源

  开线程

  ​ 一个进程内可以开设多个线程，在用一个进程内开多个线程无需再次申请内存空间及拷贝代码操作

  总结：开线程比开进程省资源

  ​ 同一个进程下的线程，数据是共享的

• 如何使用

  开启线程的两种方式：

  # # 第一种方式
  from multiprocessing import Process
  from threading import Thread
  import time
  
  
  def task(name):
      print('%s is running' % name)
      time.sleep(1)
      print('%s is over' % name)
      
      
  # 开启线程不需要在main下面执行代码 直接书写就可以
  t = Thread(target=task, args=('egon',))
  t.start()  # 创建线程的开销非常小 几乎是代码一执行线程就已经创建了
  print('主')
  
  ############################################################
  
  # 第二种方式
  from threading import Thread
  import time
  
  
  class MyThead(Thread):
      def __init__(self, name):
          super().__init__()
          self.name = name
  
      def run(self):
          print('%s is running' % self.name)
          time.sleep(1)
          print('egon DSB')
  
  
  if __name__ == '__main__':
      t = MyThead('egon')  # 开一个线程
      t.start()
      print('主')

TCP服务端实现并发的效果：

"""
服务端
    1、要有固定的IP和端口
    2、24小时不间断提供服务
    3、能够支持并发
"""

import socket
from threading import Thread
from multiprocessing import Process


server = socket.socket()  # 括号内不加参数默认就是tcp协议
server.bind(('127.0.0.1', 8080))
server.listen(5)


# 将服务的代码单独封装成一个函数
def talk(conn):
    # 通信循环
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0: break
            print(data.decode('utf-8'))
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()


# 链接循环
while True:
    conn, addr = server.accept()  # 接客
    # 叫其他人来服务客户
    t = Thread(target=talk, args=(conn,))
    # t = Process(target=talk, args=(conn,))  # 开进程也是一样的效果
    t.start()

###########################################################

"""
客户端
"""

import socket


client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'hello world')
    data = client.recv(1024)
    print(data.decode('utf-8'))

线程对象的join方法

from threading import Thread
import time


def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over' % name)


if __name__ == '__main__':
    t = Thread(target=task, args=('egon',))
    t.start()
    t.join()  # 主线程等待子线程运行结束再执行
    print('主')

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

from threading import Thread
import time

money = 100


def task():
    global money
    money = 666
    print(money)


if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    t.join()
    print(money)

线程对象属性及其他方法

from threading import Thread, active_count, current_thread
import time


def task(n):
    # print('hello world', os.getpid())
    print('hello world', current_thread().name)  # 查看当前所在线程的名字
    time.sleep(n)


if __name__ == '__main__':
    t = Thread(target=task, args=(1,))
    t1 = Thread(target=task, args=(2,))
    t.start()
    t1.start()
    t1.join()  # 等待 t1 运行完毕后再运行后面的代码
    # print('主', os.getpid())
    # print('主', current_thread().name)
    print('主', active_count())  # 统计当前正在活跃的线程数

守护线程

from threading import Thread
import time


def task(name):
    print('%s is running' % name)
    time.sleep(1)
    print('%s is over' % name)


if __name__ == '__main__':
    t = Thread(target=task, args=('xxxx',))
    t.daemon = True  # 将 t 线程变为守护线程 只要主线程结束了 t线程也结束
    t.start()
    print('主')
    
"""
主线程运行结束之后不会立刻结束 会等待所有其他非守护线程结束才会结束
因为主线程的结束意味着所在的进程的结束
"""

稍微有点迷惑性的例子：

from threading import Thread
import time


def foo():
    print('123')
    time.sleep(1)
    print('end123')


def func():
    print('456')
    time.sleep(3)
    print('end456')


if __name__ == '__main__':
    t1 = Thread(target=foo)
    t2 = Thread(target=func)
    t1.daemon = True
    t1.start()
    t2.start()
    print('主.......')

线程互斥锁

from threading import Thread, Lock
import time

money = 100
mutex = Lock()  # 先生成一把锁


def task():
    global money
    mutex.acquire()  # 在抢数据的代码前加锁
    tmp = money
    time.sleep(0.1)
    money = tmp - 1
    mutex.release()  # 抢完以后释放锁


if __name__ == '__main__':
    t_list = []
    for i in range(100):  # 起100个线程
        t = Thread(target=task)
        t.start()
        t_list.append(t)  # 先将线程逐一添加进列表中以备后续统一操作
    for t in t_list:
        t.join()  # 后续统一操作：保证每一个线程运行完毕后再结束主线程
    print(money)

GIL全局解释器锁

定义：

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

python解释器有多个版本

​ Cpython

​ Jpython

​ Pypypython

但是普遍使用的都是Cpython解释器

在Cpython解释器中GIL是一把互斥锁，用来阻止同一个进程下的多个线程的同时执行

同一个进程下的多个线程无法利用多核优势！！！

疑问：python的多线程是不是一点用都没有？？？

因为python中的内存管理不是线程安全的

内存管理（垃圾回收机制）

​ 1、引用计数

​ 2、标记清除

​ 3、分代回收

重点：

1、GIL不是python的特点，而是Cpython解释器的特点

2、GIL是保证解释器级别的数据的安全（即线程与线程之间的数据的安全）

3、GIL会导致同一个进程下的多个线程无法同时执行即无法利用多核优势

4、针对不同的数据还是需要加不同的锁处理

5、解释性语言的通病：同一个进程下多个线程无法利用多核优势

GIL与普通互斥锁的区别

from threading import Thread, Lock
import time

money = 100
mutex = Lock()  # 先生成一把锁


def task():
    global money
    # with mutex:   # 等同于下面的写法
    #     tmp = money
    #     time.sleep(0.1)
    #     money = tmp - 1
    mutex.acquire()  # 在抢数据的代码前加锁
    tmp = money
    time.sleep(0.1)
    money = tmp - 1
    mutex.release()  # 抢完以后释放锁


if __name__ == '__main__':
    t_list = []
    for i in range(100):  # 起100个线程
        t = Thread(target=task)
        t.start()
        t_list.append(t)  # 先将线程逐一添加进列表中以备后续统一操作
    for t in t_list:
        t.join()  # 后续统一操作：保证每一个线程运行完毕后再结束主线程
    print(money)

"""
100个线程起来之后要先去抢GIL
我进入IO GIL自动释放 但是我手上还有一把互斥锁
其他线程虽然抢到了GIL但是抢不到互斥锁
最终GIL还是回到我的手上 我去操作数据
"""

同一个进程下的多线程无法利用多核优势，是不是就没有用了

多线程是否有用要看具体情况

单核：四个任务（IO密集型\计算密集型）

多核：四个任务（IO密集型\计算密集型）

计算密集型：每个任务都需要10s

单核：（不用考虑了，时代已过）

​ 多进程：额外的消耗资源

​ 多线程：节省资源

多核：

​ 多进程：总耗时 10s+

​ 多线程：总耗时 40s+

IO密集型：

多核：

​ 多进程：相对浪费资源

​ 多线程：更加节省资源

代码验证

# 计算密集型
from multiprocessing import Process
from threading import Thread
import os, time


def work():
    res = 0
    for i in range(10000000):
        res *= i


if __name__ == '__main__':
    l = []
    print(os.cpu_count())  # 获取当前计算机CPU个数
    start_time = time.time()
    for i in range(8):
        # p = Process(target=work)  # 0.4691619873046875  多进程更快
        t = Thread(target=work)  # 1.6921021938323975
        # p.start()
        t.start()
        # l.append(p)
        l.append(t)
    for p in l:
        p.join()
    print(time.time() - start_time)

# IO密集型
from multiprocessing import Process
from threading import Thread
import os, time


def work():
    time.sleep(2)


if __name__ == '__main__':
    l = []
    print(os.cpu_count())  # 获取当前计算机CPU个数
    start_time = time.time()
    for i in range(2000):
        # p = Process(target=work)  # 14.634779930114746
        t = Thread(target=work)  # 2.142601251602173
        # p.start()
        t.start()
        # l.append(p)
        l.append(t)
    for p in l:
        p.join()
    print(time.time() - start_time)

总结：

多进程和多线程各有自己的优势

通常可以 多进程下面开设多线程

这样的话既可以利用多核也可以节省资源消耗

死锁

当你知道锁的使用（抢锁必须要释放锁），其实你在操作锁的时候也极其容易产生死锁现象（整个程序卡死、阻塞）

from threading import Thread, Lock
import time

mutexA = Lock()
mutexB = Lock()


# 类只要加括号多次 产生的肯定是不同的对象
# 如果你想要实现多次加括号等到的是相同的对象 ---> 单例模式


class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s 抢到A锁' % self.name)  # 获取当前线程名
        mutexB.acquire()
        print('%s 抢到B锁' % self.name)
        mutexB.release()
        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('%s 抢到B锁' % self.name)
        time.sleep(2)
        mutexA.acquire()
        print('%s 抢到A锁' % self.name)
        mutexA.release()
        mutexB.release()


if __name__ == '__main__':
    for i in range(10):
        t = MyThread()
        t.start()

递归锁

特点：

​ 可以被连续的acquire和release

​ 但是只能被第一个抢到这把锁执行上述操作

​ 它的内部有一个计数器 每acquire一次计数加一 每release一次计数减一

​ 只要计数不为0 其他人都无法抢到该锁

# 递归锁
from threading import Thread, Lock, RLock
import time

mutexA = mutexB = RLock()


# 类只要加括号多次 产生的肯定是不同的对象
# 如果你想要实现多次加括号等到的是相同的对象 ---> 单例模式


class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s 抢到A锁' % self.name)  # 获取当前线程名
        mutexB.acquire()
        print('%s 抢到B锁' % self.name)
        mutexB.release()
        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('%s 抢到B锁' % self.name)
        time.sleep(2)
        mutexA.acquire()
        print('%s 抢到A锁' % self.name)
        mutexA.release()
        mutexB.release()


if __name__ == '__main__':
    for i in range(10):
        t = MyThread()
        t.start()

信号量

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

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

如果我们将互斥锁比喻成一个厕所的话

那么信号量就相当于多个厕所

from threading import Thread, Semaphore
import time
import random


sm = Semaphore(5)  # 括号内写数字 写几就表示开设几个坑位


def task(name):
    sm.acquire()
    print('%s 正在蹲坑' % name)
    time.sleep(random.randint(1, 5))
    sm.release()


if __name__ == '__main__':
    for i in range(20):
        t = Thread(target=task, args=('伞兵%s号' % i,))
        t.start()

Event事件

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

from threading import Thread, Event
import time

event = Event()  # 造了一个红绿灯


def light():
    print('红灯亮着的')
    time.sleep(3)
    print('绿灯亮了')
    event.set()  # 告诉等红灯的人可以走了


def car(name):
    print('%s 号车正在等红灯' % name)
    event.wait()  # 等待 event.set() 被触发
    print('%s 号车加油门开走了..' % name)


if __name__ == '__main__':
    t = Thread(target=light)  # 设置一个红绿灯
    t.start()

    for i in range(1, 21):
        t = Thread(target=car, args=('%s' % i,))
        t.start()

线程q

"""
同一个进程下多个线程 数据是共享的
为什么同一个进程下还会使用队列来共享数据呢
因为同一进程下的多个线程共享数据时，数据是不安全的
队列：
    管道 + 锁
所以用队列是为了保证数据的安全
"""
import queue
# 我们现在使用的队列（queue）都是只能在本地测试使用

# 1 队列q 先进先出
q = queue.Queue(3)
q.put(1)
q.get()
q.get_nowait()
q.get(timeout=3)
q.full()
q.empty()

##############################################

# 2 后进先出q
q = queue.LifoQueue(3)  # last in first out
q.put(1)
q.put(2)
q.put(3)
print(q.get())  # 3

##############################################

# 3 优先级q  （你可以给放入队列中的数据设置进出的优先级）
q = queue.PriorityQueue(4)
q.put((10, '111'))
q.put((100, '222'))
q.put((0, '333'))
q.put((-5, '444'))
print(q.get())  # (-5, '444')
# put括号内放一个元组 第一个放数字表示优先级 第二个放数据
# 需要注意的是 数字越小优先级越高！！！

进程池与线程池

先回顾tcp服务端实现并发的效果是怎么玩的？

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

"""
无论是开进程还是线程 都要消耗资源
只不过线程的资源稍微小一点而已

我们是不可能做到无限制的开设进程和线程 因为计算机硬件的资源跟不上！
硬件的开发速度远远赶不上软件

我们的宗旨应该是在保证计算机硬件能够正常工作的情况下最大限度的利用它
"""

池的概念

什么是池？

​ 池是用来保证计算机硬件安全的情况下最大限度的利用计算机

​ 它降低了程序的运行效率，但是保证了计算机硬件的安全，从而让程序能够正常运行

基本使用：

# 线程池

from concurrent.futures import ThreadPoolExecutor
import time

pool = ThreadPoolExecutor(5)  # 变量名随便起  参数 5 表示池子里面固定只有五个线程
# 括号内可以传数字 不传的话默认会开设当前计算机CPU个数五倍的线程
"""
池子造出来之后 里面会固定存在五个线程
这五个线程不会出现重复创建和销毁的过程
这样也节省了重复创建线程的过程 ---> 节省资源
池子的使用非常的简单
你只需要将需要做的任务往池子中提交即可
"""


def task(n):
    print(n)
    time.sleep(2)
    return n*n


"""
任务的提交方式分两种
    同步：
    异步：
"""

# pool.submit(task, 1)  # 朝池子中提交任务  异步提交
# print('主')
t_list = []
for i in range(20):  # 朝池子中提交20个任务
    res = pool.submit(task, i)
    # print(res.result())  # submit类中的 result 方法  这行代码会导致程序同步提交
    t_list.append(res)
# 等待线程池中所有的任务执行完毕之后再打印列表中的结果
pool.shutdown()  # 关闭线程池 等待线程池中所有的任务运行完毕
for t in t_list:
    print('>>>: ', t.result())  # 有序输出

但是上述线程池的代码用列表的方式有点别扭，可以用下面的方法

最终实现一有结果立刻获取并打印

# 进程池

from concurrent.futures import ProcessPoolExecutor
import time

pool = ProcessPoolExecutor()
# 括号内可以传数字 不传的话默认会开设当前计算机CPU个数的进程
"""
池子造出来之后 里面会固定存在几个进程
这几个进程不会出现重复创建和销毁的过程
池子的使用非常的简单
你只需要将需要做的任务往池子中提交即可
"""


def task(n):
    print(n)
    time.sleep(2)
    return n*n


def call_back(n):  # n ==> pool.submit(task, i) 返回的对象
    print('call_back: ', n.result())  # 对象的值用 .result() 查看


"""
任务的提交方式分两种
    同步：
    异步：提交后的返回结果应该通过回调来获取
        回调机制：就相当于给每个异步任务绑定了一个定时炸弹，一旦任务有结果立刻触发
"""
if __name__ == '__main__':
    for i in range(20):  # 朝池子中提交20个任务
        # res = pool.submit(task, i)
        pool.submit(task, i).add_done_callback(call_back)

总结

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

pool = ProcessPoolExecutor()  # 进程池
pool = ThreadPoolExecutor(5)  # 线程池

res = pool.submit(task, i).add_done_callback(call_back)

协程

进程：资源单位

线程：执行单位

协程：这个概念完全是程序员自己意淫出来的 根本不存在

​ 为的是“单线程下实现并发”

​ 我们程序员自己在代码层面上检测我们所有的IO操作

​ 一旦遇到IO 在代码级别完成切换

​ 这样给CPU的感觉是你这个程序一直在运行 没有IO

​ 从而提升程序的运行效率

多道技术

​ 切换+保存状态

​ CPU两种情况下切换

​ 1、程序遇到IO

​ 2、程序长时间占用

适合的例子：

​ tcp服务端

​ accept

​ recv

代码如何做到 切换+保存状态？

​ 切换：切换不一定提升效率 也有可能降低效率

​ IO切 提升

​ 没有IO切 降低

​ 保存状态：保存上一次执行的状态 下一次接着上一次的操作继续往后执行

​ yield

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

# 串行执行计算密集型的任务
import time


def func1():
    for i in range(100000000):
        i + 1


def func2():
    for i in range(100000000):
        i + 1


start_time = time.time()
func1()
func2()
print(time.time() - start_time)

# 切换 + yield
import time


def func1():
    while True:
        100000000 + 1
        yield


def func2():
    g = func1()  # 先初始化出生成器
    for i in range(100000000):
        i + 1
        next(g)


start_time = time.time()
func2()
print(time.time() - start_time)

gevent模块

可以检测程序的IO操作

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('嘿嘿嘿')
    time.sleep(5)
    print('嘿嘿嘿')


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

协程实现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()

总结

理想状态：

​ 我们可以通过

​ 多进程下面开设多线程

​ 多线程下面开设协程

​ 从而使我们的程序执行效率提升

IO模型简介

我们这里研究的IO模型都是针对网络IO的

Stevens在文章中一共比较了五种IO Model：
* blocking IO 阻塞IO
* nonblocking IO 非阻塞IO
* IO multiplexing IO多路复用
* signal driven IO 信号驱动IO
* asynchronous IO 异步IO
由signal driven IO（信号驱动IO）在实际中并不常用，所以主要介绍其余四种IO Model

1）等待数据准备（Waiting for the data to be ready）

2）将数据从内核拷贝到进程中（Copying the data from the kernel to the process）

同步异步

阻塞非阻塞

常见的网络状态：

​ accept

​ recv

​ recvftom

​ send虽然它也有IO行为 但是不在我们的考虑范围

阻塞IO

我们之前写的都是阻塞IO模型 协程除外

import socket


server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)


while True:
    conn, addr = server.accept()
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0: break
            print(data)
            conn.send(data.upper())
        except ConnectionResetError as e:
            break
    conn.close()
    
# 在服务端无论是开设多进程、多线程，还是进程池、线程池，其实还是没有解决IO问题
"""
该等的地方还是得等 没有规避
只不过多个人等待的彼此互不干扰
"""

非阻塞IO

"""
要自己实现一个非阻塞IO模型
"""
# 服务端
import socket

server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
server.setblocking(False)  # 参数默认是True 改为False会将所有的网络阻塞变为非阻塞

r_list = []
del_list = []
while True:
    try:
        conn, addr = server.accept()
        r_list.append(conn)
    except BlockingIOError:
        for conn in r_list:
            try:
                data = conn.recv(1024)  # 没有消息 报错
                if len(data) == 0:  # 客户端断开链接
                    conn.close()  # 关闭conn
                    # 将无用的conn从r_list删除
                    del_list.append(conn)
                    continue
                conn.send(data.upper())  # 给客户端返回大写
            except BlockingIOError:
                continue
            except ConnectionResetError:
                conn.close()
                del_list.append(conn)
        # 回收无用的链接
        for conn in del_list:
            r_list.remove(conn)
        del_list.clear()
        
############################################################

# 客户端
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))


while True:
    client.send(b'hello world')
    data = client.recv(1024)
    print(data)

总结

虽然非阻塞IO给你的感觉非常的牛逼，但是该模型会长时间占用着CPU并且不干活（让CPU不停的空转）

我们实际应用中也不会考虑使用非阻塞IO模型

但是任何的技术点都有它存在的意义

实际应用或者是思想借鉴

IO多路复用

当监管的对象只有一个的时候 其实IO多路复用连阻塞IO都比不上！

但是IO多路复用可以一次性监管很多个对象：

​ server = socket.socket()

​ conn, add = server.accept()

监管机制是操作系统本身就有的 如果你想用该监管机制（select）

需要你导入对应的select模块

# 服务端
import socket
import select

server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
server.setblocking(False)
read_list = [server]

while True:
    r_list, w_list, x_list = select.select(read_list, [], [])
    for i in r_list:
        """针对不同的对象做不同的处理"""
        if i is server:
            conn, addr = i.accept()
            read_list.append(conn)  # conn 对象也应该添加到监管的队列中
        else:
            res = i.recv(1024)
            if len(res) == 0:
                i.close()
                # 将无效的监管对象 移除
                read_list.remove(i)
                continue
            print(res)
            i.send(b'heiheihei')

# 客户端
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'hello world')
    data = client.recv(1024)
    print(data)

总结

监管机制其实有很多：

​ select机制 ==> Windows Linux 都有

​ poll机制 ===> 只在 Linux 有，poll和select都可以监管多个对象 但是poll监管的数量更多

​ <u>上述select和poll机制都不是很完美 当监管的对象特别多的时候 可能会出现极其大的延迟响应</u>

​ epoll机制 ===> 只在 Linux 有

​ 它给每一个监管对象都绑定了一个回调机制，一旦有响应 回调机制立刻发起提醒

针对不同的操作系统还需要考虑不同的检测机制 书写代码太过繁琐

有一个模块能够根据你跑的平台的不同自动帮你选择对应的监管机制 => selectors模块

异步IO

异步IO模型是所有模型中效率最高的，也是使用最广泛的

相关的模块和框架

​ 模块：asyncio模块

​ 异步框架：sanic、tronado、twisted

统一特点：速度快！！！

import threading
import asyncio


async def hello():
    print('hello world %s' % threading.current_thread())
    await asyncio.sleep(1)  # 此处模拟真正的IO操作的耗时
    print('hello world %s' % threading.current_thread())


loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

四个IO模型对比