程序線程 六 線程

程序

• CPU時間片：CPU處理的時間長度
• 程序是CPU配置設定資源的最小機關
  • 光有程序沒有辦法高效裡用CPU資源
  • 程序會做IO等待，
• 記憶體獨立：
  • 切換了，彼此多個程序不會影響
  • A,B,C, 資料不會亂
  • 一個程序挂掉，其他程序不會有事情

線程：CPU執行的最小機關

• 輕量級的程序：線程是記憶體共享的
  • CPU寄存器，電腦
  • 切換簡單，CPU在切換執行任務的時候，損耗的時間少
  • 多線程如果處理資料，是并發，那麼避免不了資料混亂，加鎖，同步
• IO等待時可以切換
• 沒有辦法實作真正并發
• Python - CPython - .h Gudio
  • GIL鎖，維持全局的線程同步執行
    • Golbal Lock
  • IO等待時切換
• Cpython中的多線程執行就是同步的：按照順序，一個個來
• 程序：PID Process
• 線程也有：TID Thread
  • 隻在目前的記憶體空間下有用
• 線程如果父程序退出，那麼全部子線程，都會退出
  • 主線程死亡，子線程死亡
  • 主線程一般不要做大事，不要業務處理，
• 資料通信：
  • 本身記憶體共享，list,dict,str,int，這些資料都可以直接共享
• GIL：
  • 大鎖，全局鎖，直接鎖掉線程，
• from threading import Thread
  • Process(target,args,)
  • t = Thread(target,args,name,kwargs)
    • t.start() 真正開啟線程
    • t.join() 回收線程資源
• 隻有純計算沒有IO的時候，多線程等同于單程序
  • 甚至是多線程效率低于單程序
• 多程序：多核心電腦
  • 計算密集
  • 多程序最快–>單程序–>多線程
• 多線程：
  • IO密集
    • QQ聊天

執行個體 單程序耗時

import time
def work_a(a): #GIL鎖
	for var in range(1000000):
		a[0] += 1
	#a = [5]
def work_b(a):
	for var in range(1000000):
		a[0] += 1
		
def work_c(a):
	for var in range(1000000):
		a[0] += 1

a = [1]
start = time.time()
work_a(a)
print('------')
work_b(a)
print('------')
work_c(a)
print('------')
end = time.time()
print('程式耗時:%.2f' % (end - start))
           

執行個體

from multiprocessing import Process
from threading import Thread
import time

def work_a(a):
	for var in range(2500000):
		a[0] += 1
	print('a線程結束')


def work_b(a):
	for var in range(2500000):
		a[0] += 1
	print('b線程結束')

def work_c(a):
	for var in range(2500000):
		a[0] += 1
	print('c線程結束')


def work_d(a):
	for var in range(2500000):
		a[0] += 1
	print('d線程結束')


def main():
	a = [1]
	ta = Thread(target=work_a,args=(a,))
	tb = Thread(target=work_b,args=(a,))
	tc = Thread(target=work_c,args=(a,))
	td = Thread(target=work_d,args=(a,))

	pa = Process(target=work_a,args=(a,))
	pb = Process(target=work_b,args=(a,))
	pc = Process(target=work_c,args=(a,))
	pd = Process(target=work_d,args=(a,))

	start = time.time()
	ta.start()
	tb.start()
	tc.start()
	td.start()
	td.join()
	tc.join()
	tb.join()
	ta.join()
	end = time.time()
	print('多線程程式耗時:%.2fs' % (end - start))

	start = time.time()
	work_a(a)
	work_b(a)
	work_c(a) #0.76
	work_d(a)
	end = time.time()
	print('單程序程式耗時:%.2fs' % (end - start))

	start = time.time()
	pa.start()
	pb.start()
	pc.start()
	pd.start()
	pd.join()
	pc.join()
	pb.join()
	pa.join()
	end = time.time()
	print('多程序程式耗時:%.2fs' % (end - start))

if __name__ == '__main__':
	main()
           

線程的建立–多線程運作耗時

from threading import Thread
import time

#程序處理并發: 時間要少于單程序
#線程處理：等于，大于單程序
#同步: 0 - 8000 
#異步: 0 2000 1

def work_a(a): #GIL鎖
	for var in range(1000000):
		a[0] += 1
	#a = [5]
	print('a線程結束')
def work_b(a):
	for var in range(1000000):
		a[0] += 1
	print('b線程結束')
def work_c(a):
	for var in range(1000000):
		a[0] += 1
	print('c線程結束')

def main():
	
	a = [1]
	start = time.time()

	ta = Thread(target=work_a,args=(a,))
	tb = Thread(target=work_b,args=(a,))
	tc = Thread(target=work_c,args=(a,))
	ta.start()
	tb.start()
	tc.start()

	ta.join()
	tb.join()
	tc.join()

	end = time.time()
	print('程式耗時:%.2f' % (end - start))

	#0.9 1.83
if __name__ == '__main__':
	main()


           

線程記憶體共享

from threading import Thread
import time

#GUI程式設計 QQ
def work(a):
	a[0] = 'a'

def main():
	a = [1]

	t = Thread(target=work,args=(a,))
	t.start()
	t.join()

	print(a) #最後結果

if __name__ == '__main__':
	main()