併發程式設計概念大總結--乾貨

愛文飛翔發表於2019-08-01

程式

程式是計算機中最小的資源分配單位，進行中的一個程式就是一個程式。

程式需要作業系統來排程，每個程式執行起來的時候需要給分配一些記憶體,開啟關閉切換時間開銷大,程式之間資料隔離,程式也有資料不安全的問題用Lock解決

程式的三狀態圖：就緒執行阻塞

就緒-->操系統排程 -->執行-遇到io操作->阻塞-阻塞狀態結束->就緒
                      -時間片到了->就緒

併發程式設計概念大總結--乾貨

程式的排程演算法：給所有的程式分配資源或者分配CPU使用權的一種方法。

短作業優先、先來先服務、多級反饋演算法
多級反饋演算法：
- 多個任務佇列，優先順序從高到低
- 新來的任務總是優先順序最高
- 每個新任務幾乎會立即獲得一個時間片時間
- 執行完一個時間片之後就會降到下一級佇列中
- 總是優先順序高的任務都執行完才執行優先順序低的佇列
- 並且優先順序越高時間片越短

程式開啟和關閉
父程式開啟了子程式
父程式負責給子程式回收子程式結束之後的資源

from multiprocessing import Process
import os

def func():
   print(os.getpid(), os.getppid()) # pid process 子程式id    ppid 父程式id
if __name__ == '__main__':  # 只會在主程式中執行的所有的程式碼,寫在__main__下邊
   print('main:', os.getpid(), os.getppid())
   p = Process(target=func)  # target表示呼叫物件，即子程式要執行的任務
    p = Process(target=func,args=('安文',))
    # p = Process(target=func,kwargs={'name':'安文'})  兩種傳參方式
   p.start()  #非同步非阻塞 啟動程式，並呼叫該子程式中的p.run()

注意：在windows中Process()必須放到# if __name__ == '__main__':下
由於Windows沒有fork，多處理模組啟動一個新的Python程式並匯入呼叫模組。 
如果在匯入時呼叫Process（），那麼這將啟動無限繼承的新程式（或直到機器耗盡資源）。 
這是隱藏對Process（）內部呼叫的原，使用if __name__ == “__main __”，這個if語句中的語句將不會在匯入時被呼叫。

開啟程式的另一種方法：

物件導向的方法，通過繼承和重寫run方法完成啟動子程式

from multiprocessing import Process
# class 類名(Process):
#  def __init__(self,引數):
#     self.屬性名=引數
#     super().__init__()
#  def run(self):
#     print("子程式要執行的程式碼")
# p=類名()
# p.start()

Process類的一些其他方法和屬性：name  pid ident  daemon  terminate()  isalive()
p.name   給子程式起名字
is_alive()方法由執行緒呼叫，有返回值，如果執行緒還存活，返回true，如果執行緒消亡，返回false
terminate() #強制結束子程式 非同步非阻塞

守護程式：

# 主程式會等待所有子程式結束，是為了回收子程式的資源
# 守護程式會等待主程式的程式碼執行結束之後再結束，而不是等待整個主程式結束
# 主程式的程式碼什麼時候結束，守護程式就什麼時候結束，和其他子程式的執行進度無關

主程式建立守護程式：

- 守護程式會在主程式程式碼執行結束後就終止
- 守護程式內無法再開啟子程式，否則丟擲異常

注意：程式之間是相互獨立的，主程式程式碼執行結束，守護程式隨即終止

在start一個程式之前設定daemon=True,守護程式會等待主程式的程式碼結束就立即結束
p = Process(target=son2)
p.daemon = True  # 一定要在p.start()前設定,表示設定p是一個守護程式
p.start()

為什麼守護程式只守護主程式的程式碼？而不是等主程式結束之後才結束
#        為了給守護程式回收資源
#     守護程式會等其他子程式結束嗎？不會

一般情況下，多個程式執行順序可能是：

主程式程式碼結束-->守護程式結束-->子程式結束-->主程式結束
子程式結束-->主程式程式碼結束 -->守護程式結束-->主程式結束

程式之間通訊(IPC):

基於檔案：同一臺機器上的多個程式之間通訊
Queue佇列：基於socket的檔案級別的通訊來完成資料傳遞的，

佇列：安全管道：不安全
基於網路：同一臺機器或者多臺機器上的多程式之間的通訊
第三方工具：(訊息中介軟體):memcache/redis/rabbitmq/kafka

程式之間可以通過Manager類實現資料共享

共享資料不安全，需要自己加鎖解決資料安全問題

生產者模型消費者模型：

本質：讓生產資料和消費資料的效率達到平衡並且最大化效率

消費者:通常取到資料之後還要進行某些操作消費者如何結束：None
生產者：通常在放資料之前需要先通過某些程式碼來獲取資料

# 把原本獲取資料處理資料的完整過程進行了解耦
# 把生產資料和消費資料分開，根據生產和消費的效率不同，
# 來規劃生產者和消費者的個數，讓程式的執行效率達到平衡

#  如果你寫了一個程式所有的程式碼、和功能都放在一起
# 不分函式不分類也不分檔案，就叫這個程式是緊耦合的程式
# 緊耦合程式：程式碼只寫一次，不需要重構
# 鬆耦合的程式：需要重構，不斷迭代 複用程式碼

# 拆分的很清楚的程式 叫做 鬆耦合的程式，鬆耦合程式好

from multiprocessing import Queue,Pipe
# 佇列:ipc程式之間通訊，佇列資料安全，不需要自己加鎖。佇列做通訊，資訊之間傳遞，
# 基於socket實現的，pickle實現，鎖實現，
# pipe管道：也像佇列一樣，可以放資料可以取資料，沒有鎖資料不安全，
# 基於socket、pickle 實現的。沒有鎖 資料不安全

鎖----multiprocessing.Lock:

加鎖可以保證多個程式修改同一塊資料時，同一時間只能有一個任務可以進行修改，即序列修改，導致速度慢了，但保證了資料安全。

鎖:保證資料安全，會降低程式的執行效率，資料安全

互斥鎖，多程式中共享的資料需要加鎖

# from multiprocessing import Lock  #互斥鎖，多程式中共享的資料需要加鎖
# lock=Lock()
# lock.acquire()
# '''被鎖的內容在這裡寫'''
# lock.release()
# with lock：
#  ...

並行：

好，高效，多個cpu在自己的cpu上執行多個程式

併發：

一個cpu多個程式輪流執行，10個程式輪流使用一個cpu

多個程式同時執行，只要一個CPU,多個程式輪流在一個CPU上執行

巨集觀上：多個程式同時執行

微觀上：多個程式輪流在一個CPU上執行，本質上是序列

同步非同步阻塞非阻塞

同步：呼叫一個操作要等待結果

在做A件事的時候發起B事，必須等待B事件結束之後才能繼續A事件

非同步：更快，呼叫一個操作，不等待結果

在做A件事的時候發起B事，不需要等待B事件結束之後才能繼續A事件

阻塞:如果CPU不工作 input accept recv sleep connect
非阻塞：如果CPU在工作

# 同步阻塞：呼叫一個函式需要等待這個函式的執行結果，並且在執行這個函式的過程中CPU不工作 num=input('>>>')
# 同步非阻塞：呼叫一個函式需要等待這個函式的執行結果，並且在執行這個函式的過程中CPU工作 ret=eval(1+2+3+4)
# 非同步非阻塞:start() 呼叫一個函式不需要等待這個函式的執行結果，並且在執行這個函式的過程中CPU工作
# 非同步阻塞:呼叫一個函式不需要等待這個函式的執行結果，並且在執行這個函式的過程中CPU不工作
#  10個非同步的程式，獲取這個程式的返回值，並且能做到哪一個程式結束，就先獲取誰的返回值

# 同步阻塞
# 呼叫函式必須等待結果，cpu沒工作，input sleep recv accept content get
# 同步非阻塞 *******
# 呼叫函式必須等待結果，cpu工作了，呼叫了一個高計算的函式 ，strip,eval,max,sorted同步非阻塞
# 非同步阻塞
# 呼叫函式不需要立即獲取結果，而是繼續做其他的事情，在獲取結果的時候不知道先獲取誰的，但是總之要等
# 非同步非阻塞 *******
# 呼叫函式不需要立即獲取結果，也不需要等 start  terminate

執行緒

執行緒是計算機中能被CPU排程的最小單位，執行緒是程式中的一個單位，不能脫離程式存在，執行緒必須存在程式內。cpu執行的是解釋之後的執行緒中的程式碼，同一個程式中的多個執行緒可以同時被CPU執行。執行緒之間的資料是共享的，作業系統排程的最小單位，可以利用多核，作業系統排程，資料不安全，開啟關閉切換時間開銷非常小

全域性直譯器 GIL (global interpreter lock)：

在cpython直譯器下有個GIL鎖（全域性直譯器鎖）;全域性直譯器鎖的出現主要是為了完成GC的回收機制，對不同執行緒的引用計數的變化記錄的更加精準； 導致了同一個程式只能有一個執行緒真正被CPU執行,導致了同一個程式中的多個執行緒不能利用多核（不能並行）
節省的是IO操作的時間，而不是CPU計算的時間，因為CPU的計算速度非常快，大部分情況下，我們沒辦法把一條程式中所有的io操作都規避掉

GC:垃圾回收機制，就是一個執行緒

pypy直譯器 gc不能用多核

jpython直譯器 gc能利用多核

開啟執行緒:

# import time
# from threading import Thread
# def func(i):
#  print("start%s"%i)
#  time.sleep(1)
#  print("end%s"%i)
# for i in range(10):
#  Thread(target=func,args=(i,)).start()

# 物件導向方式起執行緒
# from threading import Thread
# class MyThread(Thread):
#   def __init__(self,a,b):
#       self.a=a
#       self.b=b
#       super().__init__()
#   def run(self):
#       print(self.ident)
# t=MyThread(1,2)
# t.start()   #開啟執行緒 才線上程中執行run方法
# print(t.ident)

# 執行緒是不能從外部關閉的 沒有terminate
# 所有的子執行緒只能是自己執行完程式碼之後就關閉
# current_thread()  當前執行緒的物件,current_thread().itent()執行緒的id
# enumerate() 列表  儲存了所有活著的執行緒物件,包括主執行緒和子執行緒
# active_count() 數字  儲存了所有活著的執行緒個數

主執行緒會等子執行緒結束之後才結束，子執行緒不結束，主執行緒就不結束

;因為主執行緒結束程式就會結束

守護執行緒 : 守護執行緒隨著主執行緒的結束而結束;

守護執行緒會在主執行緒的程式碼結束之後繼續守護其他子執行緒
# 守護程式  會隨著主程式的程式碼結束而結束，
# 如果主程式程式碼結束之後還有其他子程式在執行，守護程式不守護
# 守護執行緒  會隨著主執行緒的結束而結束
# 如果主執行緒程式碼結束之後還有其他子執行緒在執行，守護執行緒也守護

# 守護程式和守護執行緒的結束原理不同
# 守護程式需要主程式來回收、守護執行緒是隨著程式的結束才結束；所有的執行緒都會隨著程式的結束而被回收的
# 其他子執行緒-->主執行緒結束-->主程式結束-->整個程式中所有的資源都被回收-->守護執行緒也會被回收

執行緒之間資料不安全

# += -= *= /= while if 資料不安全 +和賦值是分開的兩個操作
# append pop strip資料安全
# 列表中的方法或者字典中的方法去操作全域性變數的時候 資料安全

執行緒鎖：

單例模式加鎖天生執行緒安全

import time
class A:
   from threading import Lock
   __instance=None
   lock=Lock()
   def __new__(cls, *args, **kwargs):
      with cls.lock:
         if not cls.__instance:
            time.sleep(0.000001)
            cls.__instance=super().__new__(cls)
      return cls.__instance
def func():
   a=A()
   print(a)
from threading import Thread
for i in range(10):
   Thread(target=func).start()

互斥鎖和遞迴鎖的區別：

遞迴鎖：(RLock)效率低，但是解決死鎖現象有奇效萬能鑰匙，臨時解決一些死鎖現象
遞迴鎖：在同一程式中可以被acquire多次，但一次acquire必須對應一次release
互斥鎖：效率高，能夠處理多個執行緒之間資料安全，但是多把互斥鎖交替的使用容易產生死鎖現象
互斥鎖：在同一個程式中不能被連續acquire多次，一次acquire對應一次release

死鎖現象是怎麼產生的？

多把（互斥鎖/遞迴）鎖並且在多個執行緒中交叉使用，（比如：兩把鎖，在第一把鎖沒有釋放之前就獲取第二把鎖）

解決死鎖現象：

出現了死鎖現象，最快速的解決方案把所有的互斥鎖都改成一把遞迴鎖，程式的效率會降低

佇列：queue；

執行緒佇列特點：資料安全，一定是加鎖了,先進先出

池

什麼是池？

要在程式還沒開始的時候，還沒提交任務先建立幾個執行緒或程式放在一個池子裡

為什麼要用池？

如果先開好執行緒或者程式，那麼有任務之後就可以直接使用這個池中的資料了，節省時間
並且開好的執行緒或程式一直存在池中，可以被多個任務反覆利用，這樣極大的減少了開啟和關閉、排程執行緒/程式的時間開銷。
池中的執行緒/程式個數控制了作業系統需要排程的任務個數，控制池中的單位有利於提高作業系統的效率，減輕作業系統的負擔

# multiprocessing 模組 仿照threading寫的pool
# concurrent.futures模組，執行緒池和程式池都能夠用相似的方式開啟和使用
#ThreadPoolExecutor：執行緒池，提供非同步呼叫
#ProcessPoolExecutor: 程式池，提供非同步呼叫

執行緒池：（一般根據io的比例定製）

import time
import random
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def func(a,b):
    print(current_thread().ident,'start',a,b)   #接收引數
    time.sleep(random.randint(1,4))
    print(current_thread().ident,'end')
tp=ThreadPoolExecutor(4)
for i in range(20):
    tp.submit(func,i,i+1)   #按位置傳引數
    tp.submit(func, a=i, b=i + 1)   #關鍵字傳引數

程式池：

程式池（高計算場景，沒有io（沒有檔案操作、沒有資料庫操作、沒有網路操作
、沒有input））

import os
import time
import random
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def func(a,b):
   print(os.getpid(),'start',a,b)   #接收引數
   time.sleep(random.randint(1,4))
   print(os.getpid(),'end')
if __name__ == '__main__':
   pp=ProcessPoolExecutor(4)
   for i in range(20):
      pp.submit(func,i,i+1)   #按位置傳引數
      pp.submit(func, a=i, b=i + 1)   #關鍵字傳引數

回撥函式:效率最高

import time
import random
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a,b):
   print(current_thread().ident,'start',a,b)   #接收引數
   time.sleep(random.randint(1,4))
   print(current_thread().ident,'end',a)
   return （a,a*b)
def print_func(ret):    #非同步阻塞
   print(ret.result())
if __name__ == '__main__':
   tp=ThreadPoolExecutor(4)
   for i in range(20):     #提交任務是非同步非阻塞
      ret=tp.submit(func,i,i+1)   #按位置傳引數
      ret.add_done_callback(print_func)   #非同步阻塞

# 回撥函式 給ret物件繫結一個回撥函式，等待ret對應的任務有了結果之後立即呼叫print_func這個函式
# 就可以對結果立即進行處理，而不用按照順序接收處理結果

協程

協程：是作業系統不可見的

協程本質就是一條執行緒，多個任務在一條執行緒上來回切換；
利用協程這個概念實現的內容：規避io操作，達到將一條執行緒中的io操作降到最低的目的

# 切換並規避io操作的模組：
# gevent:利用了greenlet底層模組完成的切換+自動規避io的功能
# asyncio:利用了yield底層語法完成的切換+自動規避io的功能
# tornado非同步的web框架
# yield from:為了更好的實現協程
#  send為了更好的實現協程
# asyncio 模組 基於Python原生的協程的概念正式被成立
# 特殊的在Python中提供協程功能的關鍵字：aysnc  await

使用者級別的協程還有什麼好處：

減輕作業系統的負擔
一條執行緒如果開了多個協程，那麼給作業系統的印象是執行緒很忙，
這樣能爭取一些時間片時間來被cpu執行，程式的效率就提高了

協程：

import gevent
def func():
   print('start func')
   gevent.sleep(1)
   print('end func')
g=gevent.spawn(func)
g1=gevent.spawn(func)
gevent.joinall([g,g1])

asyncio：

import asyncio
async def func(name):   #async協程函式
   print("start",name)
   #await 關鍵字必須寫在async函式裡
   await asyncio.sleep(1)  #await後面可能會生成阻塞的方法
   print('end')
loop=asyncio.get_event_loop()  #事件迴圈
loop.run_until_complete(asyncio.wait([func('wudi'),func('anwen')]))

程式、執行緒和協程

# 程式：程式之間資料隔離，資料不安全，由作業系統（級別）切換，開銷非常大，能利用多核
# 執行緒：執行緒之間資料共享，資料不安全，由作業系統（級別）切換，開銷小,不能利用多核
# 協程：協程之間資料共享，資料安全  ，使用者級別，開銷更小，不能利用多核，協程的所有切換都基於使用者，那麼只有在使用者級別
# 能夠感知到的io操作才會用協程模組來切換來規避(socket,請求網頁的)
asyncio
async def func(name):   #async協程函式
   print("start",name)
   #await 關鍵字必須寫在async函式裡
   await asyncio.sleep(1)  #await後面可能會生成阻塞的方法
   print('end')
loop=asyncio.get_event_loop()  #事件迴圈
loop.run_until_complete(asyncio.wait([func('wudi'),func('anwen')]))

程式、執行緒和協程

# 程式：程式之間資料隔離，資料不安全，由作業系統（級別）切換，開銷非常大，能利用多核
# 執行緒：執行緒之間資料共享，資料不安全，由作業系統（級別）切換，開銷小,不能利用多核
# 協程：協程之間資料共享，資料安全  ，使用者級別，開銷更小，不能利用多核，協程的所有切換都基於使用者，那麼只有在使用者級別
# 能夠感知到的io操作才會用協程模組來切換來規避(socket,請求網頁的)

Java乾貨神總結，程式設計師面試技巧
2018-11-14
Java程式設計師面試
技術乾貨 | Flutter線上程式設計實踐總結
2021-11-11
Flutter程式設計
Java 併發程式設計學習總結
2022-02-28
Java程式設計
併發程式設計——基礎概念（一）
2021-08-05
程式設計
併發程式設計——基礎概念（二）
2021-08-06
程式設計
Java併發程式設計實戰總結（一）
2020-06-06
Java程式設計
併發程式設計-6.並行程式設計概念
2024-03-30
程式設計並行行程
【Java併發程式設計】併發程式設計大合集-值得收藏
2016-06-02
Java程式設計
Canvas乾貨總結
2020-06-29
Canvas
SpringBoot 併發程式設計學習歷程(絕對的乾貨)
2018-04-05
Spring Boot程式設計
「乾貨總結」程式設計師必知必會的十大排序演算法
2020-11-26
程式設計師排序演算法
[乾貨] 位運算面試題大總結
2017-03-28
面試題
【Java併發程式設計】synchronized相關面試題總結
2020-09-21
Java程式設計synchronized面試題
關於Java併發程式設計的總結和思考
2016-11-07
Java程式設計
【乾貨】遊戲介面設計 (二)結構設計
2023-04-04
遊戲
併發程式設計模型小結
2018-09-27
程式設計模型
好程式設計師web前端乾貨之web前端開發框架彙總
2019-05-20
程式設計師Web前端框架
Java多執行緒與併發程式設計總結（一）
2017-01-12
Java執行緒程式設計
【程式設計師乾貨】開發常用免費介面
2024-01-09
程式設計師
乾貨總結！每個設計師必知的40個設計素材站
2015-11-20
「硬核乾貨」總結 IDEA 開發的26個常用設定
2020-02-20
Idea
Web測試乾貨總結
2018-01-28
Web
Flutter 開發踩坑記錄（乾貨總結）
2020-02-28
Flutter
乾貨：計算機網路知識總結
2018-04-02
計算機網路
好程式設計師分享自學大資料入門乾貨
2019-05-27
程式設計師大資料
api設計乾貨
2017-11-16
API
【系統設計】併發相關概念
2020-12-15
c++11併發程式設計歷程（15）：併發設計以及併發設計資料結構的思考
2020-11-26
C++程式設計資料結構
併發程式設計
2019-02-27
程式設計
React Native純乾貨總結
2022-02-22
React Native
【乾貨】常用maven外掛總結
2017-03-28
Maven
乾貨 | Dart 併發機制詳解
2022-01-20
Dart
程式設計面試的10大演算法概念彙總
2013-11-29
程式設計面試演算法
Java併發程式設計資源總目錄
2017-12-14
Java程式設計
純乾貨！程式設計師面試的技巧
2016-04-19
程式設計師面試
【大總結2】大學兩年，寫了這篇幾十萬字的乾貨總結
2019-12-08
併發程式設計面試必備：JUC 中的 Atomic 原子類總結
2018-10-31
程式設計面試
好程式設計師大資料學習路線之zookeeper乾貨
2019-08-28
程式設計師大資料

併發程式設計概念大總結--乾貨

程式

程式的三狀態圖： 就緒 執行 阻塞

守護程式：

一般情況下，多個程式執行順序可能是：

程式之間通訊(IPC):

程式之間可以通過Manager類實現資料共享

生產者模型 消費者模型：

鎖----multiprocessing.Lock:

並行：

併發：

同步非同步阻塞非阻塞

同步：呼叫一個操作要等待結果

在做A件事的時候發起B事，必須等待B事件結束之後才能繼續A事件

非同步：更快，呼叫一個操作，不等待結果

在做A件事的時候發起B事，不需要等待B事件結束之後才能繼續A事件

執行緒

全域性直譯器 GIL (global interpreter lock)：

開啟執行緒:

守護執行緒 : 守護執行緒隨著主執行緒的結束而結束;

執行緒之間資料不安全

執行緒鎖：

單例模式加鎖 天生執行緒安全

互斥鎖和遞迴鎖的區別：

死鎖現象是怎麼產生的？

解決死鎖現象：

池

什麼是池？

為什麼要用池？

執行緒池：（一般根據io的比例定製）

程式池：

回撥函式:效率最高

協程

協程：是作業系統不可見的

使用者級別的協程還有什麼好處：

協程：

asyncio：

程式、執行緒和協程

程式、執行緒和協程

相關文章

程式的三狀態圖：就緒執行阻塞

生產者模型消費者模型：

單例模式加鎖天生執行緒安全