12 認識進程與線程 (進階)

認識進程與線程（python）

　　一段時間沒有更新博客了，今天和你們講講關於 python 進程和線程的知識點。(我的心得，多多指教！)

階段一：併發與並行的深刻理解

​ 並行必定是併發，但併發不必定是並行。

​ 並行是相對的，並行是絕對的。

一、關於並行與併發的問題引入：

問題一： 計算機是如何執行程序指令的？

問題二： 計算機如何模擬出並行執行的效果？

問題三： 真正的並行須要依賴什麼？

二、計算機執行指令示意圖

二、輪詢調度實現併發執行

併發：看上去一塊兒執行，同時在發生

並行：真正一塊兒執行，同時在進行

調度算法：

​ 時間片輪轉

​ 優先級調度

三、並行須要的核心條件

​ 並行真正的核心條件是有多個CPU

階段二：多進程實現並行

一、多進程並行問題引入

問題一： 什麼是進程？

問題二： 如何在Python中使用進程？

問題三： 多進程實現並行的必要條件是什麼？

二、進程的概念

計算機程序是存儲在磁盤上的可執行二進制（或其餘類型）文件。

​ 只有把它們加載到內存中，並被操做系統調用它們纔會擁有其本身的生命週期。

進程則是表示的一個正在執行的程序。

​ 每一個進程都擁有本身的地址空間、內存、數據棧以及其餘用於跟蹤執行的輔助數據

操做系統負責其上全部進程的執行。

​ 操做系統會爲這些進程合理地分配執行時間。

三、在Python中直接執行耗時函數

import time
​
print('main-task start:', time.asctime(time.localtime(time.time())))
​
def func():
    print('sub-task start:', time.asctime(time.localtime(time.time())))
    time.sleep(5)
    print('sub-task end:', time.asctime(time.localtime(time.time())))
​
func()
time.sleep(5)
print('main-task end:', time.asctime(time.localtime(time.time())))

四、在Python中使用進程來分擔耗時任務

import time
import multiprocessing
​
def func(n):
    for i in range(n):
        for a in range(n):
            for b in range(n):
                print(b)
​
start_time = time.time()
​
p = multiprocessing.Process(target=func, args=(50, ))    # 實例化，建立一個進程
# 參數如何傳?  args=(50, )  kwargs={'n': 50}
p.start()   # 開啓進程
p.join()    # 主進程等待子進程結束
​
func(50)
# func(50)
​
end_time = time.time()
print('運行了%ds!' % (end_time - start_time))

五、多進程並行的必要條件

總進程數量很少於CPU核心數量！

​ 所以，如今運行的程序都是輪詢調度產生的並行假象。可是在Python層面的確得到了並行！

階段三：多線程實現併發

一、多線程併發問題引入

問題一： 什麼是線程？

問題二： 如何在Python中使用線程？

問題三： 爲何多線程不是並行？

二、線程的概念

線程被稱做輕量級進程。

​ 與進程相似，不過它們是在同一個進程下執行的。而且它們會共享相同的上下文。

當其餘線程運行時，它能夠被搶佔（中斷）和臨時掛起（也成爲睡眠）— 讓步

​ 線程的輪詢調度機制相似於進程的輪詢調度。只不過這個調度不是由操做系統來負責，而是由Python解釋器來負責。

三、在Python中使用線程來避開阻塞任務

import time
import multiprocessing
import threading
​
print('---outer--start---:', time.asctime(time.localtime(time.time())))
​
def func():
    print('---inner--start---:', time.asctime(time.localtime(time.time())))
    time.sleep(5)
    print('---inner--end---:', time.asctime(time.localtime(time.time())))
​
"""
在進程裏能夠模擬耗時任務，可是在線程裏只能模擬阻塞任務，不能模擬耗時任務。由於多線程只有一個核心進程。
"""
p = multiprocessing.Process(target=func)    # 建立子進程
t = threading.Thread(target=func)   # 建立子線程
t.start()   # 開啓子線程
​
time.sleep(5)
print('---outer--end---:', time.asctime(time.localtime(time.time())))

CPU在任意一個進程裏，任意時刻，只能執行一個線程

​ 對進程的輪詢是操做系統負責調度

​ 對線程的輪詢是Python解釋器負責調度

四、GIL鎖 全局解釋器鎖

Python在設計的時候，尚未多核處理器的概念。

所以，爲了設計方便與線程安全，直接設計了一個鎖。

這個鎖要求，任何進程中，一次只能有一個線程在執行。

所以，並不能爲多個線程分配多個CPU。

因此Python中的線程只能實現併發，

而不能實現真正的並行。

可是Python3中的GIL鎖有一個很棒的設計，

在遇到阻塞（不是耗時）的時候，會自動切換線程。

五、GIL鎖帶給咱們的新認知

遇到阻塞就自動切換。所以咱們能夠利用這種機制來有效的避開阻塞~充分利用CPU

階段四：使用多進程與多線程來實現併發服務器

關鍵點一： 多進程是並行執行，

​ 至關於分別獨立得處理各個請求。

關鍵點二： 多線程，雖然不能並行運行，

​ 可是能夠經過避開阻塞切換線程

​ 來實現併發的效果，而且不浪費CUP

from socket import *
from multiprocessing import Process     # 進程
from threading import Thread    # 線程
​
# 建立套接字
server = socket()
server.bind(('', 9999))
server.listen(1000)
​
# 定義函數
def func(conn):
    while True:
        recv_data = conn.recv(1024)
        if recv_data:
            print(recv_data)
            conn.send(recv_data)
        else:
            conn.close()
            break
​
​
while True:   # 循環去監聽
    conn, addr = server.accept()
    # 每生成一個對等鏈接套接字，我就生成一個進程、線程，而且我讓這個進程、線程去服務這個鏈接過來的客戶端
​
    # p = Process(target=func, args=(conn, ))    # 生成一個進程
    # p.start()   # 啓動進程
​
​
    t = Thread(target=func, args=(conn, ))    # 生成一個線程
    t.start()   # 啓動線程