多任务(同步异步、互斥锁、死锁、生产者和消费者)

一、同步异步概念

1.多线程开发可能遇到的问题

假设两个线程t1和t2都要对num = 0进行增1运算，t1和t2都给对num修改10次，num的最终结果应该为20.
但是由于是多线程访问，有可能出现下面的情况：
在num = 0时，t1取得num = 0。此时系统把t1调度为"sleeping"状态，把t2转换为"running"状态，t2也获得num = 0。然后t2对得到的值进行加1并赋给num，使得num = 1。然后系统又把t2调度为"sleeping"，把t1转为"running"。线程t1又把它之前得到的0加1后赋值给num。这样，明明t1和t2都完成了1次加1工作，但结果仍然是num = 1。
问题产生的原因就是没有控制多个线程对同一资源的访问，对数据造成破坏，使得线程运行的结果不可预期。这种现象称为"线程不安全"。

2.什么是同步

"同"字从字面上容易理解为一起动作
其实不是，"同"字应是协同、协助、互相配合。
如进程、线程同步，可为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。

3.解决问题的思路

对于文章开头提出的那个计算错误的问题，可以通过线程同步来进行解决。
思路如下：
系统调用t1，然后获取到num的值为0，此时上一把锁，即不允许其他线程操作num
对num的值进行 +1
解锁，此时 num 的值为1，其他的线程就可以使用 num 了，并且此时 num 的值不是0而是1
同理，其他线程在对 num 进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的准确性。

4.异步

同步调用：就是你喊你朋友吃饭，你朋友在忙，你就一直在那等，等你朋友忙完了，你们一起去。
异步调用：就是你喊你朋友吃饭，你朋友说知道了，待会忙完就去找你，你就去做别的了。

二、互斥锁

当多个线程几乎同时修改一个共享数据的时候，需要进行同步控制，线程同步能够保证多个线程安全的访问竞争资源(全局内容)，最简单的同步机制就是使用互斥锁。
某个线程要更改共享数据时，先将其锁定，此时资源的状态为锁定状态，其他线程不能再对资源进行更改，直到该线程将资源状态改为非锁定状态，也就是释放资源，其他的线程才能再次锁定资源。互斥锁保证了每一次只有一个线程进入写入操作。从而保证了多线程下数据的安全性。

threading 模块中定义了Lock类，可以方便的处理锁定：
# 创建锁
mutex = threading.Lock()
# 锁定
mutex.acquire()
# 释放
mutex.release()

其中，锁定方法acquire()可以有一个blocking参数。
如果设定blocking为True，则当前线程会堵塞，直到获取这个锁为止（如果没有指定，那么默认为True）
如果设定blocking为False，则当前线程不会堵塞。

# 上锁和解锁在循环里面
# 每循环一次上一次锁，释放一次资源
from threading import Thread,Lock
g_num = 0
def hanshu1():
    global g_num
    for i in range(100000):
        l.acquire() # 上锁，锁定资源，其他线程不能再锁定资源
        g_num += 1
        l.release() # 解锁，释放资源，其他线程可以锁定资源
    print('函数1',g_num)
def hanshu2():
    global g_num
    for i in range(100000):
        l.acquire() # 上锁，其他线程不能再锁定资源，直到资源被释放，其他线程才可以锁定资源
        g_num += 1
        l.release()
    print('函数2',g_num)
if __name__ == '__main__':
    # 创建一个互斥锁，这个锁默认是未上锁的状态
    l = Lock()
    t1 = Thread(target=hanshu1)
    t2 = Thread(target=hanshu2)
    t1.start()
    t2.start()
'''
打印结果：
函数1 15673