并发编程中死锁、递归锁、进程/线程池、协程TCP服务器并发等知识点

1、死锁

定义; 类似两个人分别被囚禁在两间房子里，A手上拿着的是B囚禁房间的钥匙，而B拿着A的钥匙，两个人都没法出去，没法给对方开锁，进而造成死锁现象。
具体例子代码如下：

# -*-coding:utf-8 -*-
from threading import Thread,Lock,RLock
import time
muxeA=Lock()
muxeB=Lock()

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

    def func1(self):
        muxeA.acquire()
        print('%s抢到A锁了'%self.name)
        muxeB.acquire()
        print('%s抢到B锁了' % self.name)
        muxeB.release()
        muxeA.release()

    def func2(self):
        muxeB.acquire()
        print('%s抢到B锁了' % self.name)
        time.sleep(2)
        muxeA.acquire()
        print('%s抢到A锁了' % self.name)
        muxeA.release()
        muxeB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

分析：
当执行func1的时候，第一个人（a)先抢到锁A,这时候，
其他人只能继续等待抢锁A,没有人跟a抢锁B，所以a也抢到锁B，
拿到锁B后，a就把锁B先释放掉，再释放锁A,
继续执行func2,a也顺利抢到锁B，这时候，睡眠2s，
而锁A已经被第二个人抢到了，这时候，第二个人只拿到锁A，没有拿到锁B，
所以没有释放锁A,而a一直在等待抢锁A，没有释放锁B，
所以这时候就造成等待死循环的情况。

执行结果如下：

2、递归锁：

递归锁使用：from reading import RLock

递归锁的特点：
1、可以被连续的acquire和release
2、但是，只能第一个抢到这把锁执行上述操作
3、它内部有一个计数器，每acquire一次计数加一，每realse一次计数减一
4、只要计数不为0，那么其他人都无法抢到该锁

具体例子代码如下：

# -*-coding:utf-8 -*-
from threading import Thread,RLock
import time

muxeA=muxeB=RLock()

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

    def func1(self):
        muxeA.acquire()
        print('%s抢到A锁了'%self.name)
        muxeB.acquire()
        print('%s抢到B锁了' % self.name)
        muxeB.release()
        muxeA.release()

    def func2(self):
        muxeB.acquire()
        print('%s抢到B锁了' % self.name)
        time.sleep(2)
        muxeA.acquire()
        print('%s抢到A锁了' % self.name)
        muxeA.release()
        muxeB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

执行结果如下（没有出现死锁现象）：

3、信号量：
定义：就相当于多个互斥锁：
具体例子如下：

from threading import Thread,Semaphore
import time,random
s=Semaphore(5)

def task(name):
    s.acquire()
    print('%s号停车位正在停车'%name)
    time.sleep(random.randint(1,5))
    s.release()

if __name__ == '__main__':
    for i in range(10):
        t=Thread(target=task,args=(i,))
        t.start()

4、事件

比如：一些线程需要等待另一些线程完成才可以操作， 就类似发送信号一样。

from threading import Thread,Event
import time,random
event=Event()
def light():
    print("红灯")
    time.sleep(3)
    print('绿灯')
    event.set() #发送信号

def car(name):
    print('%s车正在等红灯'%name)
    event.wait()  #等待对方发信号过来
    print('%s车过绿灯'%name)

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

5、线程池、进程池：

池的概念：就是保证计算硬件的安全前提下，最大限度的利用计算机。
它降低运行效率，但是，保证了计算机硬件的安全。
注意： 池里面原有的线程或进程是不会重复出现创建和销毁的过程。

#线程池的创建：
pool=ThreadPoolExecutor()
#括号内为线程池中进程的个数，你可以自己设置，默认是5个，最大不会超过32个
ThreadPoolExecutor类中的参数max_workers就是池中线程数：初始设置代码如下：
max_workers = min(32, (os.cpu_count() or 1) + 4)

#进程池的创建：
pool=ProcessPoolExecutor()
#它的参数如下：os.cpu_count()表示电脑的CPU核数
self._max_workers = os.cpu_count() or 1

总结：关键代码如下：
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
pool=ProcessPoolExecutor()
pool=ThreadPoolExecutor(5)
res=pool.submit(task,i).add_done_callback(call_back)

进程/线程池的例子如下：

# -*-coding:utf-8 -*-
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time,os

# pool=ThreadPoolExecutor(5)
pool=ProcessPoolExecutor()

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

if __name__ == '__main__':
    # list_pool=[]
    for i in range(10):
        res=pool.submit(task,i).add_done_callback(call_back)

6、协程、gevent模块：

实质：就是一个思想，它是由程序员自己在代码层面上检测IO操作，一旦遇到IO操作就会在代码级别上完成切换
注意：IO操作下的切换才是提高效率的，非IO操作下的切换会降低效率。

gevent模块的使用需要打猴子补丁，不然不会检测到像time.sIeep()等O操作

#猴子补丁
from gevent import monkey
monkey.patch_all()

具体例子如下：

# -*-coding:utf-8 -*-
#猴子补丁
from gevent import monkey
monkey.patch_all()

from gevent import spawn
import time

def ha():
    print('hahaha')
    time.sleep(2)
    print('hahaha')

def xixi():
    print('xixi')
    time.sleep(3)
    print('xixi')

if __name__ == '__main__':
    start_time=time.time()
    g1=spawn(ha)
    g2=spawn(xixi)
    g1.join()
    g2.join()
    print(time.time()-start_time)

7、基于协程的TCP并发：

服务端例子如下：

 # -*-coding:utf-8 -*-
 #猴子补丁
 from gevent import monkey;monkey.patch_all()

 from gevent import spawn
 import socket

 def new_server(ip,addr):
     server=socket.socket()
     server.bind((ip,addr))
     server.listen(5)
     while True:
         conn,addr=server.accept()
         spawn(connect,conn)

 def connect(conn):
     while True:
         try:
             data=conn.recv(1024)
             print(data.decode())
             if len(data)==0:break
             conn.send(data.upper())
         except Exception as e:
             print(e)
             break
 if __name__ == '__main__':
     g1=spawn(new_server,'localhost',8080)
     g1.join()

客户端代码如下：

 # -*-coding:utf-8 -*-
 import socket
 from threading import Thread,current_thread

 def new_client():
     c=socket.socket()
     c.connect(('localhost',8080))
     while True:
         data=('你好，我是%s'%current_thread().name)
         c.send(data.encode())
         data1=c.recv(1024)
         print(data)

 if __name__ == '__main__':
     for i in range(200):
         t=Thread(target=new_client)
         t.start()