一 threading模塊介紹
multiprocess模塊的完全模仿了threading模塊的接口，二者在使用層面，有很大的相似性，因而不再詳細介紹
官網鏈接：https://docs.python.org/3/library/threading.html?highlight=threading#
二 開啟線程的兩種方式
#方式一
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' %name)
if __name__ == '__main__':
t=Thread(target=sayhi,args=('egon',))
t.start()
print('主線程')
#方式二
from threading import Thread
import time
class Sayhi(Thread):
def __init__(self,name):
super().__init__()
self.name=name
def run(self):
time.sleep(2)
print('%s say hello' % self.name)
if __name__ == '__main__':
t = Sayhi('egon')
t.start()
print('主線程')
三 在一個進程下開啟多個線程與在一個進程下開啟多個子進程的區別
from threading import Thread
from multiprocessing import Process
import os
def work():
print('hello')
if __name__ == '__main__':
#在主進程下開啟線程
t=Thread(target=work)
t.start()
print('主線程/主進程')
'''
打印結果:
hello
主線程/主進程
'''
#在主進程下開啟子進程
t=Process(target=work)
t.start()
print('主線程/主進程')
'''
打印結果:
主線程/主進程
hello
'''
from threading import Thread
from multiprocessing import Process
import os
def work():
print('hello',os.getpid())
if __name__ == '__main__':
#part1:在主進程下開啟多個線程,每個線程都跟主進程的pid一樣
t1=Thread(target=work)
t2=Thread(target=work)
t1.start()
t2.start()
print('主線程/主進程pid',os.getpid())
#part2:開多個進程,每個進程都有不同的pid
p1=Process(target=work)
p2=Process(target=work)
p1.start()
p2.start()
print('主線程/主進程pid',os.getpid())
from threading import Thread
from multiprocessing import Process
import os
def work():
global n
n=0
if __name__ == '__main__':
# n=100
# p=Process(target=work)
# p.start()
# p.join()
# print('主',n) #毫無疑問子進程p已經將自己的全局的n改成了0,但改的僅僅是它自己的,查看父進程的n仍然為100
n=1
t=Thread(target=work)
t.start()
t.join()
print('主',n) #查看結果為0,因為同一進程內的線程之間共享進程內的數據
四 練習
練習一：
#_*_coding:utf-8_*_
#!/usr/bin/env python
import multiprocessing
import threading
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('127.0.0.1',8080))
s.listen(5)
def action(conn):
while True:
data=conn.recv(1024)
print(data)
conn.send(data.upper())
if __name__ == '__main__':
while True:
conn,addr=s.accept()
p=threading.Thread(target=action,args=(conn,))
p.start()
#_*_coding:utf-8_*_
#!/usr/bin/env python
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',8080))
while True:
msg=input('>>: ').strip()
if not msg:continue
s.send(msg.encode('utf-8'))
data=s.recv(1024)
print(data)
練習二：三個任務，一個接收用戶輸入，一個將用戶輸入的內容格式化成大寫，一個將格式化后的結果存入文件
from threading import Thread
msg_l=[]
format_l=[]
def talk():
while True:
msg=input('>>: ').strip()
if not msg:continue
msg_l.append(msg)
def format_msg():
while True:
if msg_l:
res=msg_l.pop()
format_l.append(res.upper())
def save():
while True:
if format_l:
with open('db.txt','a',encoding='utf-8') as f:
res=format_l.pop()
f.write('%s\n' %res)
if __name__ == '__main__':
t1=Thread(target=talk)
t2=Thread(target=format_msg)
t3=Thread(target=save)
t1.start()
t2.start()
t3.start()
五 線程相關的其他方法
Thread實例對象的方法 # isAlive(): 返回線程是否活動的。 # getName(): 返回線程名。 # setName(): 設置線程名。 threading模塊提供的一些方法： # threading.currentThread(): 返回當前的線程變量。 # threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啟動后、結束前，不包括啟動前和終止后的線程。 # threading.activeCount(): 返回正在運行的線程數量，與len(threading.enumerate())有相同的結果。
from threading import Thread
import threading
from multiprocessing import Process
import os
def work():
import time
time.sleep(3)
print(threading.current_thread().getName())
if __name__ == '__main__':
#在主進程下開啟線程
t=Thread(target=work)
t.start()
print(threading.current_thread().getName())
print(threading.current_thread()) #主線程
print(threading.enumerate()) #連同主線程在內有兩個運行的線程
print(threading.active_count())
print('主線程/主進程')
'''
打印結果:
MainThread
<_MainThread(MainThread, started 140735268892672)>
[<_MainThread(MainThread, started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>]
主線程/主進程
Thread-1
'''
主線程等待子線程結束
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' %name)
if __name__ == '__main__':
t=Thread(target=sayhi,args=('egon',))
t.start()
t.join()
print('主線程')
print(t.is_alive())
'''
egon say hello
主線程
False
'''
六 守護線程
無論是進程還是線程，都遵循：守護xxx會等待主xxx運行完畢后被銷毀
需要強調的是：運行完畢並非終止運行
#1.對主進程來說，運行完畢指的是主進程代碼運行完畢 #2.對主線程來說，運行完畢指的是主線程所在的進程內所有非守護線程統統運行完畢，主線程才算運行完畢
詳細解釋：
#1 主進程在其代碼結束后就已經算運行完畢了（守護進程在此時就被回收）,然后主進程會一直等非守護的子進程都運行完畢后回收子進程的資源(否則會產生僵屍進程)，才會結束， #2 主線程在其他非守護線程運行完畢后才算運行完畢（守護線程在此時就被回收）。因為主線程的結束意味着進程的結束，進程整體的資源都將被回收，而進程必須保證非守護線程都運行完畢后才能結束。
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' %name)
if __name__ == '__main__':
t=Thread(target=sayhi,args=('egon',))
t.setDaemon(True) #必須在t.start()之前設置
t.start()
print('主線程')
print(t.is_alive())
'''
主線程
True
'''
from threading import Thread
import time
def foo():
print(123)
time.sleep(1)
print("end123")
def bar():
print(456)
time.sleep(3)
print("end456")
t1=Thread(target=foo)
t2=Thread(target=bar)
t1.daemon=True
t1.start()
t2.start()
print("main-------")
七 全局解釋器鎖GIL介紹
''' 定義： In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.) ''' 結論：在Cpython解釋器中，同一個進程下開啟的多線程，同一時刻只能有一個線程執行，無法利用多核優勢
首先需要明確的一點是GIL並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標准，但是可以用不同的編譯器來編譯成可執行代碼。有名的編譯器例如GCC，INTEL C++，Visual C++等。Python也一樣，同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行。像其中的JPython就沒有GIL。然而因為CPython是大部分環境下默認的Python執行環境。所以在很多人的概念里CPython就是Python，也就想當然的把GIL歸結為Python語言的缺陷。所以這里要先明確一點：GIL並不是Python的特性，Python完全可以不依賴於GIL
這篇文章透徹的剖析了GIL對python多線程的影響，強烈推薦看一下：http://www.dabeaz.com/python/UnderstandingGIL.pdf
7.1 GIL介紹
GIL本質就是一把互斥鎖，既然是互斥鎖，所有互斥鎖的本質都一樣，都是將並發運行變成串行，以此來控制同一時間內共享數據只能被一個任務所修改，進而保證數據安全。
可以肯定的一點是：保護不同的數據的安全，就應該加不同的鎖。
要想了解GIL，首先確定一點：每次執行python程序，都會產生一個獨立的進程。例如python test.py，python aaa.py，python bbb.py會產生3個不同的python進程
''' #驗證python test.py只會產生一個進程 #test.py內容 import os,time print(os.getpid()) time.sleep(1000) ''' python3 test.py #在windows下 tasklist |findstr python #在linux下 ps aux |grep python
在一個python的進程內，不僅有test.py的主線程或者由該主線程開啟的其他線程，還有解釋器開啟的垃圾回收等解釋器級別的線程，總之，所有線程都運行在這一個進程內，毫無疑問
#1 所有數據都是共享的，這其中，代碼作為一種數據也是被所有線程共享的（test.py的所有代碼以及Cpython解釋器的所有代碼） 例如：test.py定義一個函數work（代碼內容如下圖），在進程內所有線程都能訪問到work的代碼，於是我們可以開啟三個線程然后target都指向該代碼，能訪問到意味着就是可以執行。 #2 所有線程的任務，都需要將任務的代碼當做參數傳給解釋器的代碼去執行，即所有的線程要想運行自己的任務，首先需要解決的是能夠訪問到解釋器的代碼。
綜上：
如果多個線程的target=work，那么執行流程是
多個線程先訪問到解釋器的代碼，即拿到執行權限，然后將target的代碼交給解釋器的代碼去執行
解釋器的代碼是所有線程共享的，所以垃圾回收線程也可能訪問到解釋器的代碼而去執行，這就導致了一個問題:對於同一個數據100，可能線程1執行x=100的同時，而垃圾回收執行的是回收100的操作，解決這種問題沒有什么高明的方法，就是加鎖處理，如下圖的GIL，保證python解釋器同一時間只能執行一個任務的代碼
7.2 GIL與Lock
GIL保護的是解釋器級的數據，保護用戶自己的數據則需要自己加鎖處理，如下圖
7.3 GIL與多線程
有了GIL的存在，同一時刻同一進程中只有一個線程被執行
聽到這里，有的同學立馬質問：進程可以利用多核，但是開銷大，而python的多線程開銷小，但卻無法利用多核優勢，也就是說python沒用了，php才是最牛逼的語言？
別着急啊，老娘還沒講完呢。
要解決這個問題，我們需要在幾個點上達成一致：
#1. cpu到底是用來做計算的，還是用來做I/O的？ #2. 多cpu，意味着可以有多個核並行完成計算，所以多核提升的是計算性能 #3. 每個cpu一旦遇到I/O阻塞，仍然需要等待，所以多核對I/O操作沒什么用處
一個工人相當於cpu，此時計算相當於工人在干活，I/O阻塞相當於為工人干活提供所需原材料的過程，工人干活的過程中如果沒有原材料了，則工人干活的過程需要停止，直到等待原材料的到來。
如果你的工廠干的大多數任務都要有准備原材料的過程（I/O密集型），那么你有再多的工人，意義也不大，還不如一個人，在等材料的過程中讓工人去干別的活，
反過來講，如果你的工廠原材料都齊全，那當然是工人越多，效率越高
結論：
對計算來說，cpu越多越好，但是對於I/O來說，再多的cpu也沒用
當然對運行一個程序來說，隨着cpu的增多執行效率肯定會有所提高（不管提高幅度多大，總會有所提高），這是因為一個程序基本上不會是純計算或者純I/O，所以我們只能相對的去看一個程序到底是計算密集型還是I/O密集型，從而進一步分析python的多線程到底有無用武之地
#分析： 我們有四個任務需要處理，處理方式肯定是要玩出並發的效果，解決方案可以是： 方案一：開啟四個進程 方案二：一個進程下，開啟四個線程 #單核情況下，分析結果: 如果四個任務是計算密集型，沒有多核來並行計算，方案一徒增了創建進程的開銷，方案二勝 如果四個任務是I/O密集型，方案一創建進程的開銷大，且進程的切換速度遠不如線程，方案二勝 #多核情況下，分析結果： 如果四個任務是計算密集型，多核意味着並行計算，在python中一個進程中同一時刻只有一個線程執行用不上多核，方案一勝 如果四個任務是I/O密集型，再多的核也解決不了I/O問題，方案二勝 #結論：現在的計算機基本上都是多核，python對於計算密集型的任務開多線程的效率並不能帶來多大性能上的提升，甚至不如串行(沒有大量切換)，但是，對於IO密集型的任務效率還是有顯著提升的。