由于线程之间随机调度：某线程可能在执行n条后，CPU接着执行其他线程。为了多个线程同时操作一个内存中的资源时不产生混乱，我们使用锁。

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。

可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

创建锁：

lock=threading.Lock()   

cond=threading.Condition(lock=lock)

锁的方法：

cond.acquire()：  获得锁

cond.wait()           等待通知

cond.notify()        通知正在等待的锁

cond.notify_all()   通知所有正在等待的锁

cond.release()       释放锁

实例：

在同一个进程中所创建出来的多个线程，在加上线程锁后，只要在这个进程结束前释放，那么这个锁就可以被其他线程使用。

import threading


def work_1():
    for i in range(8):
        mutex1.acquire()
        print("A")
        try:
            mutex2.release()
        except:
            pass


def work_2():
    for i in range(8):
        mutex2.acquire()
        print("B")
        try:
            mutex1.release()
        except:
            pass


if __name__ == "__main__":
    mutex1 = threading.Lock()
    mutex2 = threading.Lock()
    t1 = threading.Thread(target=work_1)
    t2 = threading.Thread(target=work_2)
    t2.start()
    t1.start()
    t1.join()
    t2.join()
    try:
        mutex1.release()
    except:
        print("释放锁2")
    try:
        mutex2.release()
    except:
        print("释放锁1")

结果为：

B
A
B
A
B
A
B
A
B
A
B
A
B
A
B
A
释放锁1