Python線程編程中的Thread該如何理解，針對這個問題，這篇文章詳細介紹了相對應的分析和解答，希望可以幫助更多想解決這個問題的小伙伴找到更簡單易行的方法。
線程被稱為輕量級的進程
線程也可以使用計算機多核資源,是多任務編程方式
線程是系統分配內核的最小單元
線程可以理解為進程的分支任務
一個進程中可以包含多個線程
線程也是一個運行行為,消耗計算機資源
一個線程中的所有線程共享這個進程的資源
多個線程之間的運行互不影響各自運行
線程的創建和銷毀消耗資源遠小于進程
各個線程也有自己的ID等特征
from threading import Thread t = Thread() 功能: 創建線程對象 參數: target 綁定線程函數 args 元組 給線程函數位置傳參 kwargs 字典 給線程函數鍵值傳參
t.start()
t.join([timeout])
"""
thread1.py 線程基礎使用
步驟:
1. 封裝線程函數
2.創建線程對象
3.啟動線程
4.回收線程
"""
import os
from threading import Thread
from time import sleep
a = 1
# 線程函數
def music():
for i in range(3):
sleep(2)
print('播放:黃河大合唱 %s' % os.getpid())
global a
print("a,",a)
a = 1000
# 創建線程對象
t = Thread(target=music)
# 啟動線程
t.start()
for i in range(3):
sleep(1)
print('播放:beauty love %s' % os.getpid())
# 回收線程
t.join()
print('程序結束')
print("a,", a)1.t.name 線程名稱
2.t.setName() 設置線程名稱
3.t.getName()獲取線程名稱
4.t.is_alive() 查看線程是否在生命周期
5.t.daemon 設置主線程和分支線程退出分支線程也退出.要在start前設置 通常不和join 一起使用
6.代碼演示
"""
thread3.py
線程屬性演示
"""
from threading import Thread
from time import sleep
def fun():
sleep(3)
print('線程屬性測試')
t = Thread(target=fun, name='ceshi')
# 主線程退出分支線程也退出 必須在start前使用 與join 沒有意義
t.setDaemon(True)
t.start()
print(t.getName())
t.setName('Tedu')
print('is alive:', t.is_alive())
print('daemon', t.daemon)1.創建步驟
1.繼承Thread類
2.重寫 __init__方法添加自己的屬性 使用super加載父類屬性
3.重寫run方法
2.使用方法
1.實例化對象
2.調傭start自動執行run方法
3.調傭join回收線程
代碼演示
"""
自定義線程類例子
"""
from threading import Thread
# 自定義線程類
class ThreadClass(Thread):
# 重寫父類 init
def __init__(self, *args, **kwargs):
self.attr = args[0]
# 加載父類init
super().__init__()
# 假設需要很多步驟完成功能
def f1(self):
print('1')
def f2(self):
print(2)
# 重寫run 邏輯調傭
def run(self):
self.f1()
self.f2()
t = ThreadClass()
t.start()
t.join()from threading import Thread
from time import sleep, ctime
class MyThread(Thread):
def __init__(self, group=None, target=None, name=None,
args=(), kwargs=None, *, daemon=None):
super().__init__()
self.fun = target
self.args = args
self.kwargs = kwargs
def run(self):
self.fun(*self.args, **self.kwargs)
def player(sec, song):
for i in range(3):
print("Playing %s : %s" % (song, ctime()))
sleep(sec)
t = MyThread(target=player, args=(3,), kwargs={'song': '量量'})
t.start()
t.join()1.通信方法
1.線程間使用全局遍歷進行通信
2.共享資源爭奪
1.共享資源:多個進程或者線程都可以操作的資源稱為共享資源,對共享資源的操作代碼段稱為臨界區
2.影響:對公共資源的無序操作可能會帶來數據的混亂,或者操作錯誤.此時往往需要同步互斥機制協調操作順序
3.同步互斥機制
1.同步:同步是一種協作關系,為完成操作,多進程或者線程形成一種協調,按照必要的步驟有序執行操作
2.互斥:互斥是一種制約關系,當一個進程或者線程占有資源時,會進行加鎖處理,此時其它進程線程就無法操作該資源,直到解鎖后才能操作
## 9.線程同步互斥方法
from threading import Event # 創建線程event對象 e = Event() # 阻塞等待e被set e.wait([timeout]) # 設置e, 使wait結束阻塞 e.set() # 使e回到未被設置狀態 e.clear() # 查看當前e是否被設置 e.is_set()
"""
event 線程互斥方法演示
"""
from threading import Event, Thread
s = None # 用于通信
e = Event()
def yzr():
print('楊子榮前來拜山頭')
global s
s = '天王蓋地虎'
e.set() #操作完共享資源 e設置
t = Thread(target=yzr)
t.start()
print('說對口令就是自己人')
e.wait() #阻塞等待 e.set()
if s == '天王蓋地虎':
print('寶塔鎮河妖')
print('確認過眼神,你是對的人')
e.clear()
else:
print('打死他...')
t.join()
print('程序結束')from threading import Lock lock = Lock()創建鎖對象 lock.acquire() 上鎖 如果lock已經上鎖再調用會阻塞 lock.release() 解鎖 with lock: 上鎖 .... .... with 代碼塊解鎖自動解鎖
"""
thread_lock
線程鎖演示
"""
from threading import Thread, Lock
a = b = 0
lock = Lock()
def value():
while True:
# 上鎖
lock.acquire()
print('a=%d,b=%d' % (a, b)) if a != b else print('a不等于b')
# 解鎖
lock.release()
t = Thread(target=value)
t.start()
while True:
# with 開始上鎖
with lock:
a += 1
b += 1
# with 解鎖 自動解鎖
t.join()
print('程序結束')死鎖是指兩個或者兩個以上的線程在執行過程中,由于競爭資源或者由于彼此通信而造成的一種阻塞的現象,若無外力作用,他們都將無法推進下去.此時稱系統處于死鎖狀態或系統產生了死鎖.
死鎖發生的必要條件
互斥條件：指線程對所分配到的資源進行排它性使用，即在一段時間內某資源只由一個進程占用。如果此時還有其它進程請求資源，則請求者只能等待，直至占有資源的進程用畢釋放。
請求和保持條件：指線程已經保持至少一個資源，但又提出了新的資源請求，而該資源已被其它進程占有，此時請求線程阻塞，但又對自己已獲得的其它資源保持不放。
不剝奪條件：指線程已獲得的資源，在未使用完之前，不能被剝奪，只能在使用完時由自己釋放,通常CPU內存資源是可以被系統強行調配剝奪的。
環路等待條件：指在發生死鎖時，必然存在一個線程——資源的環形鏈，即進程集合{T0，T1，T2，···，Tn}中的T0正在等待一個T1占用的資源；T1正在等待T2占用的資源，……，Tn正在等待已被T0占用的資源。
死鎖的產生原因
簡單來說造成死鎖的原因可以概括成三句話：
當前線程擁有其他線程需要的資源
當前線程等待其他線程已擁有的資源
都不放棄自己擁有的資源
如何避免死鎖
死鎖是我們非常不愿意看到的一種現象，我們要盡可能避免死鎖的情況發生。通過設置某些限制條件，去破壞產生死鎖的四個必要條件中的一個或者幾個，來預防發生死鎖。預防死鎖是一種較易實現的方法。但是由于所施加的限制條件往往太嚴格，可能會導致系統資源利用率。
from time import sleep
from threading import Thread, Lock
# 交易類
class Account:
def __init__(self, _id, balance, lock):
# 用戶
self._id = _id
# 存款
self.balance = balance
# 鎖
self.lock = lock
# 取錢
def withdraw(self, amount):
self.balance -= amount
# 存錢
def deposit(self, amount):
self.balance += amount
# 余額
def get_balance(self):
return self.balance
Tom = Account('Tom', 5000, Lock())
Alex = Account('Alex', 8000, Lock())
def transfer(from_, to, amount):
# 鎖住自己賬戶
if from_.lock.acquire():
# 賬戶減少
from_.withdraw(amount)
sleep(0.5)
if to.lock.acquire():
to.deposit(amount)
to.lock.release()
from_.lock.release()
print('轉賬完成 %s給%s轉賬%d' % (from_._id, to._id, amount))
# transfer(Tom, Alex, 1000)
t1 = Thread(target=transfer, args=(Tom, Alex, 2000))
t2 = Thread(target=transfer, args=(Alex, Tom, 3500))
t1.start()
t2.start()
t1.join()
t2.join()
print('程序結束')什么是GIL ：由于python解釋器設計中加入了解釋器鎖，導致python解釋器同一時刻只能解釋執行一個線程，大大降低了線程的執行效率。
導致后果： 因為遇到阻塞時線程會主動讓出解釋器，去解釋其他線程。所以python多線程在執行多阻塞高延遲IO時可以提升程序效率，其他情況并不能對效率有所提升。
GIL問題建議
盡量使用進程完成無阻塞的并發行為
不使用c作為解釋器 （Java C#）
在無阻塞狀態下，多線程程序和單線程程序執行效率幾乎差不多，甚至還不如單線程效率。但是多進程運行相同內容卻可以有明顯的效率提升。
關于Python線程編程中的Thread該如何理解問題的解答就分享到這里了，希望以上內容可以對大家有一定的幫助，如果你還有很多疑惑沒有解開，可以關注億速云行業資訊頻道了解更多相關知識。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
