死锁与递归锁、信号量、Event事件、线程Q(队列)、池、补充并发的本质、协程、gevent模块、协程实现并发

【死锁与递归锁】

死锁

# 当知道所得使用抢锁必须要释放锁，其实在操作锁的时候也极其容易产生死锁现象（程序阻塞）
# 互斥锁的死锁现象
from threading import Thread, Lock
import time

mutexA = Lock()
mutexB = Lock()


# 类只要加（）多次，产生的肯定是不同的对象，如果想要实现多次加（）得到的是相同的对象，使用单例模式
# 单例模式（Singleton Pattern） 是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。


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



主线程同时创建了10子线程，10个子线程同时开始运行函数func1，当一个子线程抢到了A锁后，
其他的子线程就已经没资格运行A锁下面的代码了，所以该子线程可以不用抢就能拿到B锁释放B锁，
最后再释放A锁。该子线程放掉A锁后，其他的子线程会去抢A锁，但是现在情况来了，
该子线程运行完了函数func1后，继续要运行函数func2时，又要抢B锁，此时其他子线程还在抢A锁，
所以该子线程还是能顺利的抢到B锁，但这个时候睡了2s，
此时其他的子线程肯定已经有一个子线程抢到了A锁，该子线程睡醒了后，想抢A锁，
但此时A锁已经被其他子线程抢到了，而且这个抢到A锁的子线程此时也正要想抢B锁，
两个子线程都想抢对方手里的锁！！！

就卡死了！！！这就是死锁现象！！！

递归锁

'''
递归锁的特点：
   可以被连续的acquire和release
   但是只能被第一个抢到这把锁执行上述操作
   它的内部有一个计数器，每acquire一次计数器+1，每release一次计数器-1
   只要计数不为0，那么其他人都无法抢到该锁
'''
from threading import Thread, Lock, RLock
import time

mutexA = mutexB = RLock()


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

 。

。

【信号量】

　　信号量：信号量在不同的阶段可能对应着不同的技术点，在并发编程中信号量指的是锁

# 模拟抢厕所
import random
import time
from threading import Thread, Semaphore

# 信号量关键字：Semaphore
wc = Semaphore(5)  # ()中的数字是信号量的初始值


def task(name):
    wc.acquire()
    print('%s 正在蹲坑' % name)
    # time.sleep(3)  # 如果蹲坑时间一样，发现5个信号量，那么5个人同时出来
    time.sleep(random.randint(1, 5))  # 蹲坑时间不一样，发现5个信号量，进去和出来的数量不一样
    wc.release()


if __name__ == '__main__':
    for i in range(20):
        t = Thread(target=task, args=('伞兵%s号' % i,))
        t.start()

。

。

 【Event事件】

子进程之间可以彼此等待彼此，或者子线程之间可以彼此等待彼此

例如：子进程A运行到某一行代码位置后，发信号告诉子进程B开始运行

也就是说比如开了两个子进程，两个子进程不是同时运行的， 有一个子进程要依赖于另一个子进程给它发信号后，才能执行。 这就叫event事件

# 模拟等红绿灯


import time
from threading import Thread, Event

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(5):
        t = Thread(target=car, args=('第%s辆' % i,))
        t.start()

 

 。

。

【线程Q】

'''
线程Q：
同一个进程下多个线程数据是共享的
为什么还会去使用队列呢？
    因为队列是：管道+锁
    这样是为了保证数据的安全
'''

import queue

# 后进先出q
q = queue.LifoQueue(3)  # last in first out
q.put(1)
q.put(2)
q.put(3)
print(q.get())  # 3

# 优先级q ，可以放给队列中的数据设置优先级
q = queue.PriorityQueue(4)
q.put((10, '111'))
q.put((100, '222'))
q.put((0, '333'))
q.put((-5, '444'))
print(q.get())  # (-5, '444'), put()内放一个元组，第一个元素是优先级，数字越小优先级越高

 。

。

【进程池，线程池】

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

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

（线程池）

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time

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


def task(n):
    print(n)
    time.sleep(2)
    return n  # return方法，同步提交


'''
任务的提交方式：
    同步提交：提交任务以后，在原地等待任务的返回结果，期间不能做任何事情
    异步提交：提交任务以后，不会等待任务的返回结果，继续往下执行
'''

t_list = []  # 保证进程先起起来
# pool.submit(task, 1)  # 朝池子中提交任务，异步提交（不等待任务的返回结果）
# print('主')
for i in range(20):
    res = pool.submit(task, i)
    # print(res.result())  # 程序由并发变成了串行，return 拿到的就是异步提交的任务的返回结果
    t_list.append(res)  # 等待线池中所有的任务执行完毕以后再继续往下执行
# pool.shutdown() # 关闭线程池/等待线程池中所有的任务运行完毕
for t in t_list:
    print('>>>>', t.result())  # 拿到的结果是有序的

 

（进程池）

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

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


def task(n):
    print(n, os.getpid())
    time.sleep(2)
    return n


# 如何拿到返回结果：异步提交任务的返回结果，应该通过回调机制来获取
# 回调机制;相当于给每个异步任务绑定一个定时炸弹，一旦该任务有结果，立刻触发爆炸
def call_back(n):
    print('call_back>>>>', n.result())  # 拿到返回结果


if __name__ == '__main__':
    t_list = []  # 保证进程先起起来
    for i in range(20):
        res = pool.submit(task, i).add_done_callback(call_back)
        # t_list.append(res)
    # 等待线池中所有的任务执行完毕以后再继续往下执行
    pool.shutdown()  # 关闭线程池/等待线程池中所有的任务运行完毕
    for t in t_list:
        print('>>>>', t.result())  # 拿到的结果是有序的

。

。

【并发的本质】

 并发的本质
    基于单线程来实现并发
    即只用一个主线程（很明显可利用的cpu只有一个）情况下实现并发
    为此我们需要先回顾下并发的本质：
        切换+保存状态

CPU正在运行一个任务
会在两种情况下切走去执行其他的任务（切换由操作系统强制控制）
一种情况是该任务发生了阻塞
另外一种情况是该任务计算的时间过长或有一个优先级更高的程序替代了它。
--------------------------------------------------------------------------------------
yield关键字

yield可以保存状态
    yield的状态保存与操作系统的保存线程状态很像，但是yield是代码级别控制的，更轻量级
2 send可以把一个函数的结果传给另外一个函数
    以此实现单线程内程序之间的切换
        

。

。

【协程】

进程:资源单位
线程:执行单位
协程:这个概念完全是程序员自己意淫出来的 根本不存在单线程下实现并发
    我们程序员自己再代码层面上检测我们所有的Io操作,一旦遇到IO了 我们在代码级别完成切换
    这样给CPu的感觉是你这个程序一直在运行 没有IO从而提升程序的运行效率
多道技术
    切换+保存状态
    CPU两种切换
        1.程序遇到IO
        2.程序长时间占用
TCP服务端
    accept
    recv
代码如何做到：切换+保存状态？
    切换：切换不一定是提升效率，也有可能是降低效率
    IO切   提升
    没有IO切   降低
    保存状态：保存上一次我执行的状态，下一次接着上一次的操作继续往后执行
    yield

2】优点

• 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
• 单线程内就可以实现并发的效果，最大限度地利用cpu
• 应用程序级别速度要远远高于操作系统的切换

3】缺点

• 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
• 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程(多个任务一旦有一个阻塞没有切，整个线程都阻塞在原地,该线程内的其他的任务都不能执行了)

4】总结

• 1.必须在只有一个单线程里实现并发
• 2.修改共享数据不需加锁
• 3.用户程序里自己保存多个控制流的上下文栈
• 4.附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

代码示例

协程代码示例：

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



# spawn监管IO操作，gevent模块本身无法检测常见的一些io操作，在使用的时候需要额外的导入一句话:from gevent import monkey
# monkey.patch_all()
# 又由于上面的两句话在使用gevent模块的时候需要经常性的重复导入，所以gevent模块还提供了简写：from gevent import monkey;monkey.patch_all()，

。

。

【gevent模块】

'''
Gevent模块的功能包括：

实现并发同步或异步编程：Gevent模块使得使用协程实现并发编程变得简单高效。通过Greenlet模式，我们可以创建并管理多个并发任务，实现异步执行。
事件驱动的网络编程：Gevent模块提供了一个事件驱动的网络编程框架，可以轻松处理各种网络I/O操作，如socket连接、数据读取和写入等。
支持异步调用：Gevent模块支持异步调用，使得我们可以编写非阻塞的代码，无需担心线程或进程阻塞问题。
简化并发编程：Gevent模块简化了并发编程的复杂性，提供了简单易用的API和模式，使得我们能够轻松地处理并发任务。
高性能：Gevent模块在处理大量并发任务时表现出高性能，可以有效地利用系统资源，提高程序的执行效率。
'''
import time
from gevent import spawn
from gevent import monkey

monkey.patch_all()  # 猴子补丁，将程序中所有的阻塞操作都替换为非阻塞操作


def heng():
    print('哼')
    time.sleep(2)
    print('哼哼')


def ha():
    print('哈')
    time.sleep(3)
    print('哈哈')

# 新增函数，让它在执行时休眠4秒（最长）
def heiheihei():
    print('嘿嘿嘿')
    time.sleep(4)
    print('嘿嘿嘿')


start_time = time.time()
g1 = spawn(heng)
g2 = spawn(ha)
g3 = spawn(heiheihei)  
g1.join()
g2.join()  # 等待被检查的任务执行完毕，再往后继续执行，3.042381525039673
g3.join()  # 4.035170078277588  验证： 耗时和最长的时间有关系
print(time.time() - start_time)  

 

 。

。

【协程实现TCP并发】

服务端

# 不借助多线程，多进程，就单纯的单核状态下，实现并发
from gevent import monkey;monkey.patch_all()
import socket
from gevent import spawn


def encapsulation(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(encapsulation, conn)


if __name__ == '__main__':
    g1 = spawn(server, '127.0.0.1', 8000)
    g1.join()



==============================================
客户端

import socket
from threading import Thread, current_thread


# 模拟多个客户端
def x_client():
    client = socket.socket()
    client.connect(('127.0.0.1', 8000))
    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(100):
        t = Thread(target=x_client)
        t.start()


# ===========================总结
'''
单线程下实现并发
我们可以通过多进程下面开始多线程
多线程下再开设协程
从而使我们的程序更加的高效

'''