快捷導(dǎo)航

Python?threading中l(wèi)ock的使用詳解

更新時間：2022年11月22日 11:19:30 作者：鍋爐房劉大爺

Lock類是threading中用于鎖定當(dāng)前線程的鎖定類，本文給大家介紹了Python?threading中l(wèi)ock的使用,需要的朋友可以參考下

在多線程中使用lock可以讓多個線程在共享資源的時候不會“亂”，例如，創(chuàng)建多個線程，每個線程都往空列表l中添加一個數(shù)字并打印當(dāng)前的列表l，如果不加鎖，就可能會這樣：

# encoding=utf8
import threading
import time
lock = threading.Lock()
l = []
 
def test1(n):
	lock.acquire()
	l.append(n)
	print l
	lock.release()
 
def test(n):
	l.append(n)
	print l
 
def main():
	for i in xrange(0, 10):
		th = threading.Thread(target=test, args=(i, ))
		th.start()
if __name__ == '__main__':
	main()

運行結(jié)果：

[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3][
0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4[, 05, , 16, , 27, ]3
, 4, 5, 6[, 07, , 18, ]2
, 3, 4, [50, , 61, , 72, , 83, , 94],
5, 6, 7, 8, 9]

因為每個線程都在同時往l中添加一個數(shù)字（當(dāng)前每個線程運行的是test函數(shù)），然后又可能在同時打印l，所以最后的結(jié)果看起來會有些“混亂”。

下面讓每個線程調(diào)用“test1”函數(shù)，看看結(jié)果如何：

[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

現(xiàn)在看起來就好多了，因為test1中每次像l中添加數(shù)字并打印之前，都先加了一把“鎖”，這樣就可以保證每次只有一個線程可以往l中添加數(shù)字，而不是同時往l里添加數(shù)字。

通過上面的結(jié)果比較可以知道，當(dāng)多線程中需要“獨占資源”的時候，要使用鎖來控制，防止多個線程同時占用資源而出現(xiàn)其他異常。

使用鎖的時候就調(diào)用acquire()方法，以此告訴其他線程，我正在占用該資源，你們要等會；待使用資源后需要釋放資源的時候就調(diào)用release()方法，告訴其他線程，我已經(jīng)完成使用該資源了，其他人可以過來使用了。

python threading Lock

這篇文章主要是通過代碼說明：

threading.Lock()不影響 multiprocessing
.threading.Lock()影響 threading.

代碼如下：

import threading
import time
from multiprocessing import Pool
_lock = threading.Lock()
def small_func(value):
    """
    添加線程鎖
    :param value:
    :return:
    """
    print(value)
    with _lock:
        time.sleep(5)
    return value
def no_small_func(value):
    """
    沒有線程鎖
    :param value:
    :return:
    """
    print(value)
    # with _lock:
    time.sleep(5)
    return value
def main():
    """
    multiprocessing 是基于進(jìn)程的，因此線程鎖對其不影響，
    :return:
    """
    st = time.time()
    p = Pool(processes=4)
    value = p.map(func=small_func, iterable=range(4))
    et = time.time()
    print(f"all use time: {et - st}")
    print(value)
def main2():
    """
    threading 受到 線程鎖 影響
    :return:
    """
    st = time.time()
    thread_list = []
    for temp_value in range(4):
        t = threading.Thread(target=small_func, args=(temp_value,))
        t.start()
        thread_list.append(t)

    for i in thread_list:
        i.join()

    et = time.time()
    print(f"all use time: {et - st}")
    # print(value)
def main3():
    st = time.time()
    thread_list = []
    res = []
    for temp_value in range(4):
        # 不加線程鎖就行了
        t = threading.Thread(target=no_small_func, args=(temp_value,))
        t.start()
        thread_list.append(t)

    for i in thread_list:
        v = i.join()
        res.append(v)

    et = time.time()
    print(f"all use time: {et - st}")
    print(res)
if __name__ == '__main__':
    # main()
    # main2()
    main3()

到此這篇關(guān)于Python threading中l(wèi)ock的使用的文章就介紹到這了,更多相關(guān)Python threading lock使用內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: