并发编程3

验证GIL的存在

from threading import Thread
money = 100
def task():
    global money
    money -= 1
t_list = []
for i in range(100):
    t = Thread(target=task)
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
print(money)

运行结果：

GIL和互斥锁结合使用

GIL不会影响程序层面的数据也不会保证它的修改是安全的要想保证得自己加锁
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):
    t = Thread(target=task)
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
print(money)

运行结果：

总结

1.GIL是一个纯理论知识 在实际工作中根本无需考虑它的存在
2.GIL作用面很窄 仅限于解释器级别，平时我们要想保证数据的安全应该自定义互斥锁(使用别人封装好的工具)

验证python多线程

多线程的几种情况

1.单个CPU
   # IO密集型（代码有IO操作）
   1.多进程 ：申请额外的空间，消耗更多的资源
   2.多线程：消耗资源相对较少 通过多道技术
   ps:多线程有优势！
   # 计算密集型 （没有IO操作）
   1.多进程 ：申请额外的空间，消耗更多的资源（总耗时+申请空间+拷贝代码+切换）
   2.多线程：消耗资源相对较少 通过多道技术（总耗时+切换）
   ps:多线程有优势！！
   
2.多个CPU
   # IO密集型
   1.多进程：总耗时（单个进程的耗时+IO+申请空间+拷贝代码）
   2.多线程：总耗时（单个进程的耗时+IO）
   ps:多线程有优势！！
   # 计算密集型
   1.多进程：总耗时（单个进程的耗时）
   2.多线程：总耗时（多个进程的总和）
   ps：多进程有优势！

计算密集型代码实操

from multiprocessing import Process
import os
import time
# 多进程
def work():
    res = 1
    for i in range(1,100000000):
        res *= i


if __name__ == '__main__':
    print(os.cpu_count())  # 查看当前计算机CPU个数
    start_time = time.time()
    P_list = []
    for i in range(12):  # 一次性创建12个进程
        p = Process(target=work)
        p.start()
        P_list.append(p)
        for p in P_list: # 确保所有的进程都运行完毕
            p.join()
    print('总耗时：%s'% (time.time()-start_time))

------------
# 多线程
from threading import Thread
import os
import time
def work():
    res = 1
    for i in range(1,100000000):
        res *= i
if __name__ == '__main__':
    print(os.cpu_count())  # 查看当前计算机CPU个数
    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))

IO密集型代码实操

# 多线程
from threading import Thread
import os
import time

def work():
    time.sleep(3) # (模仿纯IO操作)
if __name__ == '__main__':
    print(os.cpu_count())  # 查看当前计算机CPU个数
    start_time = time.time()
    t_list = []
    for i in range(100):
        t = Thread(target=work)
        t.start()
        for t in t_list:
            t.join()
    print('总耗时：%s' % (time.time() - start_time))

------------
# 多进程
from multiprocessing import Process
import os
import time

def work():
    time.sleep(3) # (模仿纯IO操作)
if __name__ == '__main__':
    print(os.cpu_count())  # 查看当前计算机CPU个数
    start_time = time.time()
    P_list = []
    for i in range(12):  # 一次性创建12个进程
        p = Process(target=work)
        p.start()
        # P_list.append(p)
        for p in P_list: # 确保所有的进程都运行完毕
            p.join()
    print('总耗时：%s'% (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(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()

信号量

 信号量本质也是互斥锁，只不过是多把锁
 ps：信号量在不同的体系中意思可能有所区别，在并发编程中 信号量就是多把互斥锁
        在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事件

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()
    print('%s加油门 飙车了' % name)


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

进程池与线程池

进程池：提前创建好固定个数的进程供程序使用，后续不再创建
线程池：提前创建好固定格个数的线程供程序使用，后续不再创建

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import current_thread
import os
import time

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

def task(n):
    # print(current_thread().name)
    print(os.getpid())
    # print(n)
    time.sleep(1)
    return '返回结果！！！'

def func(*args,**kwargs):
    print('func',args,kwargs)
    print(args[0].result())


if __name__ == '__main__':
    for i in range(20):
        res = pool.submit(task,123) # 朝池子中提交任务（异步）
        # print(res.result()) # 同步
        # pool.submit(task,123).add_done_callback(func)
        # 异步回调：异步任务执行完成后有结果就会自动触发该机制
        pool.submit(task,123).add_done_callback(func)

协程

# 该技术是程序员自己发明出来的，名字也是程序员自己取的
协程：单线程下实现并发（效率极高）核心是：写代码完成切换+保存状态
from gevent import monkey;monkey.patch_all()
# 固定编写 用于检测所有的IO操作（猴子补丁）
from gevent import spawn
import time
def func1():
    print('开始1')
    time.sleep(3)
    print('结束1')
def func2():
    print('开始2')
    time.sleep(3)
    print('结束2')
if __name__ == '__main__':
    start_time = time.time()
    # func1()
    # func2()
    s1 = spawn(func1) # 监测代码 一旦有IO操作立即切换 执行么有IO的操作
    s2 = spawn(func2)
    s1.join()
    s2.join()
    print(time.time() - start_time)

代码运行结果：