python多線程和GIL全局解釋器鎖

1、線程

    線程被稱為輕量級進程，是最小執行單元，系統調度的單位。線程切換需要的資源一般，效率一般。 

2、多線程

        在單個程序中同時運行多個線程完成不同的工作，稱為多線程

3、並發：

    操作系統同時執行幾個程序，這幾個程序都由一個cpu處理，但在一個時刻點上只有一個程序在cpu上處理

4、並行：

    操作系統同時執行2個程序，但是有兩個cpu，每個cpu處理一個程序，叫並行

5、串行： 

    是指的我們從事某項工作是一個步驟一個步驟去實施 

 

一、多線程

#python3是假的多線程，它不是真真正正的並行，其實就是串行，只不過利用了cpu上下文的切換而已

mport threading
import time
# def test1():
#     for i in range(10):
#         time.sleep(1)             #睡1s
#         print('test1=========>%s' % i)
#
#
# def test2():
#     for i in range(10):
#         time.sleep(1)
#         print('test2=========>%s' % i)
#
# t1 = threading.Thread(target=test1)    #定義一個線程  target=函數名
# t2 = threading.Thread(target=test2)
# t1.start()        #開啟線程
# t2.start()
# test1()
# test2()

# 多線程是無序的，並發的

因為在啟動一個線程時，線程不會立即執行，而是等待cpu的資源調度。

# def test1(n):
#     time.sleep(1)
#     print('task', n)
# for i in range(10):
#     t = threading.Thread(target=test1,args=('t-%s' % i,))  #args= 后接輸出結果  末尾必須加 “ ， ” 號
#     t.start()

 

#計算並發所用的時間

 
# import threading
# import time
# def dest(n):
#     time.sleep(1)
#     print('this is running====>%s' %n)
# l = []     #定義一個空列表
# start = time.time()     #開始的時間
# for i in range(10):        #10個進程
#     t = threading.Thread(target=dest,args=(i,))    
#     t.start()
#     l.append(t)      #把線程執行時間加入到列表
# for g in l:       
#     g.join()            #等待全部線程執行完畢
# end = time.time()            #執行結束時間
# print('time',(end-start))   #執行結束時間 - 開始執行的時間

 

import threading
import time
def test1(n):
    time.sleep(1)
    print('test1====>%s' %n)
def test2(n):
    time.sleep(2)
    print('test2====>%s' %n)
start = time.time()
l = []
t1 =  threading.Thread(target=test1,args=(1,))
t2 = threading.Thread(target=test2,args=(2,))
t1.start()
t2.start()
l.append(t1)
l.append(t2)
for i in l:
    i.join()
end = time.time()
print('time',(end - start))

 

#多線程共享全局變量

# g_num = 0
# def update():
#     global g_num    #global聲明全局變量
#     for i in range(10):
#         g_num += 1
#
# def reader():
#     global g_num
#     print(g_num)
#
# t1 = threading.Thread(target=update)
# t2 = threading.Thread(target=reader)
# t1.start()
# t2.start()
 

二、GIL全局解釋器鎖

        只有獲得GIL鎖的線程才能真正在cpu上運行。所以，多線程在python中只能交替執行，即使100個線程跑在100核cpu上，也只能用到1核。

 
# import threading
# global_num = 0
# def test1():
#     global global_num        #global聲明全局變量
#     for i in range(1000000):
#         global_num += 1
#     print("test1", global_num,threading.current_thread())
#
# def test2():
#     global global_num
#     for i in range(1000000):
#         global_num += 1
#     print("test2", global_num,threading.current_thread())
# t1 = threading.Thread(target=test1)
# t2 = threading.Thread(target=test2)
# t1.start()
# t2.start()
# print(global_num)

結果說明：每次執行結果都不一樣，原因是python從上往下執行，主線程走的快，當主線程走到最后print打印結果的時候，test1 test2的count++還在繼續執行，所以第一行打印出來的是它們在執行count++過程中的某一個值，至於test1和test2的值不是100w和200w，因為cpu沒有足夠的時間去進行count++就釋放鎖提交了

 

#互斥鎖

以上出現的結果是隨機的，並非我們想要的，所以要加入互斥鎖。

互斥鎖：

常用來防止兩個進程或線程同一時刻訪問相同的共享資源， 如果一個線程鎖定了一個互斥量，在它解除鎖定之前沒有其他線程可以鎖定這個互斥量。

import threading
import time
global_num = 0
 
lock = threading.Lock()           #互斥鎖
 
def test1():
    global global_num
    lock.acquire()
    for i in range(1000000):
        global_num += 1
    lock.release()
    print("test1", global_num)
 
 
def test2():
    global global_num
    lock.acquire()
    for i in range(1000000):
        global_num += 1
    lock.release()
    print("test2", global_num)
 
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)
start_time = time.time()
 
t1.start()
t2.start()
t1.join()
t2.join()
print(global_num)

加上互斥鎖之后，test1線程執行完才釋放鎖提交，讓test2線程拿到共享資源繼續執行，要想結果是200w，就必須是主線程等子線程執行完之后才執行print。

 

#只要在進行耗時的IO操作的時候，能釋放GIL，所以只要在IO密集型的代碼里，用多線程就很合適