一，什麼是程序
程序：正在進行的一個過程或者說是一個任務，而負責執行任務則是CPU
那麼一個扣扣能否稱為一個程序？
是以說程序指的是一個正在程序或者說一個任務，是一個抽象的概念，扣扣是死的，也就是說程式是死的，隻是一個檔案的執行。
二，程序與程式的差別
程式僅僅隻是一堆代碼而已，而程序指的是程式的運作過程。
舉例：
想象一位有一手好廚藝的廚師正在為他的女兒烘制生日蛋糕。
他有做生日蛋糕的食譜，
廚房裡有所需的原料:面粉、雞蛋、韭菜，蒜泥等。
在這個比喻中：
做蛋糕的食譜就是程式(即用适當形式描述的算法)
廚師就是處理器(cpu)
而做蛋糕的各種原料就是輸入資料。
程序就是廚師閱讀食譜、取來各種原料以及烘制蛋糕等一系列動作的總和。
現在假設廚師的兒子哭着跑了進來，說：Hey, Dad, my head got stung by a bee.
廚師想了想，處理兒子蟄傷的任務比給女兒做蛋糕的任務更重要，于是
廚師就記錄下他照着食譜做到哪兒了(儲存程序的目前狀态)，然後拿出一本急救手冊，
按照其中的訓示處理蟄傷。這裡，我們看到處理機從一個程序(做蛋糕)切換到另一個
高優先級的程序(實施醫療救治)，每個程序擁有各自的程式
(食譜和急救手冊)。當蜜蜂蟄傷處理完之後，這位廚師又回來做蛋糕，從他
離開時的那一步繼續做下去。
需要強調的是：同一個程式執行兩次，那也是兩個程序，比如打開暴風影音，
雖然都是同一個軟體，但是一個可以播放nba，一個可以播放cba
三，并發與并行
無論是并行還是并發，在使用者看來都是'同時'運作的，不管是程序還是線程，都隻是一個任務而已，真是幹活的是cpu，cpu來做這些任務，而一個cpu同一時刻隻能執行一個任務
一 并發：是僞并行，即看起來是同時運作。單個cpu+多道技術就可以實作并發
舉例（單核+多道，實作多個程序的并發執行）：
james在一個時間段内有很多任務要做：python備課的任務，寫書的任務，
交女朋友的任務，王者榮耀上分的任務，
但james同一時刻隻能做一個任務（cpu同一時間隻能幹一個活），如何才能玩出多個任務并發執行的效果？
james備一會課，再去跟wade的女朋友聊聊天，再去打一會王者榮耀....這就保證了每個任務都在進行中
二，并行：同時運作，隻有具備多個CPU才能實作并行
單核下，可以利用多道技術，多個核，每個核也都可以利用多道技術（多道技術是針對單核而言的）
有四個核，六個任務，這樣同一時間有四個任務被執行，假設分别被配置設定給了cpu1，cpu2，cpu3，cpu4，
一旦任務1遇到I/O就被迫中斷執行，此時任務5就拿到cpu1的時間片去執行，這就是單核下的多道技術
而一旦任務1的I/O結束了，作業系統會重新調用它(需知程序的排程、配置設定給哪個cpu運作，由作業系統說了算)
可能被分 配給四個cpu中的任意一個去執行
并發程式設計之多程式理論
所有現代計算機經常會在同一時間做很多件事，一個使用者的PC（無論是單cpu還是多cpu），都可以同時運作多個任務（一個任務可以了解為一個程序）。
啟動一個程序來殺毒（360軟體）
啟動一個程序來看電影（暴風影音）
啟動一個程序來聊天（騰訊QQ）
所有的這些程序都需被管理，于是一個支援多程序的多道程式系統是至關重要的
多道技術概念回顧：記憶體中同時存入多道（多個）程式，cpu從一個程序快速切換到另外一個，使每個程序各自運作幾十或幾百毫秒，這樣，雖然在某一個瞬間，一個cpu隻能執行一個任務，但在1秒内，cpu卻可以運作多個程序，這就給人産生了并行的錯覺，即僞并發，以此來區分多處理器作業系統的真正硬體并行（多個cpu共享同一個實體記憶體）
四，同步\異步and阻塞\非阻塞
同步：執行一個操作之後，等待結果，然後才繼續執行後續的操作
所謂同步，就是在發出一個功能調用時，在沒有得到結果之前，該調用就不會傳回。
按照這個定義，其實絕大多數函數都是同步調用。但是一般而言，我們在說同步、異
步的時候，特指那些需要其他部件協作或者需要一定時間完成的任務。
舉例：
1. multiprocessing.Pool下的apply
#發起同步調用後，就在原地等着任務結束，根本不考慮任務是在計算還是在io阻塞，
總之就是一股腦地等任務結束
2. concurrent.futures.ProcessPoolExecutor().submit(func,).result()
3. concurrent.futures.ThreadPoolExecutor().submit(func,).result()
異步：執行一個操作，可以去執行其他的操作，然後等待通知再回來執行剛才沒執行完的操作
異步的概念和同步相對。當一個異步功能調用發出後，調用者不能立刻得到結果。當該異
步功能完成後，通過狀态、通知或回調來通知調用者。如果異步功能用狀态來通知，那麼
調用者就需要每隔一定時間檢查一次，效率就很低（有些初學多線程程式設計的人，總喜歡用
一個循環去檢查某個變量的值，這其實是一 種很嚴重的錯誤）。如果是使用通知的方式，
效率則很高，因為異步功能幾乎不需要做額外的操作。至于回調函數，其實和通知沒太多差別。
舉例：
1. multiprocessing.Pool().apply_async()
#發起異步調用後，并不會等待任務結束才傳回，相反，會立即擷取一個臨時結果（并不
是最終的結果，可能是封裝好的一個對象）。
2. concurrent.futures.ProcessPoolExecutor(3).submit(func,)
3. concurrent.futures.ThreadPoolExecutor(3).submit(func,)
阻塞：程序給CPU傳達一個任務之後，一直等待CPU處理完成，然後才執行後面的操作
阻塞調用是指調用結果傳回之前，目前線程會被挂起（如遇到io操作）。函數隻有在得到
結果之後才會将阻塞的線程激活。有人也許會把阻塞調用和同步調用等同起來，實際上他
是不同的。對于同步調用來說，很多時候目前線程還是激活的，隻是從邏輯上目前函數沒
有傳回而已。
舉例：
1. 同步調用：apply一個累計1億次的任務，該調用會一直等待，直到任務傳回結果為止，
但并未阻塞住（即便是被搶走cpu的執行權限，那也是處于就緒态）;
2. 阻塞調用：當socket工作在阻塞模式的時候，如果沒有資料的情況下調用recv函數，
則目前線程就會被挂起，直到有資料為止。
非阻塞：程序給CPU傳達任務後，繼續處理後續的操作，隔段時間再來咨詢之前的操作是否完成，這樣的過程其實也叫輪詢。
非阻塞和阻塞的概念相對應，指在不能立刻得到結果之前也會立刻傳回，同時該函數不會阻塞目前線程。
小結
阻塞，多路IO複用都是同步IO，異步必定是非阻塞的，是以不存在異步阻塞和異步非阻塞的說法，真正的異步IO需要CPU的深度參與，換句話說，隻有使用者線程在操作IO的時候根本不去考慮IO的執行，全部都交給CPU去完成，而自己隻等待一個完成信号的時候，才是真正的異步IO，是以，拉一個子線程去輪詢（非阻塞），去死循環，或者使用select，poll，epoll，都不是異步。
1. 同步與異步針對的是函數/任務的調用方式：同步就是當一個程序發起一個函數
（任務）調用的時候，一直等到函數（任務）完成，而程序繼續處于激活狀态。而
異步情況下是當一個程序發起一個函數（任務）調用的時候，不會等函數傳回，而
是繼續往下執行當，函數傳回的時候通過狀态、通知、事件等方式通知程序任務完成。
2. 阻塞與非阻塞針對的是程序或線程：阻塞是當請求不能滿足的時候就将程序挂起，
而非阻塞則不會阻塞目前程序
此處參考：http://www.cnblogs.com/Anker/p/5965654.html
總結
1，異步就是異步
網上有許多IO模型的相關文章，主要涉及四個概念，同步，異步，阻塞和非阻塞，有些文章将這四個進行兩兩組合，于是有了異步阻塞，和異步非阻塞，可以很明确的說，這非常牽強，無論是Unix網絡程式設計一書中提到的IO模型，還是POSIX标準，都沒有提到這兩個概念，異步就是異步，隻有同步時才有阻塞和非阻塞。
2，阻塞和非阻塞
我們說阻塞和非阻塞時，要區分場合範圍，比如Linux中說的非阻塞IO和Java中NIO1.0和非阻塞IO不是相同的概念，從最根本上來說，阻塞就是程序被休息了，CPU處理其他程序了，非阻塞可以了解為：将大得整篇時間的阻塞分成N多的小的阻塞，是以程序不斷地有機會被CPU光顧，理論上可以做點其他事情，但是LINUX非阻塞IO要比阻塞好，單CPU會很大幾率因socket沒資料而空轉，雖然這個程序是爽了，但是從整個機器來說，浪費更大了
3，異步
異步可以說是IO最理想的模型：CPU的原則是：有必要的時候才會參與，既不浪費也不怠慢。
五，程序的建立
但凡是硬體，都需要有作業系統去管理，隻要有作業系統，就有程序的概念，就需要有建立程序的方式，一些作業系統隻為一個應用程式設計，比如微波爐中的控制器，一旦啟動微波爐，所有的程序都已經存在。
而對于通用系統（跑很多應用程式），需要有系統運作過程中建立或撤銷程序的能力，主要分為4種形式建立新的程序
- 系統初始化（檢視程序linux中用ps指令，windows中用任務管理器，前台程序負責與使用者互動，背景運作的程序與使用者無關，運作在背景并且隻在需要時才喚醒的程序，稱為守護程序，如電子郵件、web頁面、新聞、列印）
- 一個程序在運作過程中開啟了子程序（如nginx開啟多程序，os.fork,subprocess.Popen等）
- 使用者的互動式請求，而建立一個新程序（如使用者輕按兩下暴風影音）
- 一個批處理作業的初始化（隻在大型機的批處理系統中應用）
無論哪一種，新程序的建立都是由一個已經存在的程序執行了一個用于建立程序的系統調用而建立的：
- 在UNIX中該系統調用是：fork，fork會建立一個與父程序一模一樣的副本，二者有相同的存儲映像、同樣的環境字元串和同樣的打開檔案（在shell解釋器程序中，執行一個指令就會建立一個子程序）
- 在windows中該系統調用是：CreateProcess，CreateProcess既處理程序的建立，也負責把正确的程式裝入新程序。
關于建立的子程序，UNIX和windows
1.相同的是：程序建立後，父程序和子程序有各自不同的位址空間（多道技術要求實體層面實作程序之間記憶體的隔離），任何一個程序的在其位址空間中的修改都不會影響到另外一個程序。
2.不同的是：在UNIX中，子程序的初始位址空間是父程序的一個副本，提示：子程序和父程序是可以有隻讀的共享記憶體區的。但是對于windows系統來說，從一開始父程序與子程序的位址空間就是不同的。
六，程序的終止
正常退出（自願，如使用者點選互動式頁面的叉号，或程式執行完畢調用發起系統調用正常退出，
在linux中用exit，在windows中用ExitProcess）
出錯退出（自願，python a.py中a.py不存在）
嚴重錯誤（非自願，執行非法指令，如引用不存在的記憶體，1/0等，可以捕捉異常，try...except...）
被其他程序殺死（非自願，如kill -9）
七，程序的層次結構
無論UNIX還是windows，程序隻有一個父程序，不同的是：
- 在UNIX中所有的程序，都是以init程序為根，組成樹形結構。父子程序共同組成一個程序組，這樣，當從鍵盤發出一個信号時，該信号被送給目前與鍵盤相關的程序組中的所有成員。
- 在windows中，沒有程序層次的概念，所有的程序都是地位相同的，唯一類似于程序層次的暗示，是在建立程序時，父程序得到一個特别的令牌（稱為句柄）,該句柄可以用來控制子程序，但是父程序有權把該句柄傳給其他子程序，這樣就沒有層次了。
八，程序的狀态
tail -f access.log |grep '404'
執行程式tail，開啟一個子程序，執行程式grep，開啟另外一個子程序，兩個程序之間基于管道'|'通訊，将tail的結果作為grep的輸入。
程序grep在等待輸入（即I/O）時的狀态稱為阻塞，此時grep指令都無法運作
其實在兩種情況下會導緻一個程序在邏輯上不能運作，
- 程序挂起是自身原因，遇到I/O阻塞，便要讓出CPU讓其他程序去執行，這樣保證CPU一直在工作
- 與程序無關，是作業系統層面，可能會因為一個程序占用時間過多，或者優先級等原因，而調用其他的程序去使用CPU。
因而一個程序由三種狀态
九，程序并發的實作
程序并發的實作在于，硬體中斷一個正在運作的程序，把此時程序運作的所有狀态儲存下來，為此，作業系統維護一張表格，即程序表（process table），每個程序占用一個程序表項（這些表項也稱為程序控制塊）
該表存放了程序狀态的重要資訊：程式計數器、堆棧指針、記憶體配置設定狀況、所有打開檔案的狀态、帳号和排程資訊，以及其他在程序由運作态轉為就緒态或阻塞态時，必須儲存的資訊，進而保證該程序在再次啟動時，就像從未被中斷過一樣。
十，生産者消費者模型介紹
1，為什麼要使用生産者消費者模型
生産者指的是生産資料的任務，消費者指的是處理資料的任務，在并發程式設計中，如
果生産者處理速度很快，而消費者處理速度很慢，那麼生産者就必須等待消費者處理
完，才能繼續生産資料。同樣的道理，如果消費者的處理能力大于生産者，那麼消費
者就必須等待生産者。為了解決這個問題于是引入了生産者和消費者模式。
2，什麼是生産者消費者模型
生産者消費者模式是通過一個容器來解決生産者和消費者的強耦合問題。生産者和
消費者彼此之間不直接通訊，而通過阻塞隊列來進行通訊，是以生産者生産完資料之
後不用等待消費者處理，直接扔給阻塞隊列，消費者不找生産者要資料，而是直接從
阻塞隊列裡取，阻塞隊列就相當于一個緩沖區，平衡了生産者和消費者的處理能力。
這個阻塞隊列就是用來給生産者和消費者解耦的
3，生産者消費者模型實作
基于隊列來實作一個生産者消費者模型
from multiprocessing import Process,Queue
import time,random,os
def consumer(q,name):
while True:
res=q.get()
time.sleep(random.randint(1,3))
print('\033[43m%s 吃 %s\033[0m' %(name,res))
def producer(q,name,food):
for i in range(3):
time.sleep(random.randint(1,3))
res='%s%s' %(food,i)
q.put(res)
print('\033[45m%s 生産了 %s\033[0m' %(name,res))
if __name__ == '__main__':
q=Queue()
#生産者們:即廚師們
p1=Process(target=producer,args=(q,'cook','包子'))
#消費者們:即吃貨們
c1=Process(target=consumer,args=(q,'consumer'))
#開始
p1.start()
c1.start()
print('主')
執行結果：
主
cook生産了 包子0
cook 生産了 包子1
consumer吃 包子0
consumer 吃 包子1
cook 生産了 包子2
consumer 吃 包子2
此時的問題是主程序永遠不會結束，原因是：生産者p在生産完後就結束了，但是消費者c在取空了q之後，則一直處于死循環中且卡在q.get()這一步。
解決方式無非是讓生産者在生産完畢後，往隊列中再發一個結束信号，這樣消費者在接收到結束信号後就可以break出死循環
from multiprocessing import Process,Queue
import time,random,os
def consumer(q,name):
while True:
res=q.get()
if res is None:break
time.sleep(random.randint(1,3))
print('\033[43m%s 吃 %s\033[0m' %(name,res))
def producer(q,name,food):
for i in range(3):
time.sleep(random.randint(1,3))
res='%s%s' %(food,i)
q.put(res)
print('\033[45m%s 生産了 %s\033[0m' %(name,res))
if __name__ == '__main__':
q=Queue()
#生産者們:即廚師們
p1=Process(target=producer,args=(q,'cook','包子'))
#消費者們:即吃貨們
c1=Process(target=consumer,args=(q,'consumer'))
#開始
p1.start()
c1.start()
p1.join()
q.put(None)
print('主')
但上述解決方式，在有多個生産者和多個消費者時，我們則需要用一個很low的方式去解決,有幾個消費者就需要發送幾次結束信号：相當low,例如
from multiprocessing import Process,Queue
import time,random,os
def consumer(q,name):
while True:
res=q.get()
if res is None:break
time.sleep(random.randint(1,3))
print('\033[43m%s 吃 %s\033[0m' %(name,res))
def producer(q,name,food):
for i in range(3):
time.sleep(random.randint(1,3))
res='%s%s' %(food,i)
q.put(res)
print('\033[45m%s 生産了 %s\033[0m' %(name,res))
if __name__ == '__main__':
q=Queue()
#生産者們:即廚師們
p1=Process(target=producer,args=(q,'cook1','包子'))
p2=Process(target=producer,args=(q,'cook2','骨頭'))
p3=Process(target=producer,args=(q,'cook3','泔水'))
#消費者們:即吃貨們
c1=Process(target=consumer,args=(q,'consumer1'))
c2=Process(target=consumer,args=(q,'consumer2'))
#開始
p1.start()
p2.start()
p3.start()
c1.start()
c2.start()
p1.join()
p2.join()
p3.join()
q.put(None)
q.put(None)
q.put(None)
print('主')
其實我們的思路無非是發送結束信号而已，有另外一種隊列提供了這種機制
JoinableQueue([maxsize])
這就像是一個Queue對象，但隊列允許項目的使用者通知生成者項目已經被成功處理。
通知程序是使用共享的信号和條件變量來實作的。
參數介紹
maxsize是隊列中允許最大項數，省略則無大小限制。
方法介紹
JoinableQueue的執行個體p除了與Queue對象相同的方法之外還具有：
q.task_done()：使用者使用此方法發出信号，表示q.get()的傳回項目已經被處理。
如果調用此方法的次數大于從隊列中删除項目的數量，将引發ValueError異常
q.join():生産者調用此方法進行阻塞，直到隊列中所有的項目均被處理。阻塞将持
續到隊列中的每個項目均調用q.task_done（）方法為止
基于JoinableQueue實作生産者消費者模型
from multiprocessing import Process,JoinableQueue
import time,random,os
def consumer(q,name):
while True:
res=q.get()
time.sleep(random.randint(1,3))
print('\033[43m%s 吃 %s\033[0m' %(name,res))
q.task_done() #發送信号給q.join()，說明已經從隊列中取走一個資料并處理完畢了
def producer(q,name,food):
for i in range(3):
time.sleep(random.randint(1,3))
res='%s%s' %(food,i)
q.put(res)
print('\033[45m%s 生産了 %s\033[0m' %(name,res))
q.join() #等到消費者把自己放入隊列中的所有的資料都取走之後，生産者才結束
if __name__ == '__main__':
q=JoinableQueue() #使用JoinableQueue()
#生産者們:即廚師們
p1=Process(target=producer,args=(q,'cook1','包子'))
p2=Process(target=producer,args=(q,'cook2','骨頭'))
p3=Process(target=producer,args=(q,'cook3','泔水'))
#消費者們:即吃貨們
c1=Process(target=consumer,args=(q,'consumer1'))
c2=Process(target=consumer,args=(q,'consumer2'))
c1.daemon=True
c2.daemon=True
#開始
p1.start()
p2.start()
p3.start()
c1.start()
c2.start()
p1.join()
p2.join()
p3.join()
#1、主程序等生産者p1、p2、p3結束
#2、而p1、p2、p3是在消費者把所有資料都取幹淨之後才會結束
#3、是以一旦p1、p2、p3結束了，證明消費者也沒必要存在了，應該随着主程序一塊死掉，因而需要将生産者們設定成守護程序
print('主')
4，生産者消費者模型總結
4.1，程式中有兩類角色
一類負責生産資料（生産者）
一類負責處理資料（消費者）
4.2，引入生産者消費者模型為了解決的問題是
平衡生産者與消費者之間的速度差
程式解開耦合
4.3，如何實作生産者消費者模型
生産者<--->隊列<--->消費者
不經一番徹骨寒 怎得梅花撲鼻香