叁拾壹

一、线程锁

​ 运行以下代码：

from threading import Thread,Lock

x = 0
mutex = Lock()
def task():
    global x
    for i in range(200000):
        x = x+1

if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task)
    t3 = Thread(target=task)
    t1.start()
    t2.start()
    t3.start()

    t1.join()
    t2.join()
    t3.join()
    print(x)
    
440215

​ 正常运行代码应该得到600000，而实际结果为440215。这是因为代码过长，cpu进行了代码的切换，切入的时间可能恰好是运算的过程中，使得一次完整的计算没有完成，便直接运行其他线程。当再次切回这个线程时，程序会接着上一次的结果运行，造成切出去时运算的数据丢失。

​ 如果计算量少，则可能不会出现上述问题，计算量越大，出现的结果偏差可能越大。

​ 因此为了解决数据丢失的问题，需要使用互斥锁。使用.acquire()方法获取对象，使用.release()释放对象，会完整运行完其中的线程后再进行其他线程。与进程一样，将多线程并行改为串行，保证了数据的安全。

from threading import Thread,Lock

x = 0
mutex = Lock()
def task():
    global x
    mutex.acquire()
    for i in range(200000):
        x = x+1
    mutex.release()

if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task)
    t3 = Thread(target=task)
    t1.start()
    t2.start()
    t3.start()

    t1.join()
    t2.join()
    t3.join()
    print(x)

二、死锁问题

​ 假设两个线程分别拿到了两个锁，而且并未释放，它们都需要拿到对方的锁进程才可以进行下去。这样双方都拿不到彼此需要的锁，导致程序不能进行下去，这就是锁死问题。如下程序，task2中，time.sleep使线程切换，导致另一个线程也得到一把锁，两个线程相互锁死。

from threading import Thread,Lock
mutex1 = Lock()
mutex2 = Lock()
import time
class MyThreada(Thread):
    def run(self):
        self.task1()
        self.task2()
    def task1(self):
        mutex1.acquire()
        print(f'{self.name} 抢到了 锁1 ')
        mutex2.acquire()
        print(f'{self.name} 抢到了 锁2 ')
        mutex2.release()
        print(f'{self.name} 释放了 锁2 ')
        mutex1.release()
        print(f'{self.name} 释放了 锁1 ')

    def task2(self):
        mutex2.acquire()
        print(f'{self.name} 抢到了 锁2 ')
        time.sleep(0.1)
        mutex1.acquire()
        print(f'{self.name} 抢到了 锁1 ')
        mutex1.release()
        print(f'{self.name} 释放了 锁1 ')
        mutex2.release()
        print(f'{self.name} 释放了 锁2 ')

for i in range(3):
    t = MyThreada()
    t.start()
    
Thread-1 抢到了 锁1 
Thread-1 抢到了 锁2 
Thread-1 释放了 锁2 
Thread-1 释放了 锁1 
Thread-1 抢到了 锁2 
Thread-2 抢到了 锁1 

三、递归锁

​ 可以使用递归锁来解决死锁的问题。在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

​ 这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁。

from threading import Thread,RLock

mutex1 = RLock()
mutex2 = mutex1

import time
class MyThreada(Thread):
    def run(self):
        self.task1()
        self.task2()
    def task1(self):
        mutex1.acquire()
        print(f'{self.name} 抢到了 锁1 ')
        mutex2.acquire()
        print(f'{self.name} 抢到了 锁2 ')
        mutex2.release()
        print(f'{self.name} 释放了 锁2 ')
        mutex1.release()
        print(f'{self.name} 释放了 锁1 ')

    def task2(self):
        mutex2.acquire()
        print(f'{self.name} 抢到了 锁2 ')
        time.sleep(1)
        mutex1.acquire()
        print(f'{self.name} 抢到了 锁1 ')
        mutex1.release()
        print(f'{self.name} 释放了 锁1 ')
        mutex2.release()
        print(f'{self.name} 释放了 锁2 ')

for i in range(3):
    t = MyThreada()
    t.start()

四、信号量

​ Semaphore管理一个内置的计数器，每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

from threading import Thread,currentThread,Semaphore
import time

def task():
    sm.acquire()
    print(f'{currentThread().name} 在执行')
    time.sleep(3)
    sm.release()

sm = Semaphore(5)
for i in range(15):
    t = Thread(target=task)
    t.start()
    
Thread-1 在执行
Thread-2 在执行
Thread-3 在执行
Thread-4 在执行
Thread-5 在执行
Thread-7 在执行
Thread-8 在执行
Thread-6 在执行
Thread-9 在执行
Thread-10 在执行
Thread-11 在执行
Thread-12 在执行
Thread-13 在执行
Thread-14 在执行
Thread-15 在执行

五、全局解释器锁GIL

​ C python自带垃圾回收机制，在线程运行时如果垃圾回收机制也同时运行，会导致相互“抢夺”数据，因此GIL锁可以使同一进程同一时间只能运行一个线程，这样就能保证线程的数据安全，但是导致了无法使用多核优势，减低运算效率。

​ 如果一个线程抢掉了GIL,如果遇到io或者执行时间过长(cpu被剥夺),会强行释放掉GIL锁,以便其他的线程抢占GIL。

六、多进程与多线程的适用场景

​ 假设有四个任务要进行处理，那么有两种方案可以选择，开启四个进程和一个进程下开启四个线程。

​ 计算密集型推荐使用多进程；

​ 假设每个人物要进行计算10秒，如果采用多线程，因为同一时刻只能执行一个线程，所以串行4个线程，每个都需要10s，一共40s。

def work1():
    res=0
    for i in range(100000000):
        res*=i

if __name__ == '__main__':
    t_list = []
    start = time.time()
    for i in range(4):
        t = Thread(target=work1)
        # t = Process(target=work1)
        t_list.append(t)
        t.start()
    for t in t_list:
        t.join()
    end = time.time()
    # print('多线程',end-start) # 多线程 15.413789510726929
    print('多进程',end-start) # 多进程 4.711405515670776

​ io密集型推荐使用多线程；

​ 假设4个任务90%时间处于io状态，采用多线程，每个线程io时间都不占用cpu，可以执行其他进程，因此所需时间为10s加运算四个就成时间。而采用多进程，可以实行并行，但是花费时间为10s加一个任务执行时间加开启进程的时间。

def work1():
    x = 1+1
    time.sleep(5)

if __name__ == '__main__':
    t_list = []
    start = time.time()
    for i in range(4):
        t = Thread(target=work1)
        # t = Process(target=work1)
        t_list.append(t)
        t.start()
    for t in t_list:
        t.join()
    end = time.time()
    print('多线程',end-start) #  多线程 5.002625942230225
    # print('多进程',end-start) # 多进程 5.660863399505615