1 import time
2 import threading
3 4 nums=[11,22]
5 def test1(temp):
7 print("全域性的nums是%s" % str(temp))
8 9
10 def test2(temp):
11 print("全域性的nums是%s" % str(temp))
12 13
14 def main():
15 16 # args中必須是乙個元組，元組中新增乙個問號就可以
17 t1=threading.thread(target=test1,args=(nums,))
18 t2=threading.thread(target=test2,args=(nums,))
19 t1.start()
20 21 time.sleep(1)
22 t2.start()
23 time.sleep(2)
24 print(nums)
25 26 if __name__ == "__main__":
27 main()
1 import time
2 import threading
3 4 num=0
5 def test1(temp):
6 global num
7 for i in range(temp):
8 num+=1
9 print(num)
10 11
12 def test2(temp):
13 global num
14 for i in range(temp):
15 num+=1
16 print(num)
17 18
19 def main():
20 21 # args中必須是乙個元組，元組中新增乙個問號就可以
22 t1=threading.thread(target=test1,args=(100,))
23 t2=threading.thread(target=test2,args=(100,))
24 t1.start()
25 26 t2.start()
27 time.sleep(2)
28 29 print("全域性%d" % num)
30 31 if __name__ == "__main__":
32 main()
1 import time
2 import threading
3 4 num=0
5 def test1(temp):
6 global num
7 for i in range(temp):
8 num+=1
9 print(num)
10 11
12 def test2(temp):
13 global num
14 for i in range(temp):
15 num+=1
16 print(num)
17 18
19 def main():
20 21 # args中必須是乙個元組，元組中新增乙個問號就可以
22 t1=threading.thread(target=test1,args=(1000001,))
23 t2=threading.thread(target=test2,args=(1000000,))
24 t1.start()
25 26 t2.start()
27 time.sleep(2)
28 29 print("全域性%d" % num)
30 31 if __name__ == "__main__":
main()
# 建立鎖
l=threading.lock()
# 鎖定
l.acquire()
# 解鎖
l.release()
1 import time
2 import threading
3 # 預設是沒有上鎖的
4 lk=threading.lock()
5 num=0
6 def test1(temp):
7 global num
8 lk.acquire()
9 # 如果之前沒有被上鎖，則上鎖成功，
10 # 如果之前已經被被人上鎖了，則阻塞
11 for i in range(temp):
12 num+=1
13 lk.release()
14 print(num)
15 16
17 def test2(temp):
18 global num
19 lk.acquire()
20 # 如果之前沒有被上鎖，則上鎖成功，
21 # 如果之前已經被被人上鎖了，則阻塞
22 for i in range(temp):
23 num+=1
24 lk.release()
25 print(num)
26 27
28 def main():
29 30 # args中必須是乙個元組，元組中新增乙個問號就可以
31 t1=threading.thread(target=test1,args=(1000001,))
32 t2=threading.thread(target=test2,args=(1000000,))
33 t1.start()
34 35 t2.start()
36 time.sleep(2)
37 38 print("全域性%d" % num)
39 40 if __name__ == "__main__":
41 main()
1000001
2000001
全域性2000001
4 lk=threading.lock()
5 num=0
6 def test1(temp):
7 global num
8 # 如果之前沒有被上鎖，則上鎖成功，
9 # 如果之前已經被被人上鎖了，則阻塞
10 for i in range(temp):
11 lk.acquire()
12 num+=1
13 lk.release()
14 print(num)
15 16
17 def test2(temp):
18 global num
19 # 如果之前沒有被上鎖，則上鎖成功，
20 # 如果之前已經被被人上鎖了，則阻塞
21 for i in range(temp):
22 lk.acquire()
23 num+=1
24 lk.release()
25 print(num)
不管哪個執行緒先執行，最終的結果是一樣的
python多執行緒 共享全域性變數
from threading import thread import time g num 100 def work1 global g num for i in range 3 g num 1 print in work1,g num is d g num def work2 global g ...
7 多執行緒 全域性變數 共享全域性變數
多執行緒 全域性變數 共享全域性變數 多執行緒可以對全域性變數進行修改,修改後的結果會影響下乙個執行緒 程序不可以共享全域性變數,子程序是複製父程序的全域性變數,修改後互不影響 from threading import thread import time,random g num 100 def...
多執行緒共享變數 多執行緒共享全域性變數
1.多執行緒的執行順序是無序的 像2個人賽跑，乙個先跑乙個後跑，但根據每個人跑的速度不一樣，跑一半，二者可能跑在一起去了。2.又因為多執行緒是共享乙個全域性變數的，就導致資料容易被弄髒 假如老闆讓兩個員工寫兩個主題ppt，若這兩個人沒商量好，都做了同乙個主題的ppt，導致不但速度很慢，且這個ppt有...