python中進程_python中多進程和多線程的區別

A. 一篇文章帶你深度解析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

B. python 守護進程

一、守護進程的特性

守護進程是一個在後台運行並且不受任何終端控制的進程（守護進程獨立於所有終端，之所以脫離於終端是為了避免進程被任何終端所產生的信息所打斷，其在執行過程中的信息也不在任何終端上顯示。）

二、守護進程的作用

守護進程是一類在後台執行，生命周期較長的進程，它一般隨系統啟動運行，在系統關閉的時候停止。所以守護進程一般用作系統後台服務。

三、如何編寫一個守護進程

編寫守護進程實際上是把一個普通進程按照守護進程的特性進行改造。

守護進程的開發涉及到子進程、進程組、會晤期、信號量、文件許可權、目錄和控制終端等多個概念。

由於守護進程是脫離控制終端的，因此首先創建子進程，終止父進程，使得程序在shell終端里造成一個已經運行完畢的假象。之後所有的工作都在子進程中完成，而用戶在shell終端里則可以執行其他的命令，從而使得程序以僵屍進程形式運行，在形式上做到了與控制終端的脫離。

四、python 編寫守護進程

參考： https://cloud.tencent.com/developer/article/1411989

C. python 多進程

基於官方文檔：
https://docs.python.org/zh-cn/3/library/multiprocessing.html
日樂購，剛才看到的一個博客，寫的都不太對，還是基於官方的比較穩妥
我就是喜歡抄官方的，哈哈

通常我們使用Process實例化一個進程，並調用他的 start() 方法啟動它。
這種方法和 Thread 是一樣的。

上圖中，我寫了 p.join() 所以主進程是等待子進程執行完後，才執行 print("運行結束")
否則就是反過來了（這個不一定，看你的語句了，順序其實是隨機的）例如：

主進加個 sleep

所以不加join() ,其實子進程和主進程是各干各的，誰也不等誰。都執行完後，文件運行就結束了

上面我們用了 os.getpid() 和 os.getppid() 獲取當前進程，和父進程的id
下面就講一下，這兩個函數的用法：
os.getpid()
返回當前進程的id
os.getppid()
返回父進程的id。父進程退出後，unix 返回初始化進程（1）中的一個
windows返回相同的id (可能被其他進程使用了)
這也就解釋了，為啥我上面的程序運行多次，第一次列印的parentid 都是 14212 了。
而子進程的父級 process id 是調用他的那個進程的 id ： 1940

視頻筆記：
多進程：使用大致方法：

參考：進程通信（pipe和queue）

pool.map （函數可以有return 也可以共享內存或queue）結果直接是個列表

poll.apply_async() （同map,只不過是一個進程，返回結果用 xx.get() 獲得）

報錯：

參考： https://blog.csdn.net/xiemanR/article/details/71700531

把 pool = Pool() 放到 if name == " main ": 下面初始化搞定。
結果：

這個肯定有解釋的

測試多進程計算效果：
進程池運行：

結果：

普通計算：

我們同樣傳入 1 2 10 三個參數測試：

其實對比下來開始快了一半的；
我們把循環里的數字去掉一個 0；
單進程：

多進程：

兩次測試單進程/進程池分別為 0.669 和 0.772 幾乎成正比的。
問題二：
視圖：
post 視圖裡面

Music 類：

直接報錯：

寫在類裡面也在函數里用 self.pool 調用也不行，也是相同的錯誤。

最後把 pool = Pool 直接寫在 search 函數裡面，奇跡出現了：

前台也能顯示搜索的音樂結果了

總結一點，進程這個東西，最好寫在直接運行的函數裡面，而不是一個函數跳來跳去。因為最後可能是在子進程的子進程運行的，這是不許的，會報錯。
還有一點，多進程運行的函數對象，不能是 lambda 函數。也許lambda 虛擬，在內存？？

使用 pool.map 子進程函數報錯，導致整個 pool 掛了:
參考： https://blog.csdn.net/hedongho/article/details/79139606
主要你要，對函數內部捕獲錯誤，而不能讓異常拋出就可以了。

關於map 傳多個函數參數
我一開始，就是正常思維，多個參數，搞個元祖，讓參數一一對應不就行了：

報錯：

參考：
https://blog.csdn.net/qq_15969343/article/details/84672527
普通的 process 當讓可以穿多個參數，map 卻不知道咋傳的。
apply_async 和map 一樣，不知道咋傳的。

最簡單的方法：
使用 starmap 而不是 map

結果：
子進程結束
1.8399453163146973
成功拿到結果了

關於map 和 starmap 不同的地方看源碼：

關於apply_async() ,我沒找到多參數的方法，大不了用一個迭代的 starmap 實現。哈哈

關於上面源碼裡面有 itertools.starmap
itertools 用法參考：
https://docs.python.org/zh-cn/3/library/itertools.html#itertool-functions

有個問題，多進程最好不要使用全部的 cpu , 因為這樣可能影響其他任務，所以在進程池添加 process 參數指定，cpu 個數：

上面就是預留了一個cpu 干其他事的

後面直接使用 Queue 遇到這個問題：

解決：
Manager().Queue() 代替 Queue()

因為 queue.get() 是堵塞型的，所以可以提前判斷是不是空的，以免堵塞進程。比如下面這樣：
使用 queue.empty() 空為True

D. python中多進程和多線程的區別

什麼是線程、進程?
進程(process)與線程(thread)是操作系統的基本概念，它們比較抽象，不容易掌握。
關於這兩者，最經典的一句話就是「進程是資源分配的最小單位，線程是CPU調度的最小單位」，線程是程序中一個單一的順序控制流程，進程內一個相對獨立的、可調度的執行單元，是系統獨立調度和分配CPU的基本單位指運行中的程序的調度單位，在單個程序中同時運行多個線程完成不同的工作，稱為多線程。
進程與線程的區別是什麼?
進程是資源分配的基本單位，所有與該進程有關的資源，都被記錄在進程式控制制塊PCB中，以表示該進程擁有這些資源或正在使用它們，另外，進程也是搶占處理機的調度單位，它擁有一個完整的虛擬地址空間，當進程發生調度時，不同的進程擁有不同的虛擬地址空間，而同一進程內的不同線程共享同一地址空間。
與進程相對應的，線程與資源分配無關，它屬於某一個進程，並與進程內的其他線程一起共享進程的資源，線程只由相關堆棧(系統棧或用戶棧)寄存器和線程式控制製表TCB組成，寄存器可被用來存儲線程內的局部變數，但不能存儲其他線程的相關變數。
通常在一個進程中可以包含若干個線程，它們可以利用進程所擁有的資源，在引入線程的操作系統中，通常都是把進程作為分配資源的基本單位，而把線程作為獨立運行和獨立調度的基本單位。
由於線程比進程更小，基本上不擁有系統資源，所以對它的調度所付出的開銷就會小得多，能更高效的提高系統內多個程序間並發執行的程度，從而顯著提高系統資源的利用率和吞吐量。
因而近年來推出的通用操作系統都引入了線程，以便進一步提高系統的並發性，並把它視為現代操作系統的一個重要指標。

E. python進程和線程中的join方法

python中創建進程的方式
一、Process（target=函數名，args=（），name,kwargs）
target:加進程調用的函數名，一般不加括弧
name：進程的名字
kwargs：字典參數
args：元組參數，如果參數就一個，記得加逗號』，』

Python多線程與多進程中join()方法的效果是相同的

join所完成的工作就是線程同步，即主線程任務結束之後，進入阻塞狀態，一直等待其他的子線程執行結束之後，主線程再終止
import threading
import time

F. 一文帶你讀懂Python中的進程

進程

進程（Process）是計算機中的程序關於某數據集合上的一次運行，即正在運行的程序，是系統進行資源分配和調度的基本單位，進程是對正在運行程序的一個抽象，在早期面向進程設計的計算機結構中，進程是程序的基本執行實體，在當代面向線程設計的計算機結構中，進程是線程的容器，線程是執行的實體。進程的概念起源於操作系統，是操作系統最核心的概念，操作系統的其他所有內容都是圍繞進程的概念展開的。

在早期計算機中可以利用的cpu只有一個，為了充分利用CPU性能，提高用戶操作體驗，出現了多道技術。將一個單獨的cpu虛擬成多個cpu（多道技術：時間多路復用和空間多路復用+硬體上支持隔離），即使在一個單核CPU也能保證支持（偽）並發的能力。如果沒有進程的抽象，現代計算機將不復存在。

狹義定義：進程是正在運行的程序的實例（an instance of a computer program that is being executed）。

廣義定義：進程是一個具有一定獨立功能的程序關於某個數據集合的一次運行活動。它是操作系統動態執行的基本單元，在傳統的操作系統中，進程既是基本的分配單元，也是基本的執行單元。

操作系統的作用：

隱藏復雜的硬體介面，提供良好的抽象介面。

管理、調度進程，使多個進程對硬體的競爭變得有序。

多道技術：針對早期單核CPU，實現多個程序的並發執行，現在的主機一般是多核，每個核都會利用多道技術，如有4個cpu，運行於cpu1的某個程序遇到io阻塞，會等到io結束再重新調度，重新調度是可能會被調度到4個cpu中的任意一個，具體由操作系統調度演算法決定。

多道技術的主要特性如下：

（1）空間上的復用：內存中可以同時有多道程序。

（2）物理隔離：多個程序在內存中都有各自獨立的內存空間，互不影響。

（3）時間上的復用：多個程序在操作系統的調度演算法下，在不同的時間段內分別佔有CPU資源。

需要注意的是如果一個進程長時間佔用CPU資源，操作系統會強制將CPU資源分配給其它在就緒隊列中的程序，避免一個程序長時間佔有CPU資源，導致其它程序無法運行。

相關推薦：《Python視頻教程》

關於進程的一些概念：

第一，進程是一個實體。每一個進程都有它自己的地址空間，一般情況下，包括文本區域（text region）、數據區域（data region）和堆棧（stack region）。文本區域存儲處理器執行的代碼，數據區域存儲變數和進程執行期間使用的動態分配的內存，堆棧區域存儲著活動過程調用的指令和本地變數。

第二，進程是一個「執行中的程序」。程序是一個沒有生命的實體，只有處理器賦予程序生命時（操作系統將程序載入到內存），它才能成為一個活動的實體，我們稱其為進程。

進程是操作系統中最基本、重要的概念。是多道程序系統出現後，為了刻畫系統內部出現的動態情況，描述系統內部各道程序的活動規律引進的一個概念，所有多道程序設計操作系統都建立在進程的基礎上。

進程的特性：

動態性：進程的實質是程序在多道程序系統中的一次執行過程，進程是動態產生，動態消亡的。

並發性：任何進程都可以同其他進程一起並發執行

獨立性：進程是一個能獨立運行的基本單位，同時也是系統分配資源和調度的獨立單位；

非同步性：由於進程間的相互制約，使進程具有執行的間斷性，即進程按各自獨立的、不可預知的速度向前推進

結構特徵：進程由程序、數據和進程式控制制塊三部分組成。

多個不同的進程可以包含相同的程序，一個程序在不同的數據集里就構成不同的進程，能得到不同的結果，但是執行過程中，程序不能發生改變。

進程與程序的區別：

程序是指令和數據的有序集合，是對指令、數據及其組織形式的描述，其本身沒有任何運行的含義，是一個靜態的概念。而進程是程序在處理機上的一次執行過程，它是一個動態的概念。

程序可以作為一種軟體資料長期存在，而進程是有一定生命期的。程序是永久的，進程是暫時的。

進程的調度：

要想多個進程交替運行，操作系統必須對這些進程進行調度，這個調度也不是隨機進行的，而是需要遵循一定的法則，由此就有了進程的調度演算法。

1、先來先服務演算法

先來先服務（FCFS）調度演算法是一種最簡單的調度演算法，該演算法既可用於作業調度，也可用於進程調度。FCFS演算法比較有利於長作業（進程），而不利於短作業（進程）。由此可知，本演算法適合於CPU繁忙型作業，而不利於I/O繁忙型的作業（進程）。

2、短作業優先調度演算法

短作業（進程）優先調度演算法（SJ/PF）是指對短作業或短進程優先調度的演算法，該演算法既可用於作業調度，也可用於進程調度。但其對長作業不利；不能保證緊迫性作業（進程）被及時處理；作業的長短只是被估算出來的。

3、時間片輪轉法

時間片輪轉(Round Robin，RR)法的基本思路是讓每個進程在就緒隊列中的等待時間與享受服務的時間成比例。在時間片輪轉法中，需要將CPU的處理時間分成固定大小的時間片，例如，幾十毫秒至幾百毫秒。如果一個進程在被調度選中之後用完了系統規定的時間片，但又未完成要求的任務，則它自行釋放自己所佔有的CPU而排到就緒隊列的末尾，等待下一次調度。同時，進程調度程序又去調度當前就緒隊列中的第一個進程。

顯然，輪轉法只能用來調度分配一些可以搶占的資源。這些可以搶占的資源可以隨時被剝奪，而且可以將它們再分配給別的進程。CPU是可搶占資源的一種。但列印機等資源是不可搶占的。由於作業調度是對除了CPU之外的所有系統硬體資源的分配，其中包含有不可搶占資源，所以作業調度不使用輪轉法。

在輪轉法中，時間片長度的選取非常重要。首先，時間片長度的選擇會直接影響到系統的開銷和響應時間。如果時間片長度過短，則調度程序搶占處理機的次數增多。這將使進程上下文切換次數也大大增加，從而加重系統開銷。反過來，如果時間片長度選擇過長，例如，一個時間片能保證就緒隊列中所需執行時間最長的進程能執行完畢，則輪轉法變成了先來先服務法。時間片長度的選擇是根據系統對響應時間的要求和就緒隊列中所允許最大的進程數來確定的。

在輪轉法中，加入到就緒隊列的進程有3種情況：

（1）一種是分給它的時間片用完，但進程還未完成，回到就緒隊列的末尾等待下次調度去繼續執行。

（2）另一種情況是分給該進程的時間片並未用完，只是因為請求I/O或由於進程的互斥與同步關系而被阻塞。當阻塞解除之後再回到就緒隊列。

（3）第三種情況就是新創建進程進入就緒隊列。

如果對這些進程區別對待，給予不同的優先順序和時間片從直觀上看，可以進一步改善系統服務質量和效率。例如，我們可把就緒隊列按照進程到達就緒隊列的類型和進程被阻塞時的阻塞原因分成不同的就緒隊列，每個隊列按FCFS原則排列，各隊列之間的進程享有不同的優先順序，但同一隊列內優先順序相同。這樣，當一個進程在執行完它的時間片之後，或從睡眠中被喚醒以及被創建之後，將進入不同的就緒隊列。

多級反饋隊列：

前面介紹的各種用作進程調度的演算法都有一定的局限性。如短進程優先的調度演算法，僅照顧了短進程而忽略了長進程，而且如果並未指明進程的長度，則短進程優先和基於進程長度的搶占式調度演算法都將無法使用。

而多級反饋隊列調度演算法則不必事先知道各種進程所需的執行時間，而且還可以滿足各種類型進程的需要，因而它是目前被公認的一種較好的進程調度演算法。在採用多級反饋隊列調度演算法的系統中，調度演算法的實施過程如下所述。

(1) 應設置多個就緒隊列，並為各個隊列賦予不同的優先順序。第一個隊列的優先順序最高，第二個隊列次之，其餘各隊列的優先權逐個降低。該演算法賦予各個隊列中進程執行時間片的大小也各不相同，在優先權愈高的隊列中，為每個進程所規定的執行時間片就愈小。例如，第二個隊列的時間片要比第一個隊列的時間片長一倍，……，第i+1個隊列的時間片要比第i個隊列的時間片長一倍。

(2) 當一個新進程進入內存後，首先將它放入第一隊列的末尾，按FCFS原則排隊等待調度。當輪到該進程執行時，如它能在該時間片內完成，便可准備撤離系統；如果它在一個時間片結束時尚未完成，調度程序便將該進程轉入第二隊列的末尾，再同樣地按FCFS原則等待調度執行；如果它在第二隊列中運行一個時間片後仍未完成，再依次將它放入第三隊列，……，如此下去，當一個長作業(進程)從第一隊列依次降到第n隊列後，在第n 隊列便採取按時間片輪轉的方式運行。

(3) 僅當第一隊列空閑時，調度程序才調度第二隊列中的進程運行；僅當第1～(i-1)隊列均空時，才會調度第i隊列中的進程運行。如果處理機正在第i隊列中為某進程服務時，又有新進程進入優先權較高的隊列(第1～(i-1)中的任何一個隊列)，則此時新進程將搶占正在運行進程的處理機，即由調度程序把正在運行的進程放回到第i隊列的末尾，把處理機分配給新到的高優先權進程。

G. Python中進程與線程的區別是什麼

Num01–>線程

線程是操作系統中能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。

一個線程指的是進程中一個單一順序的控制流。

一個進程中可以並發多條線程，每條線程並行執行不同的任務。

Num02–>進程

進程就是一個程序在一個數據集上的一次動態執行過程。

進程有以下三部分組成：

1，程序：我們編寫的程序用來描述進程要完成哪些功能以及如何完成。
2，數據集：數據集則是程序在執行過程中需要的資源，比如圖片、音視頻、文件等。
3，進程式控制制塊：進程式控制制塊是用來記錄進程的外部特徵，描述進程的執行變化過程，系統可以用它來控制和管理進程，它是系統感知進程存在的唯一標記。

Num03–>進程和線程的區別：

1、運行方式不同：

進程不能單獨執行，它只是資源的集合。

進程要操作CPU，必須要先創建一個線程。

所有在同一個進程里的線程，是同享同一塊進程所佔的內存空間。

2，關系

進程中第一個線程是主線程，主線程可以創建其他線程；其他線程也可以創建線程；線程之間是平等的。

進程有父進程和子進程，獨立的內存空間，唯一的標識符：pid。

3，速度

啟動線程比啟動進程快。

運行線程和運行進程速度上是一樣的，沒有可比性。

線程共享內存空間，進程的內存是獨立的。

4，創建

父進程生成子進程，相當於復制一份內存空間，進程之間不能直接訪問

創建新線程很簡單，創建新進程需要對父進程進行一次復制。

一個線程可以控制和操作同級線程里的其他線程，但是進程只能操作子進程。

5，交互

同一個進程里的線程之間可以直接訪問。

兩個進程想通信必須通過一個中間代理來實現。

導航:首頁 > 編程語言 > python中進程

python中進程

與python中進程相關的資料