程序、執行緒、協程篇
本節內容
- 作業系統發展史介紹
- 程序、與執行緒區別
- python GIL全域性直譯器鎖
- 執行緒
- 語法
- join
- 執行緒鎖之Lock\Rlock\訊號量
- 將執行緒變為守護程序
- Event事件
- queue佇列
- 生產者消費者模型
- Queue佇列
- 開發一個執行緒池
- 程序
- 語法
- 程序間通訊
- 程序池
作業系統發展史
手工操作（無作業系統）
1946年第一臺計算機誕生--20世紀50年代中期，還未出現作業系統，計算機工作採用手工操作方式。
手工操作
程式設計師將對應於程式和資料的已穿孔的紙帶（或卡片）裝入輸入機，然後啟動輸入機把程式和資料輸入計算機記憶體，接著通過控制檯開關啟動程式針對資料執行；計算完畢，印表機輸出計算結果；使用者取走結果並卸下紙帶（或卡片）後，才讓下一個使用者上機。
手工操作方式兩個特點：
（1）使用者獨佔全機。不會出現因資源已被其他使用者佔用而等待的現象，但資源的利用率低。
（2）CPU 等待手工操作。CPU的利用不充分。
20世紀50年代後期，出現人機矛盾：手工操作的慢速度和計算機的高速度之間形成了尖銳矛盾，手工操作方式已嚴重損害了系統資源的利用率（使資源利用率降為百分之幾，甚至更低），不能容忍。唯一的解決辦法：只有擺脫人的手工操作，實現作業的自動過渡。這樣就出現了成批處理。
批處理系統
批處理系統：載入在計算機上的一個系統軟體，在它的控制下，計算機能夠自動地、成批地處理一個或多個使用者的作業（這作業包括程式、資料和命令）。
聯機批處理系統
首先出現的是聯機批處理系統，即作業的輸入/輸出由CPU來處理。
主機與輸入機之間增加一個儲存裝置——磁帶，在運行於主機上的監督程式的自動控制下，計算機可自動完成：成批地把輸入機上的使用者作業讀入磁帶，依次把磁帶上的使用者作業讀入主機記憶體並執行並把計算結果向輸出機輸出。完成了上一批作業後，監督程式又從輸入機上輸入另一批作業，儲存在磁帶上，並按上述步驟重複處理。
監督程式不停地處理各個作業，從而實現了作業到作業的自動轉接，減少了作業建立時間和手工操作時間，有效克服了人機矛盾，提高了計算機的利用率。
但是，在作業輸入和結果輸出時，主機的高速CPU仍處於空閒狀態，等待慢速的輸入/輸出裝置完成工作： 主機處於“忙等”狀態。
離線批處理系統
為克服與緩解高速主機與慢速外設的矛盾，提高CPU的利用率，又引入了離線批處理系統，即輸入/輸出脫離主機控制。
這種方式的顯著特徵是：增加一臺不與主機直接相連而專門用於與輸入/輸出裝置打交道的衛星機。
其功能是：
（1）從輸入機上讀取使用者作業並放到輸入磁帶上。
（2）從輸出磁帶上讀取執行結果並傳給輸出機。
這樣，主機不是直接與慢速的輸入/輸出裝置打交道，而是與速度相對較快的磁帶機發生關係，有效緩解了主機與裝置的矛盾。主機與衛星機可並行工作，二者分工明確，可以充分發揮主機的高速計算能力。
離線批處理系統:20世紀60年代應用十分廣泛，它極大緩解了人機矛盾及主機與外設的矛盾。IBM-7090/7094：配備的監督程式就是離線批處理系統，是現代作業系統的原型。
不足：每次主機記憶體中僅存放一道作業，每當它執行期間發出輸入/輸出（I/O）請求後，高速的CPU便處於等待低速的I/O完成狀態，致使CPU空閒。
為改善CPU的利用率，又引入了多道程式系統。
多道程式系統
多道程式設計技術
所謂多道程式設計技術，就是指允許多個程式同時進入記憶體並執行。即同時把多個程式放入記憶體，並允許它們交替在CPU中執行，它們共享系統中的各種硬、軟體資源。當一道程式因I/O請求而暫停執行時，CPU便立即轉去執行另一道程式。
單道程式的執行過程：
在A程式計算時，I/O空閒， A程式I/O操作時，CPU空閒（B程式也是同樣）；必須A工作完成後，B才能進入記憶體中開始工作，兩者是序列的，全部完成共需時間=T1+T2。
多道程式的執行過程：
將A、B兩道程式同時存放在記憶體中，它們在系統的控制下，可相互穿插、交替地在CPU上執行：當A程式因請求I/O操作而放棄CPU時，B程式就可佔用CPU執行，這樣 CPU不再空閒，而正進行A I/O操作的I/O裝置也不空閒，顯然，CPU和I/O裝置都處於“忙”狀態，大大提高了資源的利用率，從而也提高了系統的效率，A、B全部完成所需時間<<T1+T2。
多道程式設計技術不僅使CPU得到充分利用，同時改善I/O裝置和記憶體的利用率，從而提高了整個系統的資源利用率和系統吞吐量（單位時間內處理作業（程式）的個數），最終提高了整個系統的效率。
單處理機系統中多道程式執行時的特點：
（1）多道：計算機記憶體中同時存放幾道相互獨立的程式；
（2）巨集觀上並行：同時進入系統的幾道程式都處於執行過程中，即它們先後開始了各自的執行，但都未執行完畢；
（3）微觀上序列：實際上，各道程式輪流地用CPU，並交替執行。
多道程式系統的出現，標誌著作業系統漸趨成熟的階段，先後出現了作業排程管理、處理機管理、儲存器管理、外部裝置管理、檔案系統管理等功能。
多道批處理系統
20世紀60年代中期，在前述的批處理系統中，引入多道程式設計技術後形成多道批處理系統（簡稱：批處理系統）。
它有兩個特點：
（1）多道：系統內可同時容納多個作業。這些作業放在外存中，組成一個後備佇列，系統按一定的排程原則每次從後備作業佇列中選取一個或多個作業進入記憶體執行，執行作業結束、退出執行和後備作業進入執行均由系統自動實現，從而在系統中形成一個自動轉接的、連續的作業流。
（2）成批：在系統執行過程中，不允許使用者與其作業發生互動作用，即：作業一旦進入系統，使用者就不能直接干預其作業的執行。
批處理系統的追求目標：提高系統資源利用率和系統吞吐量，以及作業流程的自動化。
批處理系統的一個重要缺點：不提供人機互動能力，給使用者使用計算機帶來不便。
雖然使用者獨佔全機資源，並且直接控制程式的執行，可以隨時瞭解程式執行情況。但這種工作方式因獨佔全機造成資源效率極低。
一種新的追求目標：既能保證計算機效率，又能方便使用者使用計算機。 20世紀60年代中期，計算機技術和軟體技術的發展使這種追求成為可能。
分時系統
由於CPU速度不斷提高和採用分時技術，一臺計算機可同時連線多個使用者終端，而每個使用者可在自己的終端上聯機使用計算機，好象自己獨佔機器一樣。
分時技術：把處理機的執行時間分成很短的時間片，按時間片輪流把處理機分配給各聯機作業使用。
若某個作業在分配給它的時間片內不能完成其計算，則該作業暫時中斷，把處理機讓給另一作業使用，等待下一輪時再繼續其執行。由於計算機速度很快，作業執行輪轉得很快，給每個使用者的印象是，好象他獨佔了一臺計算機。而每個使用者可以通過自己的終端向系統發出各種操作控制命令，在充分的人機互動情況下，完成作業的執行。
具有上述特徵的計算機系統稱為分時系統，它允許多個使用者同時聯機使用計算機。
特點：
（1）多路性。若干個使用者同時使用一臺計算機。微觀上看是各使用者輪流使用計算機；巨集觀上看是各使用者並行工作。
（2）互動性。使用者可根據系統對請求的響應結果，進一步向系統提出新的請求。這種能使使用者與系統進行人機對話的工作方式，明顯地有別於批處理系統，因而，分時系統又被稱為互動式系統。
（3）獨立性。使用者之間可以相互獨立操作，互不干擾。系統保證各使用者程式執行的完整性，不會發生相互混淆或破壞現象。
（4）及時性。系統可對使用者的輸入及時作出響應。分時系統效能的主要指標之一是響應時間，它是指：從終端發出命令到系統予以應答所需的時間。
分時系統的主要目標：對使用者響應的及時性，即不至於使用者等待每一個命令的處理時間過長。
分時系統可以同時接納數十個甚至上百個使用者，由於記憶體空間有限，往往採用對換（又稱交換）方式的儲存方法。即將未“輪到”的作業放入磁碟，一旦“輪到”，再將其調入記憶體；而時間片用完後，又將作業存回磁碟（俗稱“滾進”、“滾出“法），使同一儲存區域輪流為多個使用者服務。
多使用者分時系統是當今計算機作業系統中最普遍使用的一類作業系統。
實時系統
雖然多道批處理系統和分時系統能獲得較令人滿意的資源利用率和系統響應時間，但卻不能滿足實時控制與實時資訊處理兩個應用領域的需求。於是就產生了實時系統，即系統能夠及時響應隨機發生的外部事件，並在嚴格的時間範圍內完成對該事件的處理。
實時系統在一個特定的應用中常作為一種控制裝置來使用。
實時系統可分成兩類：
（1）實時控制系統。當用于飛機飛行、導彈發射等的自動控制時，要求計算機能儘快處理測量系統測得的資料，及時地對飛機或導彈進行控制，或將有關資訊通過顯示終端提供給決策人員。當用於軋鋼、石化等工業生產過程控制時，也要求計算機能及時處理由各類感測器送來的資料，然後控制相應的執行機構。
（2）實時資訊處理系統。當用於預定飛機票、查詢有關航班、航線、票價等事宜時，或當用於銀行系統、情報檢索系統時，都要求計算機能對終端裝置發來的服務請求及時予以正確的回答。此類對響應及時性的要求稍弱於第一類。
實時作業系統的主要特點：
（1）及時響應。每一個資訊接收、分析處理和傳送的過程必須在嚴格的時間限制內完成。
（2）高可靠性。需採取冗餘措施，雙機系統前後臺工作，也包括必要的保密措施等。
作業系統發展圖譜
程序與執行緒
什麼是程序(process)？
程式並不能單獨執行，只有將程式裝載到記憶體中，系統為它分配資源才能執行，而這種執行的程式就稱之為程序。程式和程序的區別就在於：程式是指令的集合，它是程序執行的靜態描述文字；程序是程式的一次執行活動，屬於動態概念。
在多道程式設計中，我們允許多個程式同時載入到記憶體中，在作業系統的排程下，可以實現併發地執行。這是這樣的設計，大大提高了CPU的利用率。程序的出現讓每個使用者感覺到自己獨享CPU，因此，程序就是為了在CPU上實現多道程式設計而提出的。
有了程序為什麼還要執行緒？
程序有很多優點，它提供了多道程式設計，讓我們感覺我們每個人都擁有自己的CPU和其他資源，可以提高計算機的利用率。很多人就不理解了，既然程序這麼優秀，為什麼還要執行緒呢？其實，仔細觀察就會發現程序還是有很多缺陷的，主要體現在兩點上：
-
程序只能在一個時間幹一件事，如果想同時幹兩件事或多件事，程序就無能為力了。
-
程序在執行的過程中如果阻塞，例如等待輸入，整個程序就會掛起，即使程序中有些工作不依賴於輸入的資料，也將無法執行。
例如，我們在使用qq聊天， qq做為一個獨立程序如果同一時間只能幹一件事，那他如何實現在同一時刻 即能監聽鍵盤輸入、又能監聽其它人給你發的訊息、同時還能把別人發的訊息顯示在螢幕上呢？你會說，作業系統不是有分時麼？但我的親，分時是指在不同程序間的分時呀， 即作業系統處理一會你的qq任務，又切換到word文件任務上了，每個cpu時間片分給你的qq程式時，你的qq還是隻能同時幹一件事呀。
再直白一點， 一個作業系統就像是一個工廠，工廠裡面有很多個生產車間，不同的車間生產不同的產品，每個車間就相當於一個程序，且你的工廠又窮，供電不足，同一時間只能給一個車間供電，為了能讓所有車間都能同時生產，你的工廠的電工只能給不同的車間分時供電，但是輪到你的qq車間時，發現只有一個幹活的工人，結果生產效率極低，為了解決這個問題，應該怎麼辦呢？。。。。沒錯，你肯定想到了，就是多加幾個工人，讓幾個人工人並行工作，這每個工人，就是執行緒！
什麼是執行緒(thread)？
執行緒是作業系統能夠進行運算排程的最小單位。它被包含在程序之中，是程序中的實際運作單位。一條執行緒指的是程序中一個單一順序的控制流，一個程序中可以併發多個執行緒，每條執行緒並行執行不同的任務
程序與執行緒的區別？
Python GIL(Global Interpreter Lock)
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)
上面的核心意思就是，無論你啟多少個執行緒，你有多少個cpu, Python在執行的時候會淡定的在同一時刻只允許一個執行緒執行，擦。。。，那這還叫什麼多執行緒呀？莫如此早的下結結論，聽我現場講。
首先需要明確的一點是GIL並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標準，但是可以用不同的編譯器來編譯成可執行程式碼。有名的編譯器例如GCC，INTEL C++，Visual C++等。Python也一樣，同樣一段程式碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行。像其中的JPython就沒有GIL。然而因為CPython是大部分環境下預設的Python執行環境。所以在很多人的概念裡CPython就是Python，也就想當然的把GIL歸結為Python語言的缺陷。所以這裡要先明確一點：GIL並不是Python的特性，Python完全可以不依賴於GIL
這篇文章透徹的剖析了GIL對python多執行緒的影響，強烈推薦看一下：http://www.dabeaz.com/python/UnderstandingGIL.pdf
Python threading模組
執行緒有2種呼叫方式，如下：
直接呼叫
import threading
import
time
def
sayhi(num):
#定義每個執行緒要執行的函式
print
(
"running on number:%s"
%
num)
time.sleep(
3
)
if
__name__
=
=
'__main__'
:
t1
=
threading.Thread(target
=
sayhi,args
=
(
1
,))
#生成一個執行緒例項
t2
=
threading.Thread(target
=
sayhi,args
=
(
2
,))
#生成另一個執行緒例項
t1.start()
#啟動執行緒
t2.start()
#啟動另一個執行緒
print
(t1.getName())
#獲取執行緒名
print
(t2.getName())
繼承式呼叫
import threading
import
time
class
MyThread(threading.Thread):
def
__init__(
self
,num):
threading.Thread.__init__(
self
)
self
.num
=
num
def
run(
self
):
#定義每個執行緒要執行的函式
print
(
"running on number:%s"
%
self
.num)
time.sleep(
3
)
if
__name__
=
=
'__main__'
:
t1
=
MyThread(
1
)
t2
=
MyThread(
2
)
t1.start()
t2.start()
Join & Daemon
#_*_coding:utf-8_*_
__author__
=
'Alex Li'
import
time
import
threading
def
run(n):
print
(
'[%s]------running----\n'
%
n)
time.sleep(
2
)
print
(
'--done--'
)
def
main():
for
i
in
range
(
5
):
t
=
threading.Thread(target
=
run,args
=
[i,])
t.start()
t.join(
1
)
print
(
'starting thread'
, t.getName())
m
=
threading.Thread(target
=
main,args
=
[])
m.setDaemon(
True
)
#將main執行緒設定為Daemon執行緒,它做為程式主執行緒的守護執行緒,當主執行緒退出時,m執行緒也會退出,由m啟動的其它子執行緒會同時退出,不管是否執行完任務
m.start()
m.join(timeout
=
2
)
print
(
"---main thread done----"
)
執行緒鎖(互斥鎖Mutex)
一個程序下可以啟動多個執行緒，多個執行緒共享父程序的記憶體空間，也就意味著每個執行緒可以訪問同一份資料，此時，如果2個執行緒同時要修改同一份資料，會出現什麼狀況？
import time
import
threading
def
addNum():
global
num
#在每個執行緒中都獲取這個全域性變數
print
(
'--get num:'
,num )
time.sleep(
1
)
num
-
=
1
#對此公共變數進行-1操作
num
=
100
#設定一個共享變數
thread_list
=
[]
for
i
in
range
(
100
):
t
=
threading.Thread(target
=
addNum)
t.start()
thread_list.append(t)
for
t
in
thread_list:
#等待所有執行緒執行完畢
t.join()
print
(
'final num:'
, num )
正常來講，這個num結果應該是0， 但在python 2.7上多執行幾次，會發現，最後打印出來的num結果不總是0，為什麼每次執行的結果不一樣呢？ 哈，很簡單，假設你有A,B兩個執行緒，此時都 要對num 進行減1操作， 由於2個執行緒是併發同時執行的，所以2個執行緒很有可能同時拿走了num=100這個初始變數交給cpu去運算，當A執行緒去處完的結果是99，但此時B執行緒運算完的結果也是99，兩個執行緒同時CPU運算的結果再賦值給num變數後，結果就都是99。那怎麼辦呢？ 很簡單，每個執行緒在要修改公共資料時，為了避免自己在還沒改完的時候別人也來修改此資料，可以給這個資料加一把鎖， 這樣其它執行緒想修改此資料時就必須等待你修改完畢並把鎖釋放掉後才能再訪問此資料。
*注：不要在3.x上執行，不知為什麼，3.x上的結果總是正確的，可能是自動加了鎖
加鎖版本
import time
import
threading
def
addNum():
global
num
#在每個執行緒中都獲取這個全域性變數
print
(
'--get num:'
,num )
time.sleep(
1
)
lock.acquire()
#修改資料前加鎖
num
-
=
1
#對此公共變數進行-1操作
lock.release()
#修改後釋放
num
=
100
#設定一個共享變數
thread_list
=
[]
lock
=
threading.Lock()
#生成全域性鎖
for
i
in
range
(
100
):
t
=
threading.Thread(target
=
addNum)
t.start()
thread_list.append(t)
for
t
in
thread_list:
#等待所有執行緒執行完畢
t.join()
print
(
'final num:'
, num )
GIL VS Lock
機智的同學可能會問到這個問題，就是既然你之前說過了，Python已經有一個GIL來保證同一時間只能有一個執行緒來執行了，為什麼這裡還需要lock? 注意啦，這裡的lock是使用者級的lock,跟那個GIL沒關係 ，具體我們通過下圖來看一下+配合我現場講給大家，就明白了。
那你又問了， 既然使用者程式已經自己有鎖了，那為什麼C python還需要GIL呢？加入GIL主要的原因是為了降低程式的開發的複雜度，比如現在的你寫python不需要關心記憶體回收的問題，因為Python直譯器幫你自動定期進行記憶體回收，你可以理解為python直譯器裡有一個獨立的執行緒，每過一段時間它起wake up做一次全域性輪詢看看哪些記憶體資料是可以被清空的，此時你自己的程式 裡的執行緒和 py直譯器自己的執行緒是併發執行的，假設你的執行緒刪除了一個變數，py直譯器的垃圾回收執行緒在清空這個變數的過程中的clearing時刻，可能一個其它執行緒正好又重新給這個還沒來及得清空的記憶體空間賦值了，結果就有可能新賦值的資料被刪除了，為了解決類似的問題，python直譯器簡單粗暴的加了鎖，即當一個執行緒執行時，其它人都不能動，這樣就解決了上述的問題， 這可以說是Python早期版本的遺留問題。
RLock（遞迴鎖）
說白了就是在一個大鎖中還要再包含子鎖
import threading,time
def
run1():
print
(
"grab the first part data"
)
lock.acquire()
global
num
num
+
=
1
lock.release()
return
num
def
run2():
print
(
"grab the second part data"
)
lock.acquire()
global
num2
num2
+
=
1
lock.release()
return
num2
def
run3():
lock.acquire()
res
=
run1()
print
(
'--------between run1 and run2-----'
)
res2
=
run2()
lock.release()
print
(res,res2)
if
__name__
=
=
'__main__'
:
num,num2
=
0
,
0
lock
=
threading.RLock()
for
i
in
range
(
10
):
t
=
threading.Thread(target
=
run3)
t.start()
while
threading.active_count() !
=
1
:
print
(threading.active_count())
else
:
print
(
'----all threads done---'
)
print
(num,num2)
Semaphore(訊號量)
互斥鎖 同時只允許一個執行緒更改資料，而Semaphore是同時允許一定數量的執行緒更改資料 ，比如廁所有3個坑，那最多隻允許3個人上廁所，後面的人只能等裡面有人出來了才能再進去。
import threading,time
def
run(n):
semaphore.acquire()
time.sleep(
1
)
print
(
"run the thread: %s\n"
%
n)
semaphore.release()
if
__name__
=
=
'__main__'
:
num
=
0
semaphore
=
threading.BoundedSemaphore(
5
)
#最多允許5個執行緒同時執行
for
i
in
range
(
20
):
t
=
threading.Thread(target
=
run,args
=
(i,))
t.start()
while
threading.active_count() !
=
1
:
pass
#print threading.active_count()
else
:
print
(
'----all threads done---'
)
print
(num)
Timer
def hello():
print
(
"hello, world"
)
t
=
Timer(
30.0
, hello)
t.start()
# after 30 seconds, "hello, world" will be printed
Events
通過Event來實現兩個或多個執行緒間的互動，下面是一個紅綠燈的例子，即起動一個執行緒做交通指揮燈，生成幾個執行緒做車輛，車輛行駛按紅燈停，綠燈行的規則。
import threading,time
import
random
def
light():
if
not
event.isSet():
event.
set
()
#wait就不阻塞 #綠燈狀態
count
=
0
while
True
:
if
count <
10
:
print
(
'\033[42;1m--green light on---\033[0m'
)
elif
count <
13
:
print
(
'\033[43;1m--yellow light on---\033[0m'
)
elif
count <
20
:
if
event.isSet():
event.clear()
print
(
'\033[41;1m--red light on---\033[0m'
)
else
:
count
=
0
event.
set
()
#開啟綠燈
time.sleep(
1
)
count
相關推薦
程序、執行緒與協程
程序
程序的出現是為了更好的利用CPU資源使到併發成為可能。 假設有兩個任務A和B，當A遇到IO操作，CPU默默的等待任務A讀取完操作再去執行任務B，這樣無疑是對CPU資源的極大的浪費。聰明的老大們就在想若在任務A讀取資料時，讓任務B執行，當任務A讀取完資料後，再切換到任務A執行。注意關
程序、執行緒和協程
一、程序
1、多工原理
多工是指作業系統同時可以執行多個任務。
單核CPU實現多工原理：作業系統輪流讓各個任務交替執行；
多核CPU實現多工原理：真正的執行多工只能在多核CPU上實現，多出來的任務輪流排程到每個核心上執行。
併發：看上去一起執行，任務數多
淺談程序、執行緒和協程三者之間的區別和聯絡
一、程序、執行緒、協程
1，程序
經典定義：一個執行中程式的例項。系統中的每個程式都執行在某個程序的上下文中。（-摘自 CSAPP）
程序是系統資源分配的最小單位
2，執行緒（thread）
執行緒就是執行在程序上下文中的邏輯流。
執行緒是作業系統能夠進行運算排程的最小單位。
&
一個故事講完程序、執行緒和協程
很久以前，有兩個程式，暫且稱他們旺財和小強吧。旺財和小強這兩個程式都很長，每個都有十幾萬行。 他們兩個的人生價值就是到CPU上去執行，把執行結果告訴人類。CPU是稀缺資源，只有一個，他們倆必須排著隊，輪流使用。旺財從頭到尾執行完了，讓出CPU， 讓小強從頭兒去執行。人類把這種處理方式叫做批處理。程序長久以來，
python 程序、執行緒與協程的區別
簡單總結
程序是資源分配的單位
執行緒是作業系統排程的單位
程序切換需要的資源很最大，效率很低
執行緒切換需要的資源一般，效率一般（當然了在不考慮GIL的情況下）
協程切換任務資源很小，效率高
多程序、多執行緒根據cpu核數不一樣可能是並行的，但是協程是在一個執行緒中 所以是併發
程序：一個執行
Java面試18|關於程序、執行緒與協程
# 管道( pipe )：管道是一種半雙工的通訊方式，資料只能單向流動，而且只能在具有親緣關係的程序間使用。程序的親緣關係通常是指父子程序關係。# 有名管道 (named pipe) ： 有名管道也是半雙工的通訊方式，但是它允許無親緣關係程序間的通訊。# 訊號量( semophore ) ： 訊號量是一個計
關於程序、執行緒和協程 的基本概念
程序、執行緒和協程
GIL執行緒全域性鎖
執行緒全域性鎖(Global Interpreter Lock),即Python為了保證執行緒安全而採取的獨立執行緒執行的限制,說白了就是一個核只能在同一時間執行一個執行緒.對於io密集型任務，python的多執
程序，執行緒，協程，io多路複用 總結
併發：要做到同時服務多個客戶端，有三種技術
1. 程序並行，只能開到當前cpu個數的程序，但能用來處理計算型任務 ，開銷最大
2. 如果並行不必要，那麼可以考慮用執行緒併發，單位開銷比程序小很多
執行緒：併發（輪詢排程，遇到阻塞就切換）
只要是網路，就會有延遲，有延遲就阻塞，所以比
Cpython的程序，執行緒，協程，io模型
一、程序：
一 基礎概念：
1、程序的定義： 程序本身是一個抽象的概念,程序是作業系統資源分配的基本單位，是正在進行的一個過程或者說一個任務，負責執行任務的是cpu。
2、並行與併發： 假設計算機只有一個cpu，由於一個cpu在同一時間只能執行一個任務，那麼當有多
python-12-程序，執行緒，協程
多程序：密集CPU任務，需要充分使⽤多核CPU資源（伺服器，⼤量的並⾏計算）的時候，⽤多進 程。
缺陷：多個程序之間通訊成本⾼，切換開銷⼤。
多執行緒：密集I/O任務（⽹絡I/O，磁碟I/O，資料庫I/O）使⽤多執行緒合適。
缺陷：同⼀個時間切⽚只能運⾏⼀個執
簡述程序，執行緒和協程
執行緒,程序和協程
執行緒
執行緒的概念
併發
任務數大於cpu核載,通過系統的各種任務跳讀演算法,是任務“在一起”執行任務！ 假的多工
並行
任務數小於cpu核數，即任務真的在一起執行
多執行緒
1 同時執行
下面例子中test1和test2是同時執行
import threadi
程序，執行緒，協程概念
一、概念
1、程序
程序（Process）是計算機中的程式關於某資料集合上的一次執行活動，是系統進行資源分配和排程的基本單位，是作業系統結構的基礎。在早期面向程序設計的計算機結構中，程序是程式的基本執行實體；在當代面向執行緒設計的計算機結構中，程序是執行緒的容
celery開啟程序，執行緒，協程
做推送通知，選用的celery。使用後沒有掉單，但是有時候推送資料慢。11:50到12:00查到推送2000筆，這時候有的使用者已經延遲十分鐘才將支付狀態更新完成。後來排查是沒有應用多執行緒，協程這些東西，預設只是開啟幾個程序。CELERYD_CONCURRENCY = 20
深入理解程序，執行緒，協程
> 程序，執行緒，協程，以及golang協程和python協程的區別。
## 1. 程序
程序是系統進行資源分配和排程的一個獨立單位，程式段、資料段、PCB三部分組成了程序實體（程序映像），**PCB是程序存在的唯一標準**
 | 程序、執行緒、協程的區別與聯絡
作為程式設計師，在面試的時候經常被問到：說說程序、執行緒、協程的區別。下面我們就總結一下。
1.面試答案
1.1 程序與執行緒的區別
總述：執行緒是程序的一個實體，一個程序至少有一個執行緒。
1.根本區別；程序是作業系統資源分配的基本
程序、執行緒、協程篇
本節內容
作業系統發展史介紹
程序、與執行緒區別
python GIL全域性直譯器鎖
執行緒
語法
join
執行緒鎖之Lock\Rlock\訊號量
將執行緒變為守護程序
Event事件
queue佇列
生產者消費者模型
Queue佇
程序、執行緒、協程（程序篇）
程序篇
(最近在學習程序，看視訊的時候做了一個總結)
現代作業系統（Window、Mac OS X、Unix、Linux）都支援‘多工’
什麼叫做多工呢？
--> 作業系統可以同時執行多個任務
程序、執行緒、協程（協程篇）
什麼是協程？
首先，先說一個前提：子程式/函式：在所有語言中都是層級呼叫的，比如A呼叫B。在B執行過程中又可以呼叫C，C執行完畢返回，B執行完畢返回，最後是A執行完畢返回。是通過棧實現的，一個執行緒就是執行一個子程式，子程式呼叫總是一個入口，一次返回，呼叫的順序是明確的。
Python程序、執行緒、協程詳解、執行效能、效率（tqdm）
多程序實踐——multiprocessing
筆者最近在實踐多程序發現multiprocessing，真心很好用，不僅加速了運算，同時可以GPU呼叫，而且互相之間無關聯，這樣可以很放心的進行計算。
譬如（參考：多程序）：
from multiprocessing import Pool
Python—程序、執行緒、協程
一、執行緒
執行緒是作業系統能夠進行運算排程的最小單位。它被包含在程序之中，是程序中的實際運作單位。一條執行緒指的是程序中一個單一順序的控制流，一個程序中可以併發多個執行緒，每條執行緒並行執行不同的任務
方法：
start &