python学习Day43

本文主要是介绍python学习Day43，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Day 43

今日内容概要

• 验证GIL的存在
• 验证GIL的特点
• 验证python多线程是否有用
• 死锁现象
• 信号量
• event事件
• 进程池与线程池(重要)
• 协程
• 协程实现TCP服务端并发

今日内容详细

1.验证GIL的存在

from threading import Thread
money = 100
def task():
    global money
    money -= 1
t_list=[]
for i in range(80):
    t=Thread(target=task)
    t.start()
    t_list.append(t)#[线程1 线程2 线程3 ... 线程100]
for t in t_list:
    t.join()
# 等待所有的线程运行结束 查看money是多少
print(money)#0

2.验证GIL的特点

from threading import Thread
import time
money = 100
def task():
    global money
    tmp = money
    time.sleep(0.1)
    money = tmp - 1
t_list = []
for i in range(100):
    t = Thread(target=task)
    t.start()
    t_list.append(t)  # [线程1 线程2 线程3 ... 线程100]
for t in t_list:
    t.join()
# 等待所有的线程运行结束 查看money是多少
print(money)#99

"""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)#[线程1 线程2 线程3 ... 线程100]
for t in t_list:
    t.join()
# 等待所有的线程运行结束 查看money是多少
print(money)#0

3.验证python多线程是否有用

需要分情况
	情况1:
    	单个CPU or 多个CPU
	情况2:
		IO密集型(代码有IO操作) or 计算密集型(代码没有IO)
 
1.单CPU IO密集型:
	多进程：申请额外的空间 消耗更多的资源
	多线程：消耗资源相对较少 通过多道技术
      #ps:多线程有优势!!!
2.单CPU 计算密集型:
    多进程：申请额外的空间 消耗更多的资源(总耗时+申请空间+拷贝代码+切换)
 	多线程：消耗资源相对较少 通过多道技术(总耗时+切换)
      #ps:多线程有优势!!!
3.多个CPU IO密集型：
   	多进程：总耗时(单个进程的耗时+IO+申请空间+拷贝代码)
    多线程：总耗时(单个进程的耗时+IO)
       #ps:多线程有优势!!!
4.多个CPU 计算密集型
    多进程：总耗时(单个进程的耗时)
    多线程：总耗时(多个进程的综合)
       #ps:多进程完胜!!!

计算密集型：多进程 与 多线程

from multiprocessing import Process
from threading import Thread
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()
    # print('总耗时:%s' % (time.time() - start_time))
    '计算密集型-多进程 运行结果:总耗时:6.665070295333862'
    t_list = []
    for i in range(12):#一次性创建12个线程
        t = Thread(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:#确保所有的线程全部运行完毕
        t.join()
    print('总耗时:%s' % (time.time() - start_time))
    '计算密集型-多线程 运行结果:总耗时:28.145029306411743'

IO密集型：多进程 与 多线程

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

def work():
    time.sleep(2) #模拟纯IO操作
if __name__ == '__main__':
    print(os.cpu_count())  # 12  查看当前计算机CPU个数
    start_time = time.time()
    # p_list = []
    # for i in range(100):  # 一次性创建100个进程
    #     p = Process(target=work)
    #     p.start()
    # for p in p_list:  # 确保所有的进程全部运行完毕
    #     p.join()
    #     p_list.append(p)
    # print('总耗时:%s' % (time.time() - start_time))
    'IO密集型-多进程 运行结果:总耗时:2.979950428009033'
    t_list = []
    for i in range(100):  # 一次性创建100个线程
        t = Thread(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print('总耗时:%s' % (time.time() - start_time))
    'IO密集型-多线程 运行结果:总耗时:2.0314550399780273'

计算密集型：

​ 多进程 运行结果:总耗时:6.665070295333862'

​ 多线程 运行结果:总耗时:28.145029306411743'

IO密集型：

​ 多进程 运行结果:总耗时:2.979950428009033'

​ 多线程 运行结果:总耗时:2.0314550399780273'

4.死锁现象

"""
虽然我们已经掌握了互斥锁的使用
	先抢锁 后释放锁
但是在实际项目尽量少用(项目中领导也不允许使用)
"""
from threading import Thread, Lock
import time
#产生AB两把锁
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()

5.信号量

信号量本质也是互斥锁 只不过它是多把锁
"""
强调:
    信号量在不同的知识体系中 意思不同：
        1.在并发编程中 信号量就是多把互斥锁
        2.在django中 信号量指的是达到某个条件自动触发(中间件)
        ...

之前使用Lock产生的是单把锁
	类似于单间厕所
信号量是一次性创建多把锁
	类似于公共厕所
"""
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()

6.event事件

子进程\子线程之间可以彼此等待彼此
	eg:
      子A运行到某一个代码位置后发信号告诉子B开始运行
    
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()

7.进程池与线程池(重要)

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

池：降低程序的执行效率 保证计算机硬件的安全
进程池：提前创建好固定个数的进程供程序使用 后续不会再创建
线程池：提前创建好固定个数的线程供程序使用 后续不会再创建
"""
#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)
        """
        add_done_callback
        异步回调:异步任务执行完成后有结果就会自动触发该机制
        """
        pool.submit(task, 123).add_done_callback(func)

8.协程

"""
进程:资源单位
线程:执行单位
并发:多个进程看上去像同时执行的就是并发
协程:单线程下实现并发(效率极高)  
	在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作
	实际上IO操作被我们自己写的代码检测 一旦有则立刻让代码执行别的
	(该技术完全是程序员自己弄出来的 名字也是程序员自己起的)
		核心:自己写代码完成切换+保存状态
"""
import time
from gevent import monkey;monkey.patch_all()#固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn#固定编写 如果有IO自动切换
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

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

总结：

​ 如何不断的提升程序的运行效率？

​ 答：多进程下开多线程 多线程下开协程

作业

1.整理今日内容及博客
2.总结选课系统考试不足
3.预习明日内容>>>:MySQL数据库

这篇关于python学习Day43的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！