python 多線程效率

在一臺8核的CentOS上，用python 2.7.6程序執行一段CPU密集型的程序。

            
import time
def fun(n):#CPU密集型的程序
  while(n>0):
    n -= 1

start_time = time.time()
fun(10000000)
print('{} s'.format(time.time() - start_time))#測量程序執行時間
          

測量三次程序的執行時間，平均時間為0.968370994秒。這就是一個線程執行一次fun(10000000)所需要的時間。

下面用兩個線程并行來跑這段CPU密集型的程序。

            
import time
import threading

def fun(n):
  while(n>0):
    n -= 1

start_time = time.time()
t1 = threading.Thread( target=fun, args=(10000000,) )
t1.start()
t2 = threading.Thread( target=fun, args=(10000000,) )
t2.start()

t1.join()
t2.join()
print('{} s'.format(time.time() - start_time))
          

測量三次程序的執行時間，平均時間為2.150056044秒。

為什么在8核的機器上，多線程執行時間并不比順序執行快呢？

再做另一個實驗，用下面的命令，把8核cpu中的7個核禁掉。

            
[xxx]# echo 0 > /sys/devices/system/cpu/cpu1/online
[xxx]# echo 0 > /sys/devices/system/cpu/cpu2/online
[xxx]# echo 0 > /sys/devices/system/cpu/cpu3/online
[xxx]# echo 0 > /sys/devices/system/cpu/cpu4/online
[xxx]# echo 0 > /sys/devices/system/cpu/cpu5/online
[xxx]# echo 0 > /sys/devices/system/cpu/cpu6/online
[xxx]# echo 0 > /sys/devices/system/cpu/cpu7/online
          

然后在運行這個多線程的程序，三次平均時間為2.533491453秒。為什么多線程程序在多核上跑的時間只比單核快一點點呢？

這就要提到python程序多線程的實現機制了。

Python多線程實現機制

python的多線程機制，就是用C實現的真實系統中的線程。線程完全被操作系統控制。

python內部創建一個線程的步驟是這樣的：

• 創建一個數據結構PyThreadState，其中含有一些解釋器狀態
• 調用pthread創建線程
• 執行線程函數

由于python是解釋形動態語言，所以在實現線程時，需要PyThreadState結構來保存一些信息：

• 當前的stack frame (對python代碼)
• 當前的遞歸深度
• 線程ID
• 可選的tracing/profiling/debugging hooks

PyThreadState是C語言實現的一個結構體（摘自[2]）：

            
typedef struct _ts {
  struct _ts *next; # 鏈表指正
  PyInterpreterState *interp; # 解釋器狀態
  struct _frame *frame; # 當前的stack frame
  int recursion_depth; # 當前的遞歸深度
  int tracing;
  int use_tracing;
  Py_tracefunc c_profilefunc;
  Py_tracefunc c_tracefunc;
  PyObject *c_profileobj;
  PyObject *c_traceobj;
  PyObject *curexc_type;
  PyObject *curexc_value;
  PyObject *curexc_traceback;
  PyObject *exc_type;
  PyObject *exc_value;
  PyObject *exc_traceback;
  PyObject *dict;
  int tick_counter;
  int gilstate_counter;
  PyObject *async_exc;
  long thread_id; # 線程ID
} PyThreadState;
          

從目前最新的python源碼中來看，這個結構體中的內容已經有所改變，但記錄解釋器狀態的指針PyInterpreterState *interp依然存在。

python解釋器實現時，用了一個全局變量(_PyThreadState_Current)

[https://github.com/python/cpython/blob/3.1/Python/pystate.c]（python3.1和之前的代碼中都存在，python3.2就有所不同了）

            
PyThreadState *_PyThreadState_Current = NULL;
          

_PyThreadState_Current指向當前執行線程的PyThreadState數據結構。解釋器通過這個變量，來獲取當前所執行線程的信息。

python程序中，有一個全局解釋器鎖GIL來控制線程的執行，每一個時刻只允許一個線程執行。

GIL的行為

GIL最基本的行為只有下面兩個：

• 當前執行的線程持有GIL
• 線程遇到I/O阻塞時，會釋放GIL。（阻塞等待時，就釋放GIL，給另一個線程執行的機會）

那么，如果遇到CPU密集型的線程，一直占用CPU，不會被I/O阻塞，是不是其它線程就沒有機會執行了呢？

非也，為了避免這種情況，解釋器還會周期性的check并執行線程調度。

解釋器周期性check行為，做的就是下面這3件事：

• 復位tick計數器
• 在主線程中，檢查有沒有需要處理的信號
• 讓當前執行線程釋放(Release)GIL，讓其他線程獲取(acquire)GIL并執行（給其他線程執行的機會）

而解釋器check的周期，默認是100個tick。解釋器的tick并不是基于時間的，每個tick大致相當于一條匯編指令的執行時間。

從解釋器的check行為中可以看到，只有主線程中會處理信號，子線程中都不處理信號。所以python多線程程序，會給人一種無法處理Ctrl+C的假象，因為大部分情況下主線程被block住了，無法處理SIGINT信號。

注意python中并沒有實現線程調度，python的多線程調度完全依賴于操作系統。所以python多線程編程中沒有線程優先級等概念。

GIL的實現

python的GIL并不是簡單的用lock實現的，GIL是用signal實現的。

• 線程獲取(acquire)GIL前，先檢查有沒有被free，如果沒有，就sleep等待signal
• 線程釋放GIL時，還要發送signal

參考

[1] Understanding the Python GIL.? http://dabeaz.com/python/UnderstandingGIL.pdf

[2] Inside the Python GIL.? http://www.dabeaz.com/python/GIL.pdf

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。