day39

线程锁

例子(线程锁)

不加锁的情况

from threading import Thread, Lock

x = 0
mutex = Lock()
def task():
    global x
    for i in range(100000):
        x += 1
        '''
        
        ==》t1 的 x刚拿到0 保存状态 就被切了
        ==》t2 的 x拿到0 进行+1       1
        ==》t1 又获得运行了  x = 0  +1  1
        
        思考:一共加了几次1? 加了两次1 真实运算出来的数字本来应该+2 实际只+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)  #结果<=300000(注意只有当range数据较大时才会产生这个问题)

加锁的情况

from threading import Thread, Lock

x = 0
mutex = Lock()
def task():
    global x
    mutex.acquire()
    
    for i in range(100000):
        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)  #300000

死锁

介绍

死锁的这个概念在很多地方都存在,大概介绍下是怎么产生的

  • A拿了一个苹果
  • B拿了一个香蕉
  • A现在想再拿个香蕉,就在等待B释放这个香蕉
  • B同时想要再拿个苹果,这时候就等待A释放苹果
  • 这样就是陷入了僵局,这就是生活中的死锁

python中在线程间共享多个资源的时候,如果两个线程分别占有一部分资源并且同时等待对方的资源,就会造成死锁。

因为系统判断这部分资源都正在使用,所有这两个线程在无外力作用下将一直等待下去。

例子(死锁)

import threading
import time

lock_apple = threading.Lock()
lock_banana = threading.Lock()

class MyThread(threading.Thread):

    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.fun1()
        self.fun2()

    def fun1(self):

        lock_apple.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放

        print ("线程 %s , 想拿: %s--%s" %(self.name, "苹果",time.ctime()))

        lock_banana.acquire()
        print ("线程 %s , 想拿: %s--%s" %(self.name, "香蕉",time.ctime()))
        lock_banana.release()
        lock_apple.release()


    def fun2(self):

        lock_banana.acquire()
        print ("线程 %s , 想拿: %s--%s" %(self.name, "香蕉",time.ctime()))
        time.sleep(0.1)

        lock_apple.acquire()
        print ("线程 %s , 想拿: %s--%s" %(self.name, "苹果",time.ctime()))
        lock_apple.release()

        lock_banana.release()

if __name__ == "__main__":
    for i in range(0, 10):  #建立10个线程
        my_thread = MyThread()  #类继承法是python多线程的另外一种实现方式
        my_thread.start()

-----------------------------------我是一条分割线---------------------------------

线程 Thread-1 , 想拿: 苹果--Sun Apr 28 12:21:06 2019
线程 Thread-1 , 想拿: 香蕉--Sun Apr 28 12:21:06 2019
线程 Thread-1 , 想拿: 香蕉--Sun Apr 28 12:21:06 2019
线程 Thread-2 , 想拿: 苹果--Sun Apr 28 12:21:06 2019

上面的代码其实就是描述了苹果和香蕉的故事。大家可以仔细看看过程。下面我们看看执行流程

  • fun1中,线程1先拿了苹果,然后拿了香蕉,然后释放香蕉和苹果,然后再在fun2中又拿了香蕉,sleep 0.1秒。
  • 在线程1的执行过程中,线程2进入了,因为苹果被线程1释放了,线程2这时候获得了苹果,然后想拿香蕉
  • 这时候就出现问题了,线程一拿完香蕉之后想拿苹果,返现苹果被线程2拿到了,线程2拿到苹果执行,想拿香蕉,发现香蕉被线程1持有了
  • 双向等待,出现死锁,代码执行不下去了

上面就是大概的执行流程和死锁出现的原因。在这种情况下就是在同一线程中多次请求同一资源时候出现的问题。

递归锁(RLock)

介绍

  • 为了支持在同一线程中多次请求同一资源,python提供了"递归锁":threading.RLock。
  • RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次acquire。直到一个线程所有的acquire都被release,其他的线程才能获得资源。

例子(递归锁)

下面我们用递归锁RLock解决上面的死锁问题:

import threading
import time

lock = threading.RLock()  #递归锁


class MyThread(threading.Thread):

    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.fun1()
        self.fun2()

    def fun1(self):

        lock.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放

        print (f"线程{self.name}, 想拿:'苹果'--{time.ctime()}" )

        lock.acquire()
        print (f"线程{self.name}, 想拿: '香蕉'--{time.ctime()}" )
        lock.release()
        lock.release()


    def fun2(self):

        lock.acquire()
        print (f"线程{self.name}, 想拿: '香蕉'--{time.ctime()}" )
        time.sleep(0.1)

        lock.acquire()
        print (f"线程{self.name}, 想拿:'苹果'--{time.ctime()}" )
        lock.release()

        lock.release()

if __name__ == "__main__":
    for i in range(0, 3):  #建立10个线程
        my_thread = MyThread()  #类继承法是python多线程的另外一种实现方式
        my_thread.start()

线程Thread-1, 想拿:'苹果'--Wed Sep 18 17:01:30 2019
线程Thread-1, 想拿: '香蕉'--Wed Sep 18 17:01:30 2019
线程Thread-1, 想拿: '香蕉'--Wed Sep 18 17:01:30 2019
线程Thread-1, 想拿:'苹果'--Wed Sep 18 17:01:30 2019
线程Thread-2, 想拿:'苹果'--Wed Sep 18 17:01:30 2019
线程Thread-2, 想拿: '香蕉'--Wed Sep 18 17:01:30 2019
线程Thread-2, 想拿: '香蕉'--Wed Sep 18 17:01:30 2019
线程Thread-2, 想拿:'苹果'--Wed Sep 18 17:01:30 2019
线程Thread-3, 想拿:'苹果'--Wed Sep 18 17:01:30 2019
线程Thread-3, 想拿: '香蕉'--Wed Sep 18 17:01:30 2019
线程Thread-3, 想拿: '香蕉'--Wed Sep 18 17:01:30 2019
线程Thread-3, 想拿:'苹果'--Wed Sep 18 17:01:30 2019

上面我们用一把递归锁,就解决了多个同步锁导致的死锁问题。大家可以把RLock理解为大锁中还有小锁,只有等到内部所有的小锁,都没有了,其他的线程才能进入这个公共资源。

思考

如果我们都加锁也就是单线程了,那我们还要开多线程有什么用呢?

  • 这里解释下,在访问共享资源的时候,锁是一定要存在的。
  • 但是我们的代码中,不总是在访问公共资源的,还有一些其他的逻辑可以使用多线程。
  • 所以我们在代码里面加锁的时候,要注意在什么地方加,对性能的影响最小,这个就靠对逻辑的理解了。

信号量(Semphare)

介绍

它控制同一时刻多个线程访问同一个资源的线程数

  • 实例化时,指定使用量。
  • 其内置计数器,锁定时+1, 释放时-1,计数器为0则阻塞。
  • acquire(blocking=True,timeout=None)
  • release()释放锁

例子(信号量)

from threading import Thread,currentThread,Semaphore
import time


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

sm = Semaphore(4)
for i in range(12):
    t = Thread(target=task)
    t.start()

Thread-1 在执行
Thread-2 在执行
Thread-3 在执行
Thread-4 在执行

Thread-5 在执行
Thread-6 在执行
Thread-7 在执行
Thread-8 在执行

Thread-9 在执行
Thread-10 在执行
Thread-11 在执行
Thread-12 在执行

GIL(全局解释器锁)

介绍

问题一:为什么python在多线程中为什么不能实现真正的并行操作呢(即在多CPU中执行不同的线程)?

  • 这就要提到python中大名鼎鼎GIL,那什么是GIL?
  • GIL:全局解释器锁 无论你启多少个线程,你有多少个CPU, Python在执行的时候只会的在同一时刻只允许一个线程(线程之间有竞争)拿到GIL在一个CPU上运行。
  • 当线程遇到IO等待或到达者轮询时间的时候,CPU会切换,把CPU的时间片让给其他线程执行.
  • CPU切换需要消耗时间和资源,所以计算密集型的功能(比如加减乘除)不适合多线程,因为CPU线程切换太多,IO密集型比较适合多线程。

问题二:为什么要有GIL锁?

  • 因为cpython自带的垃圾回收机制不是线程安全的,一旦变量的引用计数为0,就会被回收。此时GIL锁就是与万恶的垃圾回收机制相抗衡,不让它这么块就过来抢我们暂时无家可归的小可爱(变量)!!!
  • 不过呢,GIL锁也导致了同一个进程同一时间只能运行一个线程,无法利用到多核优势。

分析:我们有四个任务需要处理,处理方式肯定是要玩出并发的效果

解决方案可以是:

  • 方案一:开启四个进程
  • 方案二:一个进程下,开启四个线程

例子(任务)

io密集型

'''采用多进程计时情况'''

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


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

多进程 5.499674558639526

'''采用多线程计时情况'''

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.004202604293823

小结:你发现了嘛!!!多线程的时间更短,相差0.5秒意味着什么!!!你明白吗???奶茶都可以绕地球两百圈了!!

分析:多线程为什么更快?

  • 因为你看,多进程那么多个人同时去做,意味着卡机的时候都得哭着等。
  • 那线程就不一样了,我们可聪明了,谁要等你,我直接切切切,所以同一段当然更快咯,略略略~

计算密集型

'''采用多进程计时情况'''

def work1():
    res=0
    for i in range(100000000): #1+8个0
        res*=i

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

多进程 18.062480211257935

'''采用多线程计时情况'''

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)  

多线程 33.27059483528137

小结:这次就算周杰伦说好不哭也救不了,15秒可以说是天壤之别了。。。

分析:多进程为什么更快?

  • 因为你看,这次不卡机了,所以多进程那么多个人同时去做一件事,意味着一个时间里只需要完成一件事就好啦!(一个任务时间)
  • 那多线程就不一样了,计算工作量大又耗时,但这是必经之路,这跟卡机不一样,因为那只有一个数据在动,而计算整个过程牵一发而动全身,所以一个时刻一条线程不断地切换,耍小聪明既会丢数据又没用!(多个任务时间)

总结

  • IO密集型
    • 各个线程都会都各种的等待,多线程比较适合
    • 也可以采用多进程+协程
  • 计算密集型
    • 线程在计算时没有等待,这时候去切换,就是无用的切换,python不太适合开发这类功能
    • 推荐使用多进程
原文地址:https://www.cnblogs.com/bjlxxbj/p/11545360.html