因为Python解释器帮你自动定期进行内存回收，你可以理解为python解释器里有一个独立的线程，每过一段时间它起wake up做一次全局轮询看看哪些内存数据是可以被清空的，此时你自己的程序 里的线程和 py解释器自己的线程是并发运行的，假设你的线程删除了一个变量，py解释器的垃圾回收线程在清空这个变量的过程中的clearing时刻，可能一个其它线程正好又重新给这个还没来及得清空的内存空间赋值了，结果就有可能新赋值的数据被删除了，为了解决类似的问题，python解释器简单粗暴的加了锁，即当一个线程运行时，其它人都不能动，这样就解决了上述的问题，  这可以说是Python早期版本的遗留问题。　

from threading import Thread,Lock

import os,time

def work():

    global n

    lock.acquire()

    temp=n

    time.sleep(0.1)

    n=temp-1

    lock.release()

if __name__ == '__main__':

    lock=Lock()

    n=100

    l=[]

    for i in range(100):

        p=Thread(target=work)

        l.append(p)

        p.start()

    for p in l:

        p.join()

    print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

分析：

　　#1.100个线程去抢GIL锁，即抢执行权限

     #2. 肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()

     #3. 极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL

    #4.直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程

GIL锁与互斥锁综合分析（重点！！！）

#不加锁:并发执行,速度快,数据不安全

from threading import current_thread,Thread,Lock

import os,time

def task():

    global n

    print('%s is running' %current_thread().getName())

    temp=n

    time.sleep(0.5)

    n=temp-1

if __name__ == '__main__':

    n=100

    lock=Lock()

    threads=[]

    start_time=time.time()

    for i in range(100):

        t=Thread(target=task)

        threads.append(t)

        t.start()

    for t in threads:

        t.join()

    stop_time=time.time()

    print('主:%s n:%s' %(stop_time-start_time,n))

'''

Thread-1 is running

Thread-2 is running

......

Thread-100 is running

主:0.5216062068939209 n:99

'''

#不加锁:未加锁部分并发执行,加锁部分串行执行,速度慢,数据安全

from threading import current_thread,Thread,Lock

import os,time

def task():

    #未加锁的代码并发运行

    time.sleep(3)

    print('%s start to run' %current_thread().getName())

    global n

    #加锁的代码串行运行

    lock.acquire()

    temp=n

    time.sleep(0.5)

    n=temp-1

    lock.release()

if __name__ == '__main__':

    n=100

    lock=Lock()

    threads=[]

    start_time=time.time()

    for i in range(100):

        t=Thread(target=task)

        threads.append(t)

        t.start()

    for t in threads:

        t.join()

    stop_time=time.time()

    print('主:%s n:%s' %(stop_time-start_time,n))

'''

Thread-1 is running

Thread-2 is running

......

Thread-100 is running

主:53.294203758239746 n:0

'''

#有的同学可能有疑问:既然加锁会让运行变成串行,那么我在start之后立即使用join,就不用加锁了啊,也是串行的效果啊

#没错:在start之后立刻使用jion,肯定会将100个任务的执行变成串行,毫无疑问,最终n的结果也肯定是0,是安全的,但问题是

#start后立即join:任务内的所有代码都是串行执行的,而加锁,只是加锁的部分即修改共享数据的部分是串行的

#单从保证数据安全方面,二者都可以实现,但很明显是加锁的效率更高.

from threading import current_thread,Thread,Lock

import os,time

def task():

    time.sleep(3)

    print('%s start to run' %current_thread().getName())

    global n

    temp=n

    time.sleep(0.5)

    n=temp-1

if __name__ == '__main__':

    n=100

    lock=Lock()

    start_time=time.time()

    for i in range(100):

        t=Thread(target=task)

        t.start()

        t.join()

    stop_time=time.time()

    print('主:%s n:%s' %(stop_time-start_time,n))

'''

Thread-1 start to run

Thread-2 start to run

......

Thread-100 start to run

主:350.6937336921692 n:0 #耗时是多么的恐怖

'''

互斥锁与join的区别（重点！！！）

from threading import Thread,Lock

import time

mutexA=Lock()

mutexB=Lock()

class MyThread(Thread):

    def run(self):

        self.func1()

        self.func2()

    def func1(self):

        mutexA.acquire()

        print('\033[41m%s 拿到A锁\033[0m' %self.name)

        mutexB.acquire()

        print('\033[42m%s 拿到B锁\033[0m' %self.name)

        mutexB.release()

        mutexA.release()

    def func2(self):

        mutexB.acquire()

        print('\033[43m%s 拿到B锁\033[0m' %self.name)

        time.sleep(2)

        mutexA.acquire()

        print('\033[44m%s 拿到A锁\033[0m' %self.name)

        mutexA.release()

        mutexB.release()

if __name__ == '__main__':

    for i in range(10):

        t=MyThread()

        t.start()

'''

Thread-1 拿到A锁

Thread-1 拿到B锁

Thread-1 拿到B锁

Thread-2 拿到A锁

然后就卡住，死锁了

'''

from threading import Thread,Semaphore

import threading

import time

# def func():

#     if sm.acquire():

#         print (threading.currentThread().getName() + ' get semaphore')

#         time.sleep(2)

#         sm.release()

def func():

    sm.acquire()

    print('%s get sm' %threading.current_thread().getName())

    time.sleep(3)

    sm.release()

if __name__ == '__main__':

    sm=Semaphore(5)

    for i in range(23):

        t=Thread(target=func)

        t.start()

from threading import Thread,Event

import threading

import time,random

def conn_mysql():

    count=1

    while not event.is_set():

        if count > 3:

            raise TimeoutError('链接超时')

        print('<%s>第%s次尝试链接' % (threading.current_thread().getName(), count))

        event.wait(0.5)

        count+=1

    print('<%s>链接成功' %threading.current_thread().getName())

def check_mysql():

    print('\033[45m[%s]正在检查mysql\033[0m' % threading.current_thread().getName())

    time.sleep(random.randint(2,4))

    event.set()

if __name__ == '__main__':

    event=Event()

    conn1=Thread(target=conn_mysql)

    conn2=Thread(target=conn_mysql)

    check=Thread(target=check_mysql)

    conn1.start()

    conn2.start()

    check.start()