验证GIL存在、进程池与线程池、协程简介

验证GIL的存在

from threading import Thread

money = 100


def task():
    global money
    money -= 1


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()
# 等待所有的线程运行结束 查看money是多少
print(money)  # 0

验证GIL的特点

有IO机制 会发生错乱的现象

from threading import Thread
import time
money = 100


def task():
    global money
    tmp = money
    time.sleep(0.1)  # 进入IO机制
    money = tmp - 1


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()
# 等待所有的线程运行结束 查看money是多少
print(money)  # 99

解决措施

  自己加锁

from threading import Thread,Lock
import time

money = 100
mutex = Lock()  # 创造锁


def task():
    mutex.acquire()  # 抢锁
    global money
    tmp = money
    time.sleep(0.1)
    money = tmp - 1
    mutex.release()  # 释放锁


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()
# 等待所有的线程运行结束 查看money是多少
print(money)  # 0

验证python多线程是否有用

需要分情况
情况1
	单个CPU
	多个CPU
情况2
	IO密集型(代码有IO操作)
	计算密集型(代码没有IO)

1.单个CPU
IO密集型
	多进程
		申请额外的空间 消耗更多的资源
	多线程
		消耗资源相对较少 通过多道技术
	ps:多线程有优势!!!

计算密集型
	多进程
		申请额外的空间 消耗更多的资源(总耗时+申请空间+拷贝代码+切换)
	多线程
		消耗资源相对较少 通过多道技术(总耗时+切换)
	ps:多线程有优势!!!

2.多个CPU
IO密集型
	多进程
		总耗时(单个进程的耗时+IO+申请空间+拷贝代码)
	多线程
		总耗时(单个进程的耗时+IO)
	ps:多线程有优势!!!

计算密集型
	多进程
		总耗时(单个进程的耗时)
	多线程
		总耗时(多个进程的综合)
	ps:多进程完胜!!!

代码实践

一、计算密集型

from threading import Thread
from multiprocessing import Process
import os
import time


def work():
    res = 1
    for i in range(1, 100000):
        res *= i


if __name__ == '__main__':
    print(os.cpu_count())  # 16  查看当前计算机CPU个数

    # 多进程
    start_time = time.time()
    p_list = []
    for i in range(16):  # 一次性创建16个进程
        p = Process(target=work)
        p.start()  #
        p_list.append(p)
    for p in p_list:  # 确保所有的进程全部运行完毕
        p.join()
    print('总耗时:%s' % (time.time() - start_time))  # 获取总的耗时 总耗时:5.607265472412109

    # 多线程
    start_time = time.time()
    t_list = []
    for i in range(12):
        t = Thread(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print('总耗时:%s' % (time.time() - start_time))  # 获取总的耗时 总耗时:26.753153085708618
"""
多进程总耗时:5.607265472412109
多线程总耗时:26.753153085708618
"""

二、IO密集型

from threading import Thread
from multiprocessing import Process
import os
import time


def work():
    time.sleep(2)


if __name__ == '__main__':
    # 多进程
    start_time = time.time()
    p_list = []
    for i in range(100):
        p = Process(target=work)
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print('总耗时:%s' % (time.time() - start_time))  # 总耗时:3.1973876953125

    # 多线程
    start_time = time.time()
    t_list = []
    for i in range(100):
        t = Thread(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print('总耗时:%s' % (time.time() - start_time))  # 总耗时:2.0217387676239014
"""
多进程总耗时:3.1973876953125
多线程总耗时:2.0217387676239014
"""

死锁现象

虽然我们掌握了互斥锁的使用

  先抢锁 后释放锁

就是你要的锁在我手里 我要的锁在你手里 还必须互相手里都需要有一把锁
极其容易产生死锁现象(整个程序卡死 阻塞)

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(f'{self.name}抢到了A锁')
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')

    def func2(self):
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        time.sleep(1)
        mutexA.acquire()
        print(f'{self.name}抢到了A锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')


for i in range(10):
    t = MyThread()
    t.start()

信号量

信号量本质也是互斥锁 只不过他是多把锁

我们之前使用Lock产生的是单把锁

信号量就相当于多把锁

强调:

  信号量在不同的知识体系中 意思可能有区别
  在并发编程中 信号量就是多把互斥锁
  在django中 信号量指的是达到某个条件自动触发(中间件)

from threading import Thread, Lock, Semaphore
import time
import random


sp = Semaphore(5)  # 一次性产生五把锁


class MyThread(Thread):
    def run(self):
        sp.acquire()  # 抢锁
        print(self.name)
        time.sleep(random.randint(1, 3))
        sp.release()  # 释放锁


for i in range(20):
    t = MyThread()
    t.start()

event事件

子进程\字线程之间可以彼此等待彼此

eg:

  子A运行到某一个代码位置后发信号告诉子B开始运行

from threading import Thread, Event
import time

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


def light():
    print('红灯亮着的 所有人都不能动')
    time.sleep(3)
    print('绿灯亮了 油门踩到底 给我冲!!!')
    event.set()  # set类似于发号事令的人


def car(name):
    print('%s正在等红灯' % name)
    event.wait()  # wait收到set的事令后就会执行
    print('%s加油门 飙车了' % name)


t = Thread(target=light)
t.start()
for i in range(20):
    t = Thread(target=car, args=('靓仔%s' % i,))
    t.start()

进程池与线程池

进程池与线程池的创建方法一致

一、线程池

from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import time

tool = ThreadPoolExecutor(5)  # 固定产生五个线程


def task(n):
    print(current_thread().name)  # 线程号名字
    print(n)  # 123
    time.sleep(1)
    return '返回的结果'


def func(*args, **kwargs):
    print('func', args, kwargs)  # func (<Future at 0x1d262ec09b0 state=finished returned str>,) {}
    print(args[0].result())  # 返回的结果



for i in range(20):
# res = pool.submit(task,123)  # 朝池子中提交20个任务(异步)
# print(res.result())  # result是结果的意思  直接点result会变成同步效果
tool.submit(task, 123).add_done_callback(func)
"""
异步回调:异步任务执行完成后有结果就会自动触发该机制
"""

add_done_callback()给任务绑定一个回调机制 异步提交之后有了结果会自动触发该机制

专业名词:异步回调

二、进程池

from concurrent.futures import ProcessPoolExecutor
import os
import time

pool = ProcessPoolExecutor(5)  # 固定产生五个进程


def task():
    print(os.getpid())  # 进程号名字
    time.sleep(1)
    return '返回的结果'


def func(*args, **kwargs):
    print('func', args, kwargs)  # func (<Future at 0x1eee6a014a8 state=finished returned str>,) {}
    print(args[0].result())  # 返回的结果


if __name__ == '__main__':
    for i in range(20):
        pool.submit(task).add_done_callback(func)

协程简介

进程:资源单位

线程:执行单位

协程:单线程下实现并发(效率极高)

  在代码层面欺骗CPU 让CPU觉得我们的代码里没有IO操作

  实际上IO操作被我嗯自己写的代码检测 一但有 立刻让代码执行别的

  该技术完全是程序员自己弄出来的 名字也是程序员自己起的

核心:自己写的代码 完全切换 + 保存

代码实践(猴子补丁)

import time
from gevent import monkey;monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn


def func1():
    print('func1 running')
    time.sleep(3)
    print('func1 over')


def func2():
    print('func2 running')
    time.sleep(5)
    print('func2 over')


if __name__ == '__main__':
    start_time = time.time()
    func1()
    func2()
    print(time.time() - start_time)  # 总耗时: 8.01237154006958

    # 协程
    s1 = spawn(func1)  # 检测代码 一旦有IO自动切换(执行没有io的操作 变向的等待io结束)
    s2 = spawn(func2)
    s1.join()
    s2.join()
    print(time.time() - start_time)  # 总耗时: 5.026265382766724

协程实现TCP服务端并发

服务端

import socket
from gevent import monkey;monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn


def communication(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())


def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    while True:
        sock, addr = server.accept()  # IO操作
        spawn(communication, sock)

s1 = spawn(get_server)
s1.join()

客户端

import socket
from threading import Thread,current_thread


def client():
    client = socket.socket()
    client.connect(('127.0.0.1',8080))
    while True:
        client.send(f'{current_thread().name}'.encode('utf8'))
        data = client.recv(1024)
        print(data.decode('utf8'))

for i in range(200):
    t = Thread(target=client)
    t.start()