多工 執行緒

什麼叫「多工」呢？簡單地說，就是作業系統可以同時執行多個任務。

1. 使用threading模組

import threading

defsing()
:pass
defdance()
:pass
defmain()
:    t1 = threading.thread(target=sing)
t2 = threading.thread(target=dance)
t1.start(
)    t2.start(
)if __name__ ==
"__main__"
:    main(
)

當呼叫 start() 時，才會真正的建立執行緒，並且開始執行

length =

len(threading.
enumerate()
)print
("當前執行執行緒數為：%d "
% length)

import threading

class
test
(threading.thread)
:def
run(self)
:# 這裡必須用run
print
("這裡執行**。。。。。。"
)        self.login(
)        self.use(
)def
login
(self)
:print
("這是登入的**。。。。。"
)def
use(self)
:print
("這是使用的**。。。。。"
)if __name__ ==
'__main__'
:    t = test(
)    t.start(
)# 呼叫start()方法時，會直接執行run()方法

注：若類裡面有多個方法，呼叫start() 時，不會主動執行，需在run() 方法內自身呼叫方法，多執行緒的執行順序是不確定的

import threading

import time
# 定義乙個全域性變數
g_num =
100def
test1()
:global g_num
g_num +=
1print
("-----in test1 g_num=%d-----"
% g_num)
deftest2()
:print
("-----in test2 g_num=%d-----"
% g_num)
defmain()
:    t1 = threading.thread(target=test1)
t2 = threading.thread(target=test2)
t1.start(
)    time.sleep(1)
t2.start(
)    time.sleep(1)
print
("-----in main thread g_num = %d -----"
% g_num)
print
("---建立執行緒前的 g_num = %d "
% g_num)
if __name__ ==
"__main__"
:    main(
)

import threading

import time
# 定義乙個全域性變數
g_num =
0def
test1
(num)
:global g_num
for i in
range
(num)
:        g_num +=
1print
("-----in test1 g_num=%d-----"
% g_num)
deftest2
(num)
:global g_num
for i in
range
(num)
:        g_num +=
1print
("-----in test2 g_num=%d-----"
% g_num)
defmain()
:    t1 = threading.thread(target=test1, args=
(1000000,)
)# 加逗號是因為傳遞的是列表
t2 = threading.thread(target=test2, args=
(1000000,)
)    t1.start(
)    t2.start(
)# 等待上面的兩個執行緒執行完畢
time.sleep(5)
print
("-----in main thread g_num = %d -----"
% g_num)
if __name__ ==
"__main__"
:    main(
)

上程式中 g_num 的值理論應該為 2000000，但實際結果卻是小於2000000，這就是資源競爭帶來的問題

注意：

如果這個鎖之前是沒有上鎖的，那麼acquire不會堵塞，相反的那麼此時acquire會堵塞，直到這個鎖被解鎖為止

import threading

import time
# 定義乙個全域性變數
g_num =
0def
test1
(num)
:global g_num
# 上鎖 如果之前沒有被上鎖 那麼上鎖成功
# 如果之前上鎖成功，那麼此時會在這堵塞，直到這個所被解開
for i in
range
(num)
:        mutex.acquire(
)        g_num +=
1# 解鎖
mutex.release(
)print
("-----in test1 g_num=%d-----"
% g_num)
deftest2
(num)
:global g_num
for i in
range
(num)
:        mutex.acquire(
)        g_num +=
1        mutex.release(
)print
("-----in test2 g_num=%d-----"
% g_num)
# 建立乙個互斥鎖 預設沒有上鎖
mutex = threading.lock(
)def
main()
:    t1 = threading.thread(target=test1, args=
(1000000,)
)    t2 = threading.thread(target=test2, args=
(1000000,)
)    t1.start(
)    t2.start(
)# 等待上面的兩個執行緒執行完畢
time.sleep(3)
print
("-----in main thread g_num = %d -----"
% g_num)
if __name__ ==
"__main__"
:    main(
)

當乙個執行緒呼叫鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。

每次只有乙個執行緒可以獲得鎖。如果此時另乙個執行緒試圖獲得這個鎖，該執行緒就會變為「blocked」狀態，稱為「阻塞」，直到擁有鎖的執行緒呼叫鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。

執行緒排程程式從處於同步阻塞狀態的執行緒中選擇乙個來獲得鎖，並使得該執行緒進入執行（running）狀態。

多工 執行緒

建立函式 建立執行緒物件，並制定函式 開啟執行緒 import threading import time defwork1 1.定義函式 for i in range 5 print 正在掃地 i time.sleep 1 defmain 測試執行緒的基本使用 2.建立執行緒物件 t1 threa...

多工 執行緒

簡單地說，就是作業系統可以同時執行多個任務。實現多工有多種方式，執行緒 程序 協程。可以簡單理解為同一程序中有多個計數器，每個執行緒的執行時間不確定，而每個程序的時間片相等，執行緒是作業系統排程執行的最小單位.import threadingt1 threading.thread target fu...

多工 執行緒

coding utf 8 from time import sleep defsing for i in range 3 print 正在唱歌.d i sleep 1 defdance for i in range 3 print 正在跳舞.d i sleep 1 if name main sing...