一、數(shù)據(jù)共享

　　from multiprocessing import Manager

　　把所有實現(xiàn)了數(shù)據(jù)共享的比較便捷的類都重新又封裝了一遍，并且在原有的multiprocessing基礎上增加了新的機制list、dict

　　機制：支持的數(shù)據(jù)類型非常有限

　　　　list、dict都不是數(shù)據(jù)安全的，需要自己加鎖來保證數(shù)據(jù)安全

from multiprocessing import Manager,Process,Lockdef work(d,lock):with lock:d['count'] -= 1if __name__ == '__main__':lock = Lock()with Manager() as m: # m = Manager()dic = m.dict({'count':100})p_lst = []for i in range(10):p = Process(target=work, args=(dic, lock))p_lst.append(p)p.start()for p in p_lst:p.join()print(dic) #{'count': 90} with ......一大段語句 dis模塊 python的上下文管理 在執(zhí)行一大段語句之前，自動做某個操作 open 在執(zhí)行一大段語句之后，自動做某個操作 close面向?qū)ο蟮哪g方法（雙下杠杠方法） # 回調(diào)函數(shù) in Poolimport os from multiprocessing import Pooldef func(i):print('第一個任務', os.getpid())return '*'*idef call_back(res): #回調(diào)函數(shù)print('回調(diào)函數(shù)：', os.getpid())print('res--->', res)if __name__ == '__main__':p = Pool()print('主進程', os.getpid())p.apply_async(func, args=(1,), callback=call_back)p.close()p.join()

　　func執(zhí)行完畢之后執(zhí)行callback函數(shù)

　　func的返回值會作為callback的參數(shù)

　　回調(diào)函數(shù)是在主進程中實現(xiàn)的

　　應用場景：子進程有大量運算要做，回調(diào)函數(shù)等待結(jié)果做簡單處理

import re from urllib.request import urlopen from multiprocessing import Poolurl_lst = ['http://www.baidu.com','http://www.sohu.com','http://www.sogou.com','http://www.4399.com','http://www.cnblogs.com', ]def get_url(url):response = urlopen(url)ret = re.search('www\.(.*?)\.com', url)print('%s finished' % ret.group(1))return ret.group(1),response.read()def call(content):url,con = contentwith open(url+'.html', 'wb')as f:f.write(con) if __name__ == '__main__':p = Pool()for url in url_lst:p.apply_async(get_url,args=(url,),callback=call)p.close()p.join() 子進程去訪問網(wǎng)頁，主進程處理網(wǎng)頁的結(jié)果

?

二、線程理論基礎

　　進程是計算機中最小的資源分配單位，進程對于操作系統(tǒng)來說還具有一定的負擔

　　創(chuàng)建一個進程，操作系統(tǒng)分配的資源大約有：代碼，數(shù)據(jù)，文件等

1、為什么要有線程

　　線程是輕量級的概念，他沒有屬于自己的進程資源，一條線程只負責執(zhí)行代碼，沒有自己獨立的代碼、數(shù)據(jù)以及文件

　　線程是計算機中能被CPU調(diào)用的最小的單位，當前大部分計算機中的CPU都是執(zhí)行的線程中的代碼

　　線程與進程之間的關系：每一個進程中都至少有一條線程在工作

線程的特點：

　　同一個進程中的所有線程的資源是共享的

　　輕量級， 沒有自己的資源

進程與線程之間的區(qū)別：　　　　

　　占用的資源、調(diào)度的效率、資源是否共享

線程的并行問題：

　　線程可以并行：java、c++，c#等

　　在cpython中，一個進程中的多個線程是不可以并行的

　　原因是：Cpython解釋器內(nèi)部有一把全局解釋器鎖GIL，所以線程不能充分利用多核，同一時刻同一進程中的線程只有一個能被cpu執(zhí)行

　　GIL鎖確實是限制了你程序的效率，但目前可以幫助你提高線程之間切換的效率

　　如果是想寫高計算型的就要多進程或者換一個解釋器

2、threading 模塊

# 并發(fā)import os from threading import Threaddef func(i):print('子線程：', i, os.getpid())print('主線程', os.getpid()) for i in range(10):t = Thread(target=func, args=(i,))t.start() # 進程和線程的差距import os import time from threading import Thread from multiprocessing import Processdef func(i):print('子：', os.getpid())if __name__ == '__main__':start = time.time()t_lst = []for i in range(100):t = Thread(target=func, args=(i,))t.start()t_lst.append(t)for t in t_lst:t.join()end = time.time()-startstart = time.time()t_lst = []for i in range(100):p = Process(target=func, args=(i,))p.start()t_lst.append(p)for p in t_lst:p.join()end2 = time.time()-startprint(end, end2) #0.0279843807220459 13.582834720611572 # 線程間的數(shù)據(jù)共享from threading import Threadnum = 100 def func():global numnum -= 1 #每個線程都-1 t_lst = [] for i in range(100):t = Thread(target=func) #創(chuàng)建一百個線程 t.start()t_lst.append(t) for t in t_lst:t.join() print(num) #0?

Thread 類的其他用法

Thread實例對象的方法# isAlive(): 返回線程是否活動的。# getName(): 返回線程名。# setName(): 設置線程名。 threading模塊提供的一些方法：# threading.currentThread(): 返回當前的線程變量。# threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啟動后、結(jié)束前，不包括啟動前和終止后的線程。# threading.activeCount(): 返回正在運行的線程數(shù)量，與len(threading.enumerate())有相同的結(jié)果。 from threading import currentThread,Thread def func():time.sleep(2)t = Thread(target=func) t.start() print(t.is_alive()) #True（判斷線程是否活著） print(t.getName()) #Tread-1 t.setName('tt') print(t.getName()) #tt（改名字）def func():print('子線程：', currentThread().ident)time.sleep(2) print('主線程：',currentThread().ident) t = Thread(target=func) t.start() #currentThread().ident返回線程的pidfrom threading import enumerate def func():print('子進程：', currentThread().ident)time.sleep(2)print('主進程：', currentThread().ident) for i in range(10):t = Thread(target=func)t.start() print(len(enumerate())) #enumerate()返回一個包含正在運行的線程的list，len(list)from threading import activeCount def func():print('子線程：', currentThread().ident)time.sleep(2)print('主線程：', currentThread().ident) for i in range(10):t = Thread(target=func)t.start() print(activeCount()) #activeCount()返回正在運行的線程數(shù)量，與len(threading.enumerate())有相同的結(jié)果 示例

3、守護線程

import time from threading import Threaddef func():while True:time.sleep(1)print(123)def func2():print('func2 start')time.sleep(3)print('func2 end')t1 = Thread(target=func) t2 = Thread(target=func2) t1.setDaemon(True) t1.start() t2.start() print('主線程代碼結(jié)束') # func2 start #主線程代碼結(jié)束 #123 #123 #func2 end

?

　　守護線程 是在主線程代碼結(jié)束之后，再等待子線程執(zhí)行結(jié)束后才結(jié)束

　　主線程結(jié)束? 就意味著主進程結(jié)束

　　主線程等待所有的線程結(jié)束

　　主線程結(jié)束了以后? 守護線程會隨著主進程的結(jié)束而隨之結(jié)束? 不是隨著代碼的結(jié)束而結(jié)束

??

#################################################################################

線程
線程和進程之間的關系
每個進程內(nèi)都有一個線程
線程是不能獨立存在的
線程和進程之間的區(qū)別
同一個進程中線程之間的數(shù)據(jù)是共享的
進程之間的數(shù)據(jù)是隔離的
線程是被cpu執(zhí)行的最小單位
操作系統(tǒng)調(diào)度
進程是計算機中最小的資源分配單位
python
GIL鎖 全局解釋器鎖 全局鎖
cpython解釋器中的
鎖線程 ：同一時刻同一個進程只會有一個線程訪問CPU
鎖的是線程而不是數(shù)據(jù)
當程序是高IO型的 多線程
當程序是高計算(CPU)型的 多進程
cpu*1 ~ cpu*2

threading
Thread
守護線程 ：主線程結(jié)束之后才結(jié)束

socket_server IO多路復用 + 多線程
框架 并發(fā)的效果 ：多線程、協(xié)程的概念 flask
爬蟲 ：線程池 協(xié)程

set、dict、list
生成器
面向?qū)ο蟮倪M階 ：魔術方法
管道
socket_server的源碼

轉(zhuǎn)載于:https://www.cnblogs.com/yzh2857/p/9699875.html

總結(jié)

以上是生活随笔為你收集整理的《Python》进程收尾线程初识的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。