4.27内容整理

死锁现象与递归锁

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

from threading import Thread,Lock
import time

mutexA = mutexB = Lock()
class MyThead(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 = MyThead()
        t.start()

递归锁

递归锁的特点

　　可以被连续的acquire和release

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

　　它的内部有一个计数器，每acquire一次计数加一 每realse一次计数减一

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

 

信号量

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

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

#如果我们将互斥锁比喻成一个厕所的话，那么信号量就相当于多个厕所

from threading import Thread,Semaphore

import time

import random

#利用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)
    even.wait()
    print('%s 车加油门飙车走了'%name)

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

　

线程q

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

为什么同一个进程下还会去使用队列呢

因为队列是  管道+锁

所以用队列还是为了保证数据的安全

　

import queue

#我们现在使用的队列都是只能在本地测试使用

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

#后进先出q
q = queue.LifoQueue(3)
q.put(1)
q.put(2)
q.put(3)
print(q,get())

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

　

进程池与线程池

先回顾之前TCP服务端实现并发的效果是怎么玩的

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

无论是开设进程也好还是开设线程也好，是不是都需要消耗资源
只不过开设线程的消耗比开设进程的稍微小一点而已
我们是不可能做到无限制的开设进程和线程的因为计算机硬件的资源更不上
硬件的开发速度远远赶不上软件呐
我们的宗旨应该是在保证计算机硬件能够正常工作的情况下最大限度的利用它

池的概念
什么是池？
    池是用来保证计算机硬件安全的情况下最大限度的利用计算机
    它降低了程序的运行效率但是保证了计算机硬件的安全，从而让你写的程序能够正常运行

基本使用

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

#pool = ThreadPoolExecutor(5)池子里面固定只有五个线程
#括号内可以传数字，不传的话默认会开设当前计算机cpu个数五倍的线程
pool = ProcessPoolExecutor(5)
#括号内可以传数字，不传的话默认会开设当前计算机cpu个数进程
池子造出来之后里面会固定存在五个线程
这子个线程不会出现重复创建和销毁的过程
池子造出来之后里面会固定的几个进程
这几个进程不会出现重复创建和销毁的过程

池子的使用非常的简单
你只需要将需要做的任务往池子中提交即可，自动会有人来服务你

　　

def task(n):
    print(n,os.getpid())
    time.sleep(2)
    return n**n
def call_back(n):
    print ('call_back:',result())

任务的是交方式
    同步：提交任务之后原地等待任务的返回结果期间不做任何事
    异步：提交任务之后不等待任务的返回结果执行继续往下执行
    返回结果如何获取
    异步提交任务的对它回结果应该通过回调机制来获取
    回调机制，就相当于给每个异步任务绑定了一个定时炸弹
    一旦该任务有结果立刻触发爆炸

if __name__=='__main__':
    t_list = []
    for i in range(20);
        res = pool.submit(task,i).add_done_callback(call_back)
# print(res.result())  # result方法   同步提交
        # t_list.append(res)
    # 等待线程池中所有的任务执行完毕之后再继续往下执行
    # pool.shutdown()  # 关闭线程池  等待线程池中所有的任务运行完毕
    # for t in t_list:
    #     print('>>>:',t.result())  # 肯定是有序的
"""
程序有并发变成了串行
任务的为什么打印的是None
res.result() 拿到的就是异步提交的任务的返回结果
"""

总结

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
pool = ProcessPoolExecutor(5)
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(100000):
        i + 1
def func2():
    for i in range(100000):
        i + 1

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

切换 + yield
import time

def func1():
    while True:
        100000 + 1
        yield
def func2():
    g = func1()
    for i in range(1000000):
        i + 1
        next(g)
start_time = time.time()
func2()
print(time.time() - start_time)

　

gevent模块

from gevent import monkey;monkey.patch_all()

import time

from gevent import spawn

 

#gevent模块本身无法检测常见的一些io操作，在使用的时候需要你额外的导入一名话，又由于上面的两名话在使用geven模块的时候是肯定要导入的

所以还支持简写

from gevent import monkey;monkey.patch_all()

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

总结　

理想状态：

　　我们可以通过多进程下面开设多线程，多线程下面再开设协程序，从而使我们的程序执行效率提升