python 多线程 等待全部线程结束

目录

• 验证GIL的存在

• GIL是否存在
• 针对不同的数据应该加不同的锁处理

• 验证python多线程是否有用

• 单个cpu
• 多个cpu

• 死锁现象
• 信号量
• event事件
• 进程池与线程池
• 协程
• 协程实现TCP服务端并发

验证GIL的存在

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)

'''
for循环是一次性全部触发
等待所有的线程运行结束以后，查看money是多少
因为start是一个异步操作，执行完for循环的时候它会直接执行print，但是此时线程还没有执行完，所有还需要进一步优化
join()方法：主线程等待子线程运行结束

新增内容：
    每一个t都是不一样的，列表里的每一个t都是不一样的，类似于列表里的t指向了不同的子线程
    
'''

针对不同的数据应该加不同的锁处理

'''
GIL它只影响的是解释器层面的数据安全，不会影响应用程序自己的数据安全
问题：
    是不是有了GIL以后只要涉及到了并发操作同一个数据，就不需要加锁等处理？？
        并不是，GIL不管程序里面的数据怎么变，只保证的是垃圾回收装置不会误删数据，其他情况要保证数据的不错乱需要自己加锁
        也就是GIL的存在与否并不会影响所写的代码，在程序运行期间自己想修改的那个数据的安全性需要自己去加锁
        尤其是在网络延迟的情况下，还有我们平常写的代码中大多数会进入一个IO操作情况下，需要我们自己加锁
    
GIL释放的情况：
    代码运行结束
    进入IO操作
time.sleep是一个IO操作，遇到它的时候被迫会把GIL放出来，此时其他线程就会去抢，然后就是会一直这样，每个子线程都-1，最后输出的就是99

生成锁：
    mutex.acquire()
    mutex.release()
'''

from threading import Thread
import time
money = 100


def task():
    '''修改部分,再加一个锁'''
    mutex.acquire()
    global money
    tmp = money
    time.sleep(0.1)
    money = tmp - 1
	mutex.release()
'''
第一个抢到的后面遇到IO操作只是释放了GIL的锁，而里面自己设置的锁还在，所以其他的子线程还是进不去，得等到第一个自己的锁释放掉才可以
'''
#  新增
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)

验证python多线程是否有用

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

单个cpu

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

多个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())  # 12  查看当前计算机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()
    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))  # 获取总的耗时

"""
计算密集型
    多进程:5.665567398071289
    多线程:30.233906745910645
"""

def work():
    time.sleep(2)   # 模拟纯IO操作


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

"""
IO密集型
    多线程:0.0149583816528320
    多进程:0.6402878761291504
"""

死锁现象

两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁现象

"""
虽然我们已经掌握了互斥锁的使用
	先抢锁 后释放锁
但是在实际项目尽量少用(你也不会用!!!)
"""
from threading import Thread, Lock
import time

mutexA = Lock()  # 类名加括号每执行一次就会产生一个新的对象
mutexB = Lock()  # 类名加括号每执行一次就会产生一个新的对象
'''
Lock()是一个类，类名加括号，每执行一次就会产生一个对象
类名加括号每执行一次就会产生一个新的对象，可以用单例模式实现
'''

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

    def func1(self):
        mutexA.acquire()
        print(f'{}抢到了A锁')
        mutexB.acquire()
        print(f'{}抢到了B锁')
        mutexB.release()
        print(f'{}释放了B锁')
        mutexA.release()
        print(f'{}释放了A锁')

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


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

信号量

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据。
    Semaphore管理一个内置的计数器，
    每当调用acquire()时内置计数器-1；
    调用release() 时内置计数器+1；
    计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()

锁信号量与进程池的概念很像，但是要区分开，信号量涉及到加锁的概念。

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

强调:
    信号量在不同的知识体系中 意思可能有区别
        在并发编程中 信号量就是多把互斥锁
        在django中 信号量指的是达到某个条件自动触发(中间件)
        ...
我们之前使用Lock产生的是单把锁
	类似于单间厕所
信号量相当于一次性创建多间厕所
	类似于公共厕所

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


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


class MyThread(Thread):
    def run(self):
        sp.acquire()
        print()
        time.sleep(random.randint(1, 3))
        sp.release()


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

event事件

子进程\子线程之间可以彼此等待彼此
	eg:子A运行到某一个代码位置后'发信号'告诉子B开始运行
    
在多线程环境中，每个线程的执行一般是独立的，如果一个线程的执行依赖于另一个线程的状态，那么就有必要引入某种标志位来进行判断，event就相当于一个全局的标志位。

event常用于主线程控制其他线程的执行。
创建一个event对象：
event = threading.Event()
event对象的方法：
1. event.isSet() 或 event.is_set(), 返回event对象的bool值，event对象的初始bool值是False.
2. event.wait() 如果上面是True, 啥也不做，往下执行，如果上面是False, 则阻塞线程. wait(num)为超时设置，超过num秒，继续往下执行。
3. event.set() 设置event对象True
4. event.clear() 恢复为False

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()

进程池与线程池

多进程 多线程
	在实际应用中是不是可以无限制的开进程和线程
	肯定不可以!!! 会造成内存溢出受限于硬件水平
我们在开设多进程或者多线程的时候 还需要考虑硬件的承受范围

池
	降低程序的执行效率 保证计算机硬件的安全
进程池
	提前创建好固定个数的进程供程序使用 后续不会再创建
线程池
	提前创建好固定个数的线程供程序使用 后续不会再创建

submit(函数名,实参1,实参2,...)
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)
'''

异步回调：
	先向池子里提交任务，不用等待它什么时候执行完，只要池子里的任务执行完以后，就会立即将结果返回，触发func
	
'''

协程

进程:资源单位
线程:执行单位
协程:单线程下实现并发(效率极高)
	在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作
	实际上IO操作被我们自己写的代码检测 一旦有 立刻让代码执行别的
	(该技术完全是程序员自己弄出来的 名字也是程序员自己起的)
		核心:自己写代码完成切换+保存状态
            
协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。

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()
    s1 = spawn(func1)  # 检测代码 一旦有IO自动切换(执行没有io的操作 变向的等待io结束)
    s2 = spawn(func2)
    s1.join()
    s2.join()
    print(time.time() - start_time)  # 8.01237154006958   协程 5.015487432479858

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