Pythonio阻塞

『壹』 一篇文章帶你深度解析python線程和進程

使用Python中的線程模塊，能夠同時運行程序的不同部分，並簡化設計。如果你已經入門Python，並且想用線程來提升程序運行速度的話，希望這篇教程會對你有所幫助。

線程與進程

什麼是進程

進程是系統進行資源分配和調度的一個獨立單位 進程是具有一定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位。每個進程都有自己的獨立內存空間，不同進程通過進程間通信來通信。由於進程比較重量，占據獨立的內存，所以上下文進程間的切換開銷（棧、寄存器、虛擬內存、文件句柄等）比較大，但相對比較穩定安全。

什麼是線程

CPU調度和分派的基本單位 線程是進程的一個實體，是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。線程間通信主要通過共享內存，上下文切換很快，資源開銷較少，但相比進程不夠穩定容易丟失數據。

進程與線程的關系圖

線程與進程的區別：

進程

現實生活中，有很多的場景中的事情是同時進行的，比如開車的時候 手和腳共同來駕駛 汽車 ，比如唱歌跳舞也是同時進行的，再比如邊吃飯邊打電話；試想如果我們吃飯的時候有一個領導來電，我們肯定是立刻就接聽了。但是如果你吃完飯再接聽或者回電話，很可能會被開除。

注意：

多任務的概念

什麼叫 多任務 呢？簡單地說，就是操作系統可以同時運行多個任務。打個比方，你一邊在用瀏覽器上網，一邊在聽MP3，一邊在用Word趕作業，這就是多任務，至少同時有3個任務正在運行。還有很多任務悄悄地在後台同時運行著，只是桌面上沒有顯示而已。

現在，多核CPU已經非常普及了，但是，即使過去的單核CPU，也可以執行多任務。由於CPU執行代碼都是順序執行的，那麼，單核CPU是怎麼執行多任務的呢？

答案就是操作系統輪流讓各個任務交替執行，任務1執行0.01秒，切換到任務2，任務2執行0.01秒，再切換到任務3，執行0.01秒，這樣反復執行下去。表面上看，每個任務都是交替執行的，但是，由於CPU的執行速度實在是太快了，我們感覺就像所有任務都在同時執行一樣。

真正的並行執行多任務只能在多核CPU上實現，但是，由於任務數量遠遠多於CPU的核心數量，所以，操作系統也會自動把很多任務輪流調度到每個核心上執行。 其實就是CPU執行速度太快啦！以至於我們感受不到在輪流調度。

並行與並發

並行（Parallelism）

並行：指兩個或兩個以上事件（或線程）在同一時刻發生，是真正意義上的不同事件或線程在同一時刻，在不同CPU資源呢上（多核），同時執行。

特點

並發（Concurrency）

指一個物理CPU(也可以多個物理CPU) 在若幹道程序（或線程）之間多路復用，並發性是對有限物理資源強制行使多用戶共享以提高效率。

特點

multiprocess.Process模塊

process模塊是一個創建進程的模塊，藉助這個模塊，就可以完成進程的創建。

語法：Process([group [, target [, name [, args [, kwargs]]]]])

由該類實例化得到的對象，表示一個子進程中的任務（尚未啟動）。

注意：1. 必須使用關鍵字方式來指定參數；2. args指定的為傳給target函數的位置參數，是一個元祖形式，必須有逗號。

參數介紹：

group：參數未使用，默認值為None。

target：表示調用對象，即子進程要執行的任務。

args：表示調用的位置參數元祖。

kwargs：表示調用對象的字典。如kwargs = {'name':Jack, 'age':18}。

name：子進程名稱。

代碼：

除了上面這些開啟進程的方法之外，還有一種以繼承Process的方式開啟進程的方式：

通過上面的研究，我們千方百計實現了程序的非同步，讓多個任務可以同時在幾個進程中並發處理，他們之間的運行沒有順序，一旦開啟也不受我們控制。盡管並發編程讓我們能更加充分的利用IO資源，但是也給我們帶來了新的問題。

當多個進程使用同一份數據資源的時候，就會引發數據安全或順序混亂問題，我們可以考慮加鎖，我們以模擬搶票為例，來看看數據安全的重要性。

加鎖可以保證多個進程修改同一塊數據時，同一時間只能有一個任務可以進行修改，即串列的修改。加鎖犧牲了速度，但是卻保證了數據的安全。

因此我們最好找尋一種解決方案能夠兼顧：1、效率高（多個進程共享一塊內存的數據）2、幫我們處理好鎖問題。

mutiprocessing模塊為我們提供的基於消息的IPC通信機制：隊列和管道。隊列和管道都是將數據存放於內存中 隊列又是基於（管道+鎖）實現的，可以讓我們從復雜的鎖問題中解脫出來， 我們應該盡量避免使用共享數據，盡可能使用消息傳遞和隊列，避免處理復雜的同步和鎖問題，而且在進程數目增多時，往往可以獲得更好的可獲展性（ 後續擴展該內容 ）。

線程

Python的threading模塊

Python 供了幾個用於多線程編程的模塊，包括 thread, threading 和 Queue 等。thread 和 threading 模塊允許程序員創建和管理線程。thread 模塊 供了基本的線程和鎖的支持，而 threading 供了更高級別，功能更強的線程管理的功能。Queue 模塊允許用戶創建一個可以用於多個線程之間 共享數據的隊列數據結構。

python創建和執行線程

創建線程代碼

1. 創建方法一:

2. 創建方法二:

進程和線程都是實現多任務的一種方式，例如：在同一台計算機上能同時運行多個QQ（進程),一個QQ可以打開多個聊天窗口（線程）。資源共享：進程不能共享資源，而線程共享所在進程的地址空間和其他資源，同時，線程有自己的棧和棧指針。所以在一個進程內的所有線程共享全局變數，但多線程對全局變數的更改會導致變數值得混亂。

代碼演示:

得到的結果是：

首先需要明確的一點是GIL並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標准，但是可以用不同的編譯器來編譯成可執行代碼。同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行（其中的JPython就沒有GIL）。

那麼CPython實現中的GIL又是什麼呢？GIL全稱Global Interpreter Lock為了避免誤導，我們還是來看一下官方給出的解釋：

主要意思為:

因此，解釋器實際上被一個全局解釋器鎖保護著，它確保任何時候都只有一個Python線程執行。在多線程環境中，Python 虛擬機按以下方式執行:

由於GIL的存在，Python的多線程不能稱之為嚴格的多線程。因為 多線程下每個線程在執行的過程中都需要先獲取GIL，保證同一時刻只有一個線程在運行。

由於GIL的存在，即使是多線程，事實上同一時刻只能保證一個線程在運行， 既然這樣多線程的運行效率不就和單線程一樣了嗎，那為什麼還要使用多線程呢？

由於以前的電腦基本都是單核CPU，多線程和單線程幾乎看不出差別，可是由於計算機的迅速發展，現在的電腦幾乎都是多核CPU了，最少也是兩個核心數的，這時差別就出來了：通過之前的案例我們已經知道，即使在多核CPU中，多線程同一時刻也只有一個線程在運行，這樣不僅不能利用多核CPU的優勢，反而由於每個線程在多個CPU上是交替執行的，導致在不同CPU上切換時造成資源的浪費，反而會更慢。即原因是一個進程只存在一把gil鎖，當在執行多個線程時，內部會爭搶gil鎖，這會造成當某一個線程沒有搶到鎖的時候會讓cpu等待，進而不能合理利用多核cpu資源。

但是在使用多線程抓取網頁內容時，遇到IO阻塞時，正在執行的線程會暫時釋放GIL鎖，這時其它線程會利用這個空隙時間，執行自己的代碼，因此多線程抓取比單線程抓取性能要好，所以我們還是要使用多線程的。

GIL對多線程Python程序的影響

程序的性能受到計算密集型(CPU)的程序限制和I/O密集型的程序限制影響,那什麼是計算密集型和I/O密集型程序呢?

計算密集型：要進行大量的數值計算，例如進行上億的數字計算、計算圓周率、對視頻進行高清解碼等等。這種計算密集型任務雖然也可以用多任務完成，但是花費的主要時間在任務切換的時間，此時CPU執行任務的效率比較低。

IO密集型：涉及到網路請求(time.sleep())、磁碟IO的任務都是IO密集型任務，這類任務的特點是CPU消耗很少，任務的大部分時間都在等待IO操作完成（因為IO的速度遠遠低於CPU和內存的速度）。對於IO密集型任務，任務越多，CPU效率越高，但也有一個限度。

當然為了避免GIL對我們程序產生影響，我們也可以使用，線程鎖。

Lock&RLock

常用的資源共享鎖機制：有Lock、RLock、Semphore、Condition等，簡單給大家分享下Lock和RLock。

Lock

特點就是執行速度慢，但是保證了數據的安全性

RLock

使用鎖代碼操作不當就會產生死鎖的情況。

什麼是死鎖

死鎖：當線程A持有獨占鎖a，並嘗試去獲取獨占鎖b的同時，線程B持有獨占鎖b，並嘗試獲取獨占鎖a的情況下，就會發生AB兩個線程由於互相持有對方需要的鎖，而發生的阻塞現象，我們稱為死鎖。即死鎖是指多個進程因競爭資源而造成的一種僵局，若無外力作用，這些進程都將無法向前推進。

所以，在系統設計、進程調度等方面注意如何不讓這四個必要條件成立，如何確定資源的合理分配演算法，避免進程永久占據系統資源。

死鎖代碼

python線程間通信

如果各個線程之間各干各的，確實不需要通信，這樣的代碼也十分的簡單。但這一般是不可能的，至少線程要和主線程進行通信，不然計算結果等內容無法取回。而實際情況中要復雜的多，多個線程間需要交換數據，才能得到正確的執行結果。

python中Queue是消息隊列，提供線程間通信機制，python3中重名為為queue，queue模塊塊下提供了幾個阻塞隊列，這些隊列主要用於實現線程通信。

在 queue 模塊下主要提供了三個類，分別代表三種隊列，它們的主要區別就在於進隊列、出隊列的不同。

簡單代碼演示

此時代碼會阻塞，因為queue中內容已滿，此時可以在第四個queue.put('蘋果')後面添加timeout，則成為 queue.put('蘋果'，timeout=1)如果等待1秒鍾仍然是滿的就會拋出異常，可以捕獲異常。

同理如果隊列是空的，無法獲取到內容默認也會阻塞，如果不阻塞可以使用queue.get_nowait()。

在掌握了 Queue 阻塞隊列的特性之後，在下面程序中就可以利用 Queue 來實現線程通信了。

下面演示一個生產者和一個消費者，當然都可以多個

使用queue模塊，可在線程間進行通信，並保證了線程安全。

協程

協程，又稱微線程，纖程。英文名Coroutine。

協程是python個中另外一種實現多任務的方式，只不過比線程更小佔用更小執行單元（理解為需要的資源）。為啥說它是一個執行單元，因為它自帶CPU上下文。這樣只要在合適的時機， 我們可以把一個協程 切換到另一個協程。只要這個過程中保存或恢復 CPU上下文那麼程序還是可以運行的。

通俗的理解：在一個線程中的某個函數，可以在任何地方保存當前函數的一些臨時變數等信息，然後切換到另外一個函數中執行，注意不是通過調用函數的方式做到的，並且切換的次數以及什麼時候再切換到原來的函數都由開發者自己確定。

在實現多任務時，線程切換從系統層面遠不止保存和恢復 CPU上下文這么簡單。操作系統為了程序運行的高效性每個線程都有自己緩存Cache等等數據，操作系統還會幫你做這些數據的恢復操作。所以線程的切換非常耗性能。但是協程的切換只是單純的操作CPU的上下文，所以一秒鍾切換個上百萬次系統都抗的住。

greenlet與gevent

為了更好使用協程來完成多任務，除了使用原生的yield完成模擬協程的工作，其實python還有的greenlet模塊和gevent模塊，使實現協程變的更加簡單高效。

greenlet雖說實現了協程，但需要我們手工切換，太麻煩了，gevent是比greenlet更強大的並且能夠自動切換任務的模塊。

其原理是當一個greenlet遇到IO(指的是input output 輸入輸出，比如網路、文件操作等)操作時，比如訪問網路，就自動切換到其他的greenlet，等到IO操作完成，再在適當的時候切換回來繼續執行。

模擬耗時操作：

如果有耗時操作也可以換成，gevent中自己實現的模塊，這時候就需要打補丁了。

使用協程完成一個簡單的二手房信息的爬蟲代碼吧！

以下文章來源於Python專欄 ，作者宋宋

文章鏈接：https://mp.weixin.qq.com/s/2r3_ipU3HjdA5VnqSHjUnQ

『貳』 python多線程能提高效率嗎

很多爬蟲工作者都遇到過抓取速度非常慢，現在的大多數網站都具備了反爬蟲技術，對IP的訪問頻率限制很嚴格。如果想提升爬蟲的速度，大家可以嘗試以下方法。

一、盡量減少訪問次數。
單次爬蟲任務的大多耗時在網路請求等待響應，所以能減少網路請求就盡量減少請求，這樣既能減少目標網站的壓力，也能減少代理伺服器的壓力，提高工作效率。

二、精簡流程，減少重復。
大部分網站並不是嚴格意義上的樹狀結構，而是多重交叉的網狀結構，所以從多個入口深入的網頁會有很多重復，一般根據URL或者ID進行唯一性判別，爬過的就不需要再爬。一些數據如果可以在一個頁面內獲取到，也可以在多個頁面下獲取到，那就選擇只在一個頁面內獲取。

三、多線程任務。
大量爬蟲是一個IO阻塞的任務，所以採用多線程的並發方式可以有效地提高整體速度。多線程可以更好地提高資源利用率，程序設計也更加堅定，程序響應也更快。

四、分布式任務。
上面三點都做到極致了，但是單機單位時間內能爬取到的網頁數量還不足以達到目標，在指定時間內還不能及時的完成任務，那麼就只能多機器來同時進行爬蟲任務了，這就是分布式爬蟲。

做好以上幾點，基本可以將爬蟲的效率提升大半，另外爬蟲代理ip也是不可缺少的尤其是對於量大的任務，IPIDEA提供全球ip的同時更注重保護數據的安全，也可以減少反爬蟲策略的觸發，一舉多得。

『叄』 如何用python開發移動App後台

用python開發移動App後台

可以做 "AIR" 應用.

用Python寫服務 端即可

『肆』 Python中級精華-並發之啟動和停止線程

為了讓代碼能夠並發執行，向創建線程並在核實的時候銷毀它。

由於目的比較單純，只是講解基礎的線程創建方法，所以可以直接使用threading庫中的Thread類來實例化一個線程對象。

例子，用戶輸入兩個數字，並且求其兩個數字的四則運算的結果：

除了以上的一些功能以外，在python線程

中沒有其他的諸如給線程發信號、設置線程調度屬性、執行任何其他高級操作的功能了，如果需要這些功能，就需要手工編寫了。

另外，需要注意的是，由於GIL（全局解釋器鎖喊慶虛）的存在，限制了在python解釋器當中只允許運行一個線程。基於這個原因，不停該使用python線程來處理計算密集型的任務，因為在這種任務重我們希望在多個CPU核心上實現並行處理。Python線程更適合於IO處理以及設計阻塞操作的並發執行任務（即等待IO響應或等待資料庫取出結果等）。

如何判斷線程是否已經啟動？

目的：我們載入了差行一個線程，但是想要知道這個線程什麼時候才會開始運行？

方法：

線程的核心特徵我認為就是不確定性鄭燃，因為其什麼時候開始運行，什麼時候被打斷，什麼時候恢復執行，這不是程序員能夠控制的，而是有系統調度

來完成的。如果遇到像某個線程的運行依託於其他某個線程運行到某個狀態時該線程才能開始運行，那麼這就是線程同步

問題，同樣這個問題非常棘手。要解決這類問題我們要藉助threading中的Event對象。

Event其實和條件標記類似，勻速線程

等待某個時間發生。初始狀態時事件被設置成0。如果事件沒有被設置而線程正在等待該事件，那麼線程就會被阻塞，直到事件被設置位置，當有線程設置了這個事件之後，那麼就會喚醒正在等待事件的線程，如果線程等待的事件已經設置了，那麼線程會繼續執行。

一個例子：

如上能夠確定的是，主線程會在線程t運行結束時再運行。

『伍』 Python 多線程效率不高嗎

Python效率到底高不高？到底是不是雞肋？Python由於有全鎖局的存在（同一時間只能有一個線程執行），並不能利用多核優勢。所以，如果你的多線程進程是CPU密集型的，那多線程並不能帶來效率上的提升，相反還可能會因為線程的頻繁切換，導致效率下降；如果是IO密集型，多線程進程可以利用IO阻塞等待時的空閑時間執行其他線程，提升效率。

雖然CPython的線程庫直接封裝了系統的原生線程，但CPython整體作為一個進程，同一時間只會有一個獲得GIL的線程在跑，其他線程則處於等待狀態。這就造成了即使在多核CPU中，多線程也只是做著分時切換而已。

『陸』 Python基礎之:Python中的IO

IO就是輸入和輸出，任何一個程序如果和外部希望有交互的話，都需要使用到IO。相對於java而言，Python中的IO更加的簡單，易用。
本文將會詳細介紹Python中的IO操作。

linux中有三種標准輸入輸出，分別是STDIN，STDOUT，

STDERR，對應的數字是0，1，2。

STDIN是標准輸入，默認從鍵盤讀取信息；

STDOUT是標准輸出，默認將輸出結果輸出至終端；

STDERR是標准錯誤，默認將輸出結果輸出至終端。

我們常用的 2>&1，指將標准輸出、標准錯誤指定為同一輸出路徑 。

python中，我們可以使用print方法來輸出信息。\

我們看下print函數的定義：

print函數將 objects 列印到 file 指定的文本流，以 sep 分隔並在末尾加上 end。 sep, end, file 和 flush 如果存在，那麼必須以關鍵字參數的形式給出。

所有非關鍵字參數都會被轉換為字元串，並會被寫入到流，以 sep 分割，並在末尾加上 end。 sep 和 end 都必須為字元串；它們也可以為 None，這意味著使用默認值。 如果沒有給出 objects，則 print() 將只寫入 end。

file 參數必須是一個具有 write(string) 方法的對象；如果參數不存在或為 None，則將使用 sys.stdout。 由於要列印的參數會被轉換為文本字元串，因此 print()不能用於二進制模式的文件對象。 對於這些對象，可以使用 file.write(...)。

輸出是否被緩存通常決定於 file，但如果 flush 關鍵字參數為真值，輸出流會被強制刷新。

可以看到print的輸出格式還是比較簡單的。我們接下來看一下怎麼豐富輸出的格式。

如果想要格式化字元串，可以在字元串的開始引號之前加上 f 或 F。
這樣的話，我們可以直接在字元串中引入變數值，只需要把變數放在 { 和 } 中間即可。

除了在{ }中放入Python變數之外，還可以在其中放入函數：

在 ':' 後傳遞一個整數可以讓該欄位成為最小字元寬度。方便列對齊:

{ }中的變數後面還可以跟著轉值符號：'!a' 表示應用 ascii() ，'!s' 表示應用 str()，還有 '!r' 表示應用 repr()：

除此之外，str本身自帶一個功能強大的format 函數：

調用此方法的字元串可以包含字元串字面值或者以花括弧 {} 括起來的替換域，每個替換域可以包含一個位置參數的數字索引，或者一個關鍵字參數的名稱。 返回的字元串副本中每個替換域都會被替換為對應參數的字元串值。

再看一個使用索引的例子：

看一個關鍵字的例子：

再看一個組合的例子：

還有非常復雜的組合的例子：

或者使用 '**' 符號將 table 作為關鍵字參數傳遞：

還可以使用n類型 '{:n}' 來格式化數字：

如果我們只是想要將Python對象轉換為字元串，那麼可以使用repr()或者str(), str() 函數是用於返回人類可讀的值的表示，而 repr()是用於生成解釋器可讀的表示。
舉個例子：

str對象還提供了一些對字元串進行手動格式化的方法：

字元串對象的 str.rjust()方法通過在左側填充空格來對給定寬度的欄位中的字元串進行右對齊。類似的方法還有 str.ljust()和 str.center()。
如果輸入的字元串太長，它們不會截斷字元串，而是原樣返回。
如果想保證字元串的長度，則可以使用切片： x.ljust(n)[:n] 。
還可以使用str.zfill()來用0填充字元串：

% 也可以用來格式化字元串，給定 'string' % values，則 string 中的 % 實例會以零個或多個 values 元素替換。 此操作通常被稱為字元串插值。

python中文件讀取非常簡單，使用open()方法即可。
open()會返回一個文件對象。我們看一下它的定義：

第一個參數是文件名。
第二個參數是文件打開的模式，可用的模式有：

默認模式為 'r' 。
看一個open文件的例子：

文件打開了，自然需要被關閉，所以我們需要顯示調用 f.close() 方法：

有沒有類似java中的try with resource的自動關閉文件的功能呢？
我們可以使用with，這樣文件在使用完畢之後，會自動被關閉，非常的好用。

文件被關閉之後，如果想要再次讀取，就會報錯：

獲取到文件對象之後，我們就可以調用文件中的方法了。

f.read(size) 會讀取一些數據並將其作為字元串（在文本模式下）或位元組串對象（在二進制模式下）返回。

size 是一個可選的數值參數。 當 size 被省略或者為負數時，將讀取並返回整個文件的內容；當取其他值時，將讀取並返回至多 size 個字元（在文本模式下）或 size 個位元組（在二進制模式下）。 如果已到達文件末尾，f.read() 將返回一個空字元串 ('')。

f.readline() 從文件中讀取一行；換行符（\n）留在字元串的末尾，如果文件不以換行符結尾，則在文件的最後一行省略。如果 f.readline() 返回一個空的字元串，則表示已經到達了文件末尾，而空行使用 '\n' 表示，該字元串只包含一個換行符。

還有一種更加簡單的讀取方法，就是從文件中遍歷：

如果你想以列表的形式讀取文件中的所有行，你也可以使用 list(f) 或 f.readlines()。
f.write(string) 會把 string 的內容寫入到文件中，並返回寫入的字元數。

如果是在文本模式下，那麼在寫入文件之前，需要把對象轉換成為文本形式，我們可以使用str()來進行轉換。

使用f.seek(offset, whence)可以定位文件指針的位置，然後後續會從該位置開始進行讀取操作。

whence 的 0 值表示從文件開頭起算，1 表示使用當前文件位置，2 表示使用文件末尾作為參考點。 whence 如果省略則默認值為 0，即使用文件開頭作為參考點。

JSON是一個很方便進行信息交流的文件格式。我們看下怎麼使用JSON來將對象轉換為字元串：

mps是將對象轉換為json str。 json還有一個mp方法，可以直接將對象存入到文件中。

要從文件中解析出json字元串，可以使用load：

JSON 中的鍵-值對中的鍵永遠是 str類型的。當一個對象被轉化為 JSON 時，字典中所有的鍵都會被強制轉換為字元串。這所造成的結果是字典被轉換為 JSON 然後轉換回字典時可能和原來的不相等。換句話說，如果 x 具有非字元串的鍵，則有 loads(mps(x)) != x。

『柒』 python同時打開幾個程序默認運行哪一個

操作系統的作用
隱藏醜陋復雜的硬體介面，提供良好的抽象介面
管理、調度進程，並且將多個進程對硬體的競爭變得有序
2. 多道技術產生背景

針對單核，實現並發
現在的主機一般是多核，那麼每個核都會利用多道技術
有 4 個 cpu，運行於 cpu1 的某個程序遇到 io 阻塞，會等到 io 結束再重新調度
會被調度到 4 個 cpu 中的任意一個，具體由操作系統調度演算法決定
3. 多道技術空間上的復用：如內存中同時有多道程序

4. 多道技術時間上的復用

復用一個 cpu 的時間片
注意，遇到 io 切，佔用 cpu 時間過長也切
核心在於切之前將進程的狀態保存下來
這樣才能保證下次切換回來時，能基於上次切走的位置繼續運行
進程的概念
進程是一個具有一定獨立功能的程序關於某個數據集合的一次運行活動
進程是操作系統動態執行的基本單元
在傳統的操作系統中，進程既是基本的分配單元，也是基本的執行單元
進程與程序的區別
程序是指令和數據的有序集合，是一個靜態的概念。程序可以作為一種軟體資料長期存在，是永久的
進程是程序在處理機上的一次執行過程,它是一個動態的概念。進程是有一定生命期的，是暫時的
5. 注意：同一個程序執行兩次，就會在操作系統中出現兩個進程。所以可以同時運行一個軟體，分別做不同的事情也不會混亂，比如可以打開兩個Pycharm做不同的事

6. 進程調度

要想多個進程交替運行，操作系統必須對這些進程進行調度
這個調度也不是隨即進行的，而是需要遵循一定的法則
由此就有了進程的調度演算法：先來先服務調度演算法、短作業優先調度演算法、時間片輪轉法、多級反饋隊列
並行和並發
並行是指在一個時間點上，有多個進程在被 cpu 計算，比如賽跑，兩個人都在不停的往前跑
並發是指資源有限的情況下，在一個時間段上，有多個進程在被 cpu 計算，交替輪流使用資源
並行與並發的區別
並行是從微觀上，也就是在一個精確的時間片刻，有不同的程序在執行，這就要求必須有多個處理器
並發是從宏觀上，在一個時間段上可以看出是同時執行的，比如一個伺服器同時處理多個 session
進程的三狀態
在程序運行的過程中，由於被操作系統的調度演算法控制，程序會進入幾個狀態
就緒
運行
阻塞
2. 舉例說明什麼是 argv，什麼是阻塞

import sys
print(sys.argv)

# 運行結果：
['G:/course_select/進程的概念.py']

# argv 指參數
# sys.argv 是 Python 解釋器在運行的時候傳遞進來的參數

# 首先在cmd輸入以下信息：
python G:/course_select/進程的概念.py
# 列印結果：
['G:/course_select/進程的概念.py']

# 然後在cmd中切換路徑到G盤，接著輸入 python course_select/進程的概念.py
# 列印結果：
['course_select/進程的概念.py']

# 接著，再在cmd中輸入：python course_select/進程的概念.py 123 abc
# 列印結果：
['course_select/進程的概念.py', '123', 'abc']

# 因此，以下程序不能在編輯器里運行，只能在 cmd 裡面使用 Python 運行本文件
# 然後要在後面加上 aaa bbb
# 就像上面的 python course_select/進程的概念.py 123 abc 一樣
if sys.argv[1] == "aaa" and sys.argv[2] == "bbb":
print("登錄成功")
else:
print("登錄失敗")
exit()
print(666)

# 而如果使用input(),其實就是一種阻塞
3. 進程的三狀態圖

.png
同步非同步
同步：形象的說，一件事的執行必須依賴另一件事的結束，強調的是順序性
非同步： 形象的說，兩件事情可以同時進行
注意：同步非同步和並行、並發沒關系
阻塞：等待，比如 input sleep recv accept recvfrom
非阻塞：不等待，start/terminate 都是非阻塞的
阻塞與非阻塞主要是從程序（線程）等待消息通知時的狀態角度來說的
可以分為四類：
同步阻塞
非同步阻塞
同步非阻塞
非同步非阻塞
start/terminate 都是非阻塞的
進程模塊
跟進程相關的基本都在這個模塊里：multiprocessing
父進程與子進程的對比分析
父進程，比如運行本文件
子進程，運行 Process(target=func).start()
父進程與子進程數據隔離
主進程等待子進程結束之後再結束
子進程和主進程之間默認是非同步的
from multiprocessing import Process
import time

def func():
time.sleep(1)
print(666)

if __name__ == "__main__":
# 開啟了一個新的進程，在這個新的進程里執行的 func()
Process(target=func).start()
time.sleep(1)
# 主進程
print(777)

# 777
# 666
# 運行結果仔細觀察發現有非同步的效果
# 也就是說，主進程和新的進程同時執行
3. 上面的示例中為什麼要有 if __name__ == "__main__"？其實這是 windows 操作系統開啟子進程的方式問題

4. 繼續深入

import time
import os
from multiprocessing import Process

def func():
time.sleep(1)
print(666, os.getpid(), os.getppid())

if __name__ == "__main__":
# 代碼執行到這里並不代表開啟了子進程
p = Process(target=func)
# 開啟了一個子進程，並執行func()
p.start()
time.sleep(1)
print(777, os.getpid(), os.getppid())

# 主進程運行的結果
777 12340 1636
# 子進程運行的結果
666 7604 12340

# 由上面兩行結果可以得出：
# 利用 os.getpid() 證明兩個進程不一樣
# 另外每次運行，os.getpid() 結果都不一樣
# 但是，12340 是主進程的 id，7604 是子進程的 id
# 1636 是 Pycharm 的 id，排列特點不變
5. 開啟多個相同的子進程示例

import time
import os
from multiprocessing import Process

def func():
time.sleep(3)
print(666, os.getpid(), os.getppid())

if __name__ == "__main__":
for i in range(10):
p = Process(target=func)
p.start()
time.sleep(1)
print(777, os.getpid(), os.getppid())

# 這里需要注意一點：Python 程序一直都是逐行執行
# 但是因為這里設置了時間延遲，因此會先執行主程序的代碼
# 運行結果：
777 29006 3833 # 暫停 2s 後再有下面的結果
666 29007 29006
666 29009 29006
666 29008 29006
666 29010 29006
666 29013 29006
666 29011 29006
666 29012 29006
666 29014 29006
666 29016 29006
666 29015 29006

# 觀察結果發現主進程只運行了一次
# 然後剩下的全是一個子進程重新運行的結果
# 主進程運行完不會結束，它會等子進程全部運行結束
# 注意變數 p 拿到的是最後一個子進程的 id
6. 開啟多個不同的子進程示例

import time
import os
from multiprocessing import Process

def func():
time.sleep(2)
print(666, os.getpid(), os.getppid())

def func2():
print(111)

if __name__ == "__main__":
for i in range(3):
p = Process(target=func)
p.start()
for i in range(2):
p = Process(target=func2)
p.start()
time.sleep(1)
print(777, os.getpid(), os.getppid())

# 運行程序時仔細觀察結果顯示順序：
111
111
777 29316 3833
666 29319 29316
666 29317 29316
666 29318 29316
7. 給子進程傳參示例

from multiprocessing import Process

def func(name):
print(666, name)

if __name__ == "__main__":
p = Process(target=func,args=(777,)) # 注意是一個元組
p.start()

import time
from multiprocessing import Process

def func(num, name):
time.sleep(1)
print(num, "hello", name)

if __name__ == "__main__":
for i in range(10):
p = Process(target=func, args=(i, "abc"))
p.start()
print("主進程")

# 運行結果：
666 777
主進程
0 hello abc
2 hello abc
1 hello abc
3 hello abc
5 hello abc
4 hello abc
6 hello abc
7 hello abc
8 hello abc
9 hello abc

# 多運行幾次，發現子進程並不是完全按順序運行的
# 比如上面先出結果 2 hello abc，再出結果 1 hello abc
8. 子進程可以有返回值嗎：不能有返回值，因為子進程函數中的返回值無法傳遞給父進程

import time
from multiprocessing import Process

def func():
time.sleep(3)
print("這是子進程,3s後才運行")

if __name__ == "__main__":
Process(target=func).start()
print("主進程")

# 運行結果：
主進程
這是子進程,3s後才運行

# 主進程會默認等待子進程結束之後才結束
# 因為父進程要負責回收子進程佔用的操作系統資源
相關資源：Python多進程寫入同一文件的方法_python多進程寫入同意文件-其它...
文章知識點與官方知識檔案匹配
Python入門技能樹首頁概覽
194693 人正在系統學習中
點擊閱讀全文
打開CSDN，閱讀體驗更佳

Python多進程(一)進程及進程池_程序員-夏天的博客
print("主進程結束") 通過上述代碼我們發現,multiprocessing.Process幫我們創建一個子進程,並且成功運行,但是我們發現,在子進程還沒執行完的時候主進程就已經死了,那麼這個子進程在主進程結束後就是一個孤兒進程,那麼我們可以讓主進程等待...
Python多進程之Process、Pool、Lock、Queue、Event、Semaphore、Pipe_大 ...
1. Python創建進程類Process python的multiprocessing模塊提供了一個創建進程的類Precess,其創建有以下兩種方法: 創建Process類的實例,並指向目標函數和傳遞參數 自定義一個類並繼承Process類,重寫__init__()和run()方法 ...
python兩個進程同時開啟只運行了一個_二十二、 深入Python的進程和線程（上篇）...
「@Author： Runsen」進程(Process)和線程(Thread)都是操作系統中的基本概念，它們之間有一些優劣和差異，那麼在Python中如何使用進程和線程？CPU計算機的核心是CPU，它承擔了計算機的所有計算任務，CPU就像一個工廠，時刻在運行著，而操作系統管理著計算機，負責任務的調度、資源的分配和管理。進程進程是指在系統中能獨立運行並作為資源分配的基本單位，它是由一組機器指令、數據...
繼續訪問
python啟動多個進程_Python多處理：只有一個進程正在運行
由於注釋表明您希望使用初始化程序和initargs參數傳遞featureVector.在Unix類型的系統上,這將導致大量的性能提升(即使selLabel中只有1個項目),因為該值將使用os.fork基本上免費傳遞給子進程.否則,每次調用foo時,featureVector都將被父進程pickle,通過管道傳遞並由子進程進行unpickled.這將花費很長時間,並且基本上將序列化所有子進程,因為它...
繼續訪問
python多進程多線程,多個程序同時運行_陳逸飛_p的博客_pyth...
python 模塊應用 開發工具 pycharm 實現方法 多任務的實現可以用進程和線程來實現 進程—> 線程---> 多任務應用 多進程操作 比如下載多個文件, 利用cpu 資源 提高效率 多任務: 同一時間執行多個任務, 比如windows操作系統 執行...
python多進程單例_Python多線程處理實例詳解【單進程/多進程】
python — 多線程處理 1、一個進程執行完後,繼續下一個進程 root@72132server:~# cd /root/python/multiprocess/ root@72132server:~/python/multiprocess# ls multprocess.py root@72132server:~/python/multiprocess# cat multprocess...
系統編程__2__父子進程的創建和回收
系統編程 這里寫的是對於小白來說更多的了解系統編程的文章，有寫的不對的地方還懇請各位大佬指出錯誤，小編一定會多多採納[手動多謝]。 那麼，上一次我們稍微了解了一下關於系統編程的一些主要內容[沒有看到的童鞋還請去上一篇文章稍微復習一下噢]。 這節課，我們先來想一想，我們為什麼要學系統編程呢？原因很簡單，我們要充分的利用CPU的性能，CPU和我們人類不太一樣，我們人類大多數情況下，在同一時間，只能完成一件事，而CPU作為無數科學家的心血當然不會這么簡單，CPU能夠同時進行多個進程，這里的進程我們可以理解成任務，
繼續訪問
android 10 system/core無法列印log問題
1.關閉重定向 system/core/init/util.cpp --- a/init/util.cpp +++ b/init/util.cpp @@ -454,7 +454,7 @@ static void InitAborter(const char* abort_message) { // SetStdioToDevNull() must be called again in second stage init. void SetStdioToDevNull(char** argv) { ...
繼續訪問
Python多進程1 一個多進程實例_BBJG_001的博客
下執行,job('主進程step1###')p1=mp.Process(target=job,args=('新進程>>>',))# 創建一個進程# 注意當只有一個參數的時候,一定要在參數後面加一個逗號,因為args需要是一個可以迭代的參量p1.start()# 開始執行新進程# p...
熱門推薦 python多進程多線程,多個程序同時運行
python 多線程 多進程同時運行 多任務要求 python 基礎語法 python 文件目錄操作 python 模塊應用 開發工具 pycharm 實現方法 多任務的實現可以用進程和線程來實現 進程—> 線程----> 多任務應用 多進程操作 比如下載多個文件, 利用cpu 資源 提高效率 多任務： 同一時間執行多個任務, 比如windows操作系統 執行方式有兩種( 表現形式 ) 並發 在單核cpu中: 在一段時間內交替執行多個任務, 例如單核cpu 處理多任務, 操作系統讓各個任務交
繼續訪問
fork()函數
多進程通信 fork()函數
繼續訪問
（1/7）Electron教程（一）什麼是 Electron，由來、適用場景 和 Electron 的環境搭建（1/7）
最近自己有個小的需求，是做一個能編輯本地特定文本的工具，需要跨平台， Windows 和 macOS，這樣，如果用原生開發的話，Windows 就要用c#macOS 就要用swift，學習成本高，並且學完用處也不是很大。我本身是前端開發的，發現了這個electron能滿足我的需求，跨平台運行，內部是 js 驅動的，簡直就是如魚得水。順便把學習的經歷寫出來，分享需要的人，我會按標題序號漸進式地編寫內容。electron。...
繼續訪問

fork()詳解
<一>： fork()函數用來創建新的進程，它的特點是調用一次返回兩次( 在原來的進程中返回新進程的 PID（新進程的 PID 肯定不等於 0）， 在新進程中返回為 0.) 函數原型：pid_t fork(void)； pid_t getpid(); 獲取當前進程的 pid 值。 pid_t getppid(); 獲取當前進程的父進程 pid 值。 圖一 如圖一所...
繼續訪問
fork()函數詳解
目錄 1.基本了解： 2.fork函數的了解： 3.僵死進程： 1.基本了解： 一個進程，包括代碼、數據和分配給進程的資源。fork 函數會新生成一個進程，調用 fork 函數的進程為父進程，新生成的進程為子進程。在父進程中返回子進程的 pid，在子進程中返回 0，失敗返回-1。 為什麼兩個進程的fpid不同呢，這與fork函數的特性有關。fork調用的一個奇妙之處就是它僅僅被調用一次，卻能夠返回兩次，它可能有三種不同的返回值： 1）在父進程中，fork返回新創建子進程的進程...
繼續訪問

Electron在Windows下的環境搭建
Electron作為一種用javascript寫桌面程序的開發方式，現在已經被大眾接受。下面就介紹如何在windows（>win7）下快速搭建Electron開發環境。 1. nodejs 的安裝 從nodejs 下載最新版本的windows安裝程序進行安裝，我下載的是v6.9.1，安裝時一路默認即可，這個安裝會把nodejs和npm配置到系統PATH中，這樣在命令行的任何位置都可以直接...
繼續訪問
python多線程pool_Python mutiprocessing多線程池pool操作示例
本文實例講述了Python mutiprocessing多線程池pool操作。分享給大家供大家參考，具體如下：python — mutiprocessing 多線程 pool腳本代碼：root@72132server:~/python/multiprocess# lsmultiprocess_pool.py multprocess.pyroot@72132server:~/python/multi...
繼續訪問
最新發布 python入門開發學習筆記之守護進程
本節重點 了解守護進程的概念 本節時長需控制在5分鍾內 一 守護進程 主進程創建子進程，然後將該進程設置成守護自己的進程，守護進程就好比崇禎皇帝身邊的老太監，崇禎皇帝已死老太監就跟著殉葬了。 關於守護進程需要強調兩點： 其一：守護進程會在主進程代碼執行結束後就終止 其二：守護進程內無法再開啟子進程,否則拋出異常：AssertionError: daemonic processes are not allowed to have children 如果我們有兩個任務需要並發執行，那麼開一個主進程和一個子進程分
繼續訪問
用python進行多進程編程時，只有主進程可以運行，子進程貌似沒有運行是什麼原因？
找了半天，原來是這個原因！這是因為multiprocessing模塊在交互模式是不支持的，在 cmd 里頭輸入 python xxx.py 來運行起來，你就可以看到子進程的執行了。
繼續訪問
linux中fork() 函數詳解
fork入門知識 一個進程，包括代碼、數據和分配給進程的資源。fork（）函數通過系統調用創建一個與原來進程幾乎完全相同的進程，也就是兩個進程可以做完全相同的事，但如果初始參數或者傳入的變數不同，兩個進程也可以做不同的事。 一個進程調用fork（）函數後，系統先給新的進程分配資源，例如存儲數據和代碼的空間。然後把原來的進程的所有值都復制到新的新進程中，只有少數值與原來的進程的值不同。相當於克隆了...
繼續訪問
Windows版 Node.js 安裝詳解以及Electron安裝
Windows Node.js 安裝詳解以及Electron安裝詳解，示例版本：node v10.15.0/npm6.4.1 介紹： 簡單的說 Node.js 就是運行在服務端的 JavaScript。 Node.js 是一個基於Chrome JavaScript 運行時建立的一個平台。 Node.js是一個事件驅動I/O服務端JavaScript環境，基於Google的V8引擎，V8引擎執...
繼續訪問

Electron 簡介
本教程我們來學習 Electron 的基礎知識，下面我們先來學習一下什麼是 Electron。 Electron是什麼 Electron 是是 GitHub 開發的一個開源框架。它允許使用 Node.js（作為後端）和 Chromium（作為前端）完成桌面 GUI 應用程序的開發。 Electron 可以用於構建具有 HTML、CSS、JavaScript 的跨平台桌面應用程序，它通過將 Chromium 和 node.js 合同一個運行的環境中來實現這一點，應用程序可以打包到 Mac、Windows 和
繼續訪問

Election的優缺點
優點 原生的介面（菜單、消息提醒、系統托盤等）。 上手難度低。能夠使用react、vue等前端框架，能方便地遷移前端組件，構建出漂亮的桌面應用。 方便熱更新 調試和測試方便 Electron使用node.js。因此，您可以導入Chrome應用程序中不容易使用的許多模塊 Electron文檔要好得多，盡管它是一個更年輕的平台 缺點 不適合開發輕量級的應用。即使一個electron的項目框架，也包含chromium內核，打包完接近200G。 相比c++開發的桌面應用，性能遠遠不如後者。 啟動速
繼續訪問
[electron]終極奧義 五千字教程丟給你
前言 本文包含打包、自動更新、簡易API、調試、進程通信等相關知識點，內容較多，可能會引起不適，請酌情查看（手動滑稽）。 electron 簡介 electron是由Github開發，是一個用Html、css、JavaScript來構建桌面應用程序的開源庫，可以打包為Mac、Windows、Linux系統下的應用。 electron是一個運行時環境，包含Node和Chromium，可以理解成把we...
繼續訪問
深入理解Java中的wait() 方法
使用場景 當某個線程獲取到鎖後，發現當前還不滿足執行的條件，就可以調用對象鎖的wait方法，進入等待狀態。 直到某個時刻，外在條件滿足了，就可以由其他線程通過調用notify()或者notifyAll()方法，來喚醒此線程。 這篇文章將側重於討論wait()方法對於線程狀態的影響，以及被喚醒後線程的狀態變更。 條件 只有已經獲取鎖的線程，才可以調用鎖的wait方法，否則會拋出異常IllegalMonitorStateException。 比如下面的代碼，A獲得了鎖後，主動調用wait方法釋放鎖和
繼續訪問

用Electron開發桌面應用的避坑指南(文末送書)
送一波高質量Web開發圖書，送5本書籍，隨你挑。抽獎規則見本文最後！抽獎規則見本文最後！抽獎規則見本文最後！如今，Electron 領域發生了重大的變革，Electron 版本更新換代極快...
繼續訪問

python多進程只有一個進程在執行
python兩個進程同時開啟只運行了一個。

『捌』 用python打開文件總是出現IOError怎麼回事

用python打開文件總是出現IOError的原因：

1.python ioerror的出現：打開一個不存在的文件，示例中有意輸入了一個不存在的文件名，並試圖打開它。程序找不到這個文件名所以引發了IOError

」Traceback (most recent call last): File "<stdin>", line 1, in <mole>IOError: [Errno 2] No such file or directory: 'a.txt'「

2.文件寫入時遇到python error錯誤原因。有同學遇到了IOError Errno 0 錯誤的情況，在用a+方式打開文件，之後讀取該文件內容。修改讀取的內容後重新寫入文件，在寫入時程序也遇到了IOError錯誤。這時要注意在讀取文件之後記得要把文件關閉，當你需要寫入文件時，要再將文件以w+方式打開寫入。加深學習Python open()函數文件打開、讀、寫基礎操作，可以減少類似情況發生。

3.當你不能滿足被訪問文件所設置的許可權時，也會引發IO Error錯誤，類似這樣

」IOError: [Errno 13] Permission denied: 'c:/a.txt' python permission denied「

從字面意思來理解就可以知道原因了，是因為我們執行的命令（運行python文件等），沒有許可權，給一個超級管理員許可權就可以了。

『玖』 io.UnsupportedOperation: not readable python編程中老是這情況，，新人求解救

io.UnsupportedOperation: not read()able python編程中老是這情況，是因為這個代碼中有兩處錯誤：

1、你是用open打開豎孝一個文件，此時調用的是w寫入模式，下面使用read是沒有許可權的。

2、使用write寫入一個字元s，但是此時並沒有真正的寫入，而是還存在與內存中。此時執行read讀取的為空字元。需要先執行a.close()關閉文件，再使用a=open("D://2.txt")，最後再用a.read()打開文件讀入。

修改後的代碼：

擴展余扮稿資料：

這個參數的具體說明如下：

1、name : 一個包含了你要訪問的文件名稱的字元串值。

2、mode : mode 決定了打開文件的模式：只讀，寫入，追加等。

3、buffering : 如果 buffering 的值被設為 0，就不會有寄存。如果 buffering 的值取 1，訪問文件時會寄存行。缺晌如果將 buffering 的值設為大於 1 的整數，表明了這就是的寄存區的緩沖大小。

『拾』 python並發編程-Gevent包介紹

Gevent 是一個第三方庫，可以輕鬆通過gevent實現並發同步或中坦舉非同步編程，在gevent中用到的主要模式是Greenlet, 它是以C擴展模塊形式接入Python的輕量級協程。 Greenlet全部運行在主程序操作系統進程的內部，但它們被協作式地調度。信雀

遇到IO阻塞時會自動切換任務

上例gevent.sleep(2)模擬的是gevent可以識別的io阻塞,

而time.sleep(2)或其他的阻塞,gevent是不能直接識別的需要用下面一行代碼,打補丁,就可以識別了

from gevent import monkey;monkey.patch_all()必須放到被打補丁者的前面，如time，socket模塊之前

我們可以用threading.current_thread().getName()來查看每個g1和g2，查看的結果為DummyThread-n，即假賣碧線程

通過gevent實現單線程下的socket並發（from gevent import monkey;monkey.patch_all()一定要放到導入socket模塊之前，否則gevent無法識別socket的阻塞）

服務端

客戶端

多線程並發多個客戶端