一、線程理論

1.什麽是線程

多線程（即多個控制線程）的概念是，在一個進程中存在多個線程，多個線程共享該進程的地址空間，相當於一個車間內有多條流水線，都共用一個車間的資源。

所以，進程只是用來把資源集中到一起（進程只是一個資源單位，或者說資源集合），而線程才是cpu上的執行單位。

2.進程與線程的區別

• 同一進程內的多個線程共享該進程內的地址資源

• 創建線程的開銷要遠小於創建進程的開銷（創建一個進程，就是創建一個車間，涉及到申請空間，而且在該空間內建至少一條流水線，但創建線程，就只是在一個車間內造一條流水線，無需申請空間，所以創建開銷小）

3.多線程應用舉例

開啟一個字處理軟件進程，該進程肯定需要辦不止一件事情，比如監聽鍵盤輸入，處理文字，定時自動將文字保存到硬盤，這三個任務操作的都是同一塊數據，因而不能用多進程。只能在一個進程裏並發地開啟三個線程,如果是單線程，那就只能是，鍵盤輸入時，不能處理文字和自動保存，自動保存時又不能輸入和處理文字。

二、開啟線程的兩種方式

方式一：

import time, random
from threading import Thread

def task(name):
    print('%s is running' %name)
    time.sleep(random.randrange(1, 3))
    print('%s running end' %name)


if __name__ == '__main__':
    t1 = Thread(target=task, args=('gudon', ))
    t1.start()
    print('主線程。。。')
    
    
---------------------------打印結果-----------------------------
gudon is running
主線程。。。
gudon running end
 

方式二：

import time, random
from threading import Thread

class MyThread(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running' %self.name)
        time.sleep(random.randrange(1,3))
        print('%s running end' %self.name)


if __name__ == "__main__":
    t1 = MyThread('Astro')
    t1.start()
    print('主線程......')
    
---------------------------打印結果-----------------------------
Astro is running
主線程......
Astro running end
 

multprocess 、threading 兩個模塊在使用方式上相似性很大

二、進程與線程的區別

1.開線程的開銷遠小於開進程的開銷

進程：

import time, random
from threading import Thread
from multiprocessing import Process


def task(name):
    print('%s is running' %name)
    time.sleep(random.randrange(1, 3))
    print('%s running end' %name)


if __name__ == '__main__':
    p = Process(target=task, args=('Astro', ))
    p.start() # p.start ()將開啟進程的信號發給操作系統後，操作系統要申請內存空間，讓好拷貝父進程地址空間到子進程，開銷遠大於線程
    print('主...........')
    

---------------------------【進程】打印結果-----------------------------
主...........
Astro is running
Astro running end

線程：

import time, random
from threading import Thread
from multiprocessing import Process

def task(name):
    print('%s is running' %name)
    time.sleep(random.randrange(1, 3))
    print('%s running end' %name)


if __name__ == '__main__':
    t1 = Thread(target=task, args=('Astro', ))
    t1.start() #幾乎是t.start ()的同時就將線程開啟了，線程的創建開銷要小魚進程創建的開銷
    print('主...........')
    
---------------------------【線程】打印結果-----------------------------

Astro is running
主...........
Astro running end

2.同一進程內的多個線程共享該進程的地址空間

from threading import Thread
from multiprocessing import Process

n = 100
def task():
    global n
    n = 0

if __name__ == "__main__":
    p1 = Process(target=task)
    p1.start()
    p1.join()

    print('主 %s' %n)  
    
---------------------------打印結果-----------------------------
主 100

子進程 p1 創建的時候，會把主進程中的數據復制一份，進程之間數據不會互相影響，所以子進程p1 中 n=0 後，只是子進程中的 n 改了，主進程的 n 不會受影響 ,即 進程之間地址空間是隔離的

from threading import Thread
from multiprocessing import Process

n = 100
def task():
    global n
    n = 0

if __name__ == "__main__":
    t1 = Thread(target=task)
    t1.start()
    t1.join()

    print('主 %s' %n)

---------------------------打印結果-----------------------------
主 0

同一進程內的線程之間共享進程內的數據，所以為 0

3. pid

pid 就是 process id ,進程的id號。

開多個進程,每個進程都有不同的pid：

from multiprocessing import Process, current_process
from threading import Thread
import os

def task():
   # print('子進程...', current_process().pid)  # 也可以使用 os.getpid()或 current_process().pid 來查看當前進程的pid，os.getppid() 可以查看當前進程的父進程的pid
    print('子進程PID:%s  父進程的PID:%s' % (os.getpid(), os.getppid()))

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()

    print('主線程', current_process().pid)
    
    
---------------------------打印結果-----------------------------
主線程 808
子進程PID:7668  父進程的PID:808

在主進程下開啟多個線程,每個線程都跟主進程的pid一樣

from threading import Thread
import os
def task():
    print('子線程pid:',os.getpid())

if __name__ == '__main__':
    t1 = Thread(target=task, )
    t1.start()

    print('主線程pid:', os.getpid())

---------------------------打印結果-----------------------------
子線程pid: 9084
主線程pid: 9084

三、Thread對象的其他屬性或方法

Thread實例對象的方法
  # isAlive(): 返回線程是否活動的。
  # getName(): 返回線程名。
  # setName(): 設置線程名。

threading模塊提供的一些方法：
  # threading.currentThread(): 返回當前的線程變量。
  # threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啟動後、結束前，不包括啟動前和終止後的線程。
  # threading.activeCount(): 返回正在運行的線程數量，與len(threading.enumerate())有相同的結果。

from threading import Thread, currentThread,active_count,enumerate
import time
def task():
    print('%s is running '%currentThread().getName())
    time.sleep(2)
    print('%s is done' %currentThread().getName())


if __name__ == "__main__":
    t = Thread(target=task, )
    # t = Thread(target=task, name='子線程001')  # 也可以在這裏改子線程名字
    t.start()
    # t.setName('子線程001')
    t.join()
    currentThread().setName('主線程')
    print(active_count())  # 返回正在運行的線程數量
    print(enumerate())  # [<_MainThread(主線程, started 6904)>]     默認為：[<_MainThread(MainThread, started 6904)>]
    
    
---------------------------打印結果-----------------------------
子線程001 is running 
子線程001 is done
1
[<_MainThread(主線程, started 6432)>]

四、守護線程與互斥鎖

1.守護線程

無論是進程還是線程，都遵循：守護xxx會等待主xxx運行完畢後被銷毀

1、對主進程來說，運行完畢指的是主進程代碼運行完畢

主進程在其代碼結束後就已經算運行完畢了（守護進程在此時就被回收）,然後主進程會一直等非守護的子進程都運行完畢後回收子進程的資源(否則會產生僵屍進程)，才會結束，

2、對主線程來說，運行完畢指的是主線程所在的進程內所有非守護線程統統運行完畢，主線程才算運行完畢

主線程在其他非守護線程運行完畢後才算運行完畢（守護線程在此時就被回收）。因為主線程的結束意味著進程的結束，進程整體的資源都將被回收，而進程必須保證非守護線程都運行完畢後才能結束。

from threading import Thread
import time

def sayHi(name):
    time.sleep(2)
    print('%s say Hello')

if __name__ == '__main__':
    t = Thread(target=sayHi, args=('Astro', ))
    t.setDaemon(True)  # 設置為守護線程， t.daemon = True 也可以
    t.start()

    print('主線程')
    print(t.is_alive())
    
----------------------執行結果---------------------------
主線程
True

t.start() 後，系統會馬上創建出一條子線程，但是由於子線程中 time.sleep(2) ,2秒的時間對計算機來說已經很長了，所以在

print('主線程')
print(t.is_alive())

執行後，主線程結束，子線程跟著就結束了，因為我們設置了該子線程為守護線程

在看一個例子：

def foo():
    print('foo runing..')
    time.sleep(1)
    print('foo end')

def bar():
    print('bar running..')
    time.sleep(3)
    print('bar end')


if __name__ == '__main__':
    t1 = Thread(target=foo, )
    t2 = Thread(target=bar, )

    t1.setDaemon(True)
    t1.start()
    t2.start()

    print('main.......')
    
----------------------執行結果---------------------------   
foo runing..
bar running..
main.......
foo end
bar end

t1 為守護進程，t1.start() 後，馬上執行 foo函數，然後 time.sleep(1)

此時 t2.start() 開啟了線程，執行 bar函數後 time.sleep(3)

3秒的時間內，執行了主線程的 print(‘main......‘) , 然後主線程任務已經完成，但是由於 子線程t2 還未執行完畢，t2 非守護線程，主線程還需要等待 非守護線程t2運行完畢後才能結束，所以在等待 t2結束的時間裏，t1 線程執行完畢，t1只sleep 1秒，時間上足夠t1 先執行了

然後t2 三秒後執行自己剩下的部分

2.互斥鎖

from threading import Thread, Lock
import time

n = 100
def task(mutex):
    global n
    mutex.acquire()  # 加互斥鎖
    temp = n
    time.sleep(0.1)
    n = temp - 1
    mutex.release()

if __name__ == '__main__':
    mutex = Lock()
    t_list = []
    for i in range(100):
        t = Thread(target=task, args=(mutex, ))
        t_list.append(t)
        t.start()

    for t in t_list:
        t.join()

    print('main....',n)
 
----------------------執行結果---------------------------
main.... 0

如果不加互斥鎖的情況下，得到的結果是 main.... 99

因為，在循環中 t.start() 的時候，100個線程會立馬創建出來，然後在函數中，100個線程的 temp都被賦值為了 100，所以 n = temp - 1 只是循環的被賦值為 99 而已

另外，互斥鎖只保證裏局部的串行，與join 不一樣

五、GIL 全局解釋器鎖

運行這段代碼

import os, time
print(os.getpid())  # 5132
time.sleep(1000)

然後cmd 查看一下 tasklist |findstr python

結果：

python.exe                    5132 Console                    1      9,568 K

python 並發編程之多線程