本篇文章為大家帶來了關於Python的相關知識，其中主要介紹了關於多線程的相關內容，多個線程可以在同一個程式中運行，並且每個線程完成不同的任務，下面一起來看一下，希望對大家有幫助。
【相關推薦：Python3影片教學 】
執行緒是CPU分配資源的基本單位。當一程式開始運行，這個程式就變成了一個行程，而一個行程相當於一個或多個執行緒。當沒有多執行緒程式設計時，一個行程相當於一個主執行緒；當有多執行緒程式設計時，一個行程包含多個執行緒（含主執行緒）。使用執行緒可以實現程式大的開發。
多個執行緒可以在同一個程式中運行，並且每個執行緒完成不同的任務。
多執行緒實作後台服務程式可以同時處理多個任務，並且不會發生阻塞現象。
多執行緒的程式設計的特點是能夠提高程式執行效率和處理速度。 python程式可以同時並行運行多個相對獨立的執行緒。
python支援兩種建立多執行緒的方式：
~透過 threading.Thread () 建立。
~透過繼承 threading.Thread 類別的繼承。
#語法形式：
thread.Thread(group=Nore,targt=None,args=(),kwargs={},*,daemon=None)參數解釋：
~group：必須為None，於ThreadGroup類別相關，一般不使用。
~target：執行緒呼叫的對象，就是目標函數。
~name：為線程取這個名字。預設是Tread-x，x是序號，由1開始，第一個創建的線程名字就是Tread-1。
~args：為目標函數傳遞關鍵字參數，字典。
~daemon：用來設定執行緒是否隨主執行緒退出而退出。
範例：
import threading def test (x,y): for i in range(x,y): print(i) thread1 = threading.Thread(name='t1',target= test,args=(1,10)) thread2 = threading.Thread(name='t2',target= test,args=(11,20)) thread1.start() #启动线程1 thread2.start() #启动线程2
輸出：
1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19
解釋：兩個程式會並發運行，所以結果不一定每次都是順序的1~10，這是根據CPU給兩個線程風馬分配的時間片段來決定。可以看到每次結果都不同。
threading.Thread是一個類，可以繼承它。
範例：
import threading class mythread(threading.Thread): def run(self): for i in range(1,10): print(i) thread1 = mythread(); thread2 = mythread(); thread1.start() thread2.start()
輸出：
1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9
解釋：自訂一個類別繼承threading.Thread,然後重寫父類別的run方法，執行緒啟動時（執行start （））會自動執行該方法。
在python中，主執行緒是第一個啟動的執行緒。
~父執行緒:如果啟動執行緒A中啟動了一個執行緒B，A就是B的父執行緒。
~子執行緒：B就是A的子執行緒。
建立執行緒時有一個damon屬性，用它來判斷主執行緒。當daemon設定False時，執行緒不會隨主執行緒退出而退出，主執行緒會一直等著子執行緒執行完;。當daemon設定True時，執行緒會隨主執行緒退出而退出，主執行緒結束其他的子執行緒會強制退出。
使用daemon注意：
~daemon屬性必須在start( )之前設置，否則會引發RuntimeError異常
~每個線程都由daemon屬性，可以顯示設置也可以不設置，不設置則取預設值None
~如果子子執行緒不設定daemon屬性，就取目前執行緒的daemon來設定它。子子執行緒繼承子執行緒的daemon值，作用和設定None一樣。
~從主執行緒建立的所有執行緒不設定daemon屬性，則預設都是daemon=False。
範例：
import time
import threading
def test():
time.sleep(10)
for i in range(10):
print(i)
thread1 = threading.Thread(target=test,daemon=False)
thread1.start()
print('主线程完成了')輸出：
主线程完成了 0 1 2 3 4 5 6 7 8 9
解釋：當主執行緒執行完畢輸出完後，等待一下後輸出0~9。如果將daemon=False該為daemon=True，則不會執行for i in range(10)語句。
一個執行緒中呼叫另一個執行緒的join方法，呼叫者被阻塞，直到呼叫執行緒被終止。
語法形式：
join(timeout-=None)
timeout 參數指定呼叫者等待多久，沒有設定時，就一直等待被呼叫執行緒結束被呼叫執行緒結束。其中，一個執行緒可以被join多次呼叫。
範例：
import time
import threading
def test():
time.sleep(5)
for i in range(10):
print(i)
thread1=threading.Thread(target=test)
thread1.start()
thread1.join()
print('主线程完成了')輸出：
0 1 2 3 4 5 6 7 8 9 主线程完成了
解釋：在thread1.start()後面加上thread1.join()加入join方法，輸出時，主執行緒就會等待輸出完0~9後再執行自己的print輸出。
~run（）：用以表示執行緒活動的方法
~start（）：啟動執行緒
~join（）：等待至執行緒終止
~isAlive（）：傳回執行緒是否活動的
~getName（）：傳回執行緒名稱
~setName() : 設定執行緒名稱
範例：
from threading import Thread, Event
import time
def countdown(n, started_evt):
print('正在运行')
started_evt.set()
while n > 0:
print('时间', n)
n -= 1
time.sleep(2)
started_evt = Event()
print('开始倒计时')
t = Thread(target=countdown, args=(10, started_evt))
t.start()
started_evt.wait()
print('倒计时运行')輸出：
开始倒计时 正在运行 时间 10 倒计时运行 时间 9 时间 8 时间 7 时间 6 时间 5 时间 4 时间 3 时间 2 时间 1
Alive，顾名思义，它表示线程当前是否为可用状态，如果线程已经启动，并且当前没有任何异常的话，则返回true，否则为false
Thread.isAlive() ：顾名思义，是表示当前线程时候为可用状态，即是否已经在启动，并且在运行的状态；
异步模式的情况下，同时有一个线程在修改共享数据，另一个线程在读取共享数据，当修改的共享数据的线程没有处理完毕，读取数据的线程肯定会得到错误的结果。如果采用多线程的同步控制机制，当处理共享数据的线程完成处理数据之后，读取线程就读取数据。
python的锁就解决这一问题，锁住线程，只允许一个线程操作，其他线程排队等待，待当前线程操作完毕后，再按顺序一个一个来运行。
python的threading模块提供了RLock锁解决方法。在某一时间只能让一个线程操作的语句放到RLock的acquire方法和release方法之间，即acquire相当于给RLack上锁，而release相当于解锁。
示例：
import threading
class mythread(threading.Thread):
def run(self):
global x #声明一个全局变量
lock.acquire() #上锁
x +=10
print('%s:%d'%(self.name,x))
lock.release() #解锁
x = 0 #设置全局变量初始值
lock = threading.RLock() #创建可重入锁
list1 = []
for i in range(5):
list1.append(mythread()) #创建五个线程，放到同一列表中
for i in list1:
i.start() #开启列表线程输出：
Thread-1:10 Thread-2:20 Thread-3:30 Thread-4:40 Thread-5:50
解释：
条件锁常用的方法：
~acquire([timeout]):调用关联锁的方法
~release()：解锁
~wait():使线程进入 Condition 的等待池等待通知并释放解锁。使用前线程必须已获得锁定，否则将抛出异常。
~notify():从等待池挑选一个线程并通知，收到通知的线程将自动调用 acquire() 尝试获得，其他线程仍然在等待池中等待通知，直到该线程收到通知 调用该方法，否则将会抛出异常。
~notify ALL():跟notify() 一样，但这个方法对应的是所有的线程。
示例：
题目：有几个生产车间生产，几个消费者购买，当生产达到一定数量时，停止生产。
import threading
import time
condtion = threading.Condition()
sheep = ['1件产品','1件产品','1件产品','1件产品','1件产品']
class Producer(threading.Thread):
def __init__(self, name):
super().__init__(name=name)
pass
def run(self):
global condtion, sheep
while True:
time.sleep(0.1)
condtion.acquire()
if len(sheep) < 10:
print(self.name + "生产了1件产品")
sheep.append('1件产品')
condtion.notifyAll()
pass
else:
print("仓库满了，停止生产!")
condtion.wait()
pass
condtion.release()
pass
pass
class Customer(threading.Thread):
def __init__(self, name):
super().__init__(name=name)
pass
def run(self):
global condtion, sheep
while True:
time.sleep(0.1)
condtion.acquire()
if len(sheep) > 0:
meat = sheep.pop()
print(self.name + "购买了" + meat + "还剩多少" + str(len(sheep)) + "件")
condtion.notifyAll()
pass
else:
print("买光了，等待")
condtion.wait()
pass
condtion.release()
pass
pass
if __name__ == "__main__":
p1 = Producer("1号生产车间")
p2 = Producer("2号生产车间")
p3 = Producer("3号生产车间")
p4 = Producer("4号生产车间")
p5 = Producer("5号生产车间")
p6 = Producer("6号生产车间")
p1.start()
p2.start()
p4.start()
p5.start()
p6.start()
c1 = Customer('小王')
c2 = Customer('小李')
c3 = Customer('小贾')
c4 = Customer('小沈')
c5 = Customer('小刘')
c1.start()
c2.start()
c3.start()
c4.start()
c5.start()【相关推荐：Python3视频教程 】
以上是python的多線程（整理總結）的詳細內容。更多資訊請關注PHP中文網其他相關文章！
