12互斥锁来解决多线程共享全局变量的问题

1. 多线程全局变量存在的问题（一块执行会造成数据同步存在问题）

import threading
import time
g_num = 0


def test1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("---in test1 g_num = %d---" % g_num)


def test2(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("---in test2 g_num = %d---" % g_num)


def main():
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))

    t1.start()
    t2.start()

    # 等待上面两个线程执行完毕---
    time.sleep(5)

    print("---in main Thread g_num = %d" % g_num)


if __name__ == "__main__":
    main()

2. 当多个线程几乎同时修改某一个共享数据的时候，就需要进行同步控制，互斥锁就可以用来解决这问题。

3. 原理：某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

4. threading模块中定义了Lock类，可以方便的处理锁定。

lock1 = threading.Lock()
lock2 = threading.Lock()
lock3 = threading.Lock()
# 对lock2,和lock3上锁
lock2.acquire()
lock3.acquire()


class Task1(threading.Thread):
    def run(self):
        while True:
            if lock1.acquire():
                print("...task1...")
                time.sleep(1)
                # 释放lock2的锁
                lock2.release()


class Task2(threading.Thread):
    def run(self):
        while True:
            if lock2.acquire():
                print("...task2...")
                time.sleep(1)
                lock3.release()


class Task3(threading.Thread):
    def run(self):
        while True:
            if lock3.acquire():
                print("...task3...")
                time.sleep(1)
                lock3.release()


if __name__ == "__main__":
    t1 = Task1()
    t2 = Task2()
    t3 = Task3()
    t1.start()
    t2.start()
    t3.start()