Day26：進程與線程

時間 2019-11-19

標籤 day26 day 進程線程简体版

原文原文鏈接

一背景知識

進程的概念起源於操做系統，是操做系統最核心的概念。html

進程是對正在運行程序的一個抽象，操做系統的其餘全部內容都是圍繞進程的概念展開的。因此想要真正瞭解進程，必須事先了解操做系統，點擊進入。 python

進程是操做系統提供的最古老也是最重要的抽象概念之一。即便能夠利用的cpu只有一個（早期的計算機確實如此），也能保證支持（僞）併發的能力。將一個單獨的cpu變成多個虛擬的cpu（多道技術：時間多路複用和空間多路複用+硬件上支持隔離），沒有進程的抽象，現代計算機將不復存在。linux

　理論基礎：nginx

　　一操做系統的做用：程序員

1：隱藏醜陋複雜的硬件接口，提供良好的抽象接口web

2：管理、調度進程，而且將多個進程對硬件的競爭變得有序算法

　　二多道技術：shell

1.產生背景：針對單核，實現併發（如今的主機通常是多核，那麼每一個核都會利用多道技術，可是核與核之間沒有使用多道技術切換這麼一說，一個程序io阻塞，會等到io結束再從新調度）編程

2.時間上的複用（複用一個cpu的時間片）+空間上的複用（如內存中同時有多道程序）json

二進程

2.1-2.4 (重點部分)

2.5-2.9（瞭解部分）

2.1 什麼是進程

進程：正在進行的一個過程或者說一個任務。而負責執行任務則是cpu。

舉例（單核+多道，實現多個進程的併發執行）：

egon在一個時間段內有不少任務要作：python備課的任務，寫書的任務，交女友的任務，王者榮耀上分的任務，　　

但egon同一時刻只能作一個任務（cpu同一時間只能幹一個活），如何才能玩出多個任務併發執行的效果？

egon備一會課，再去跟李傑的女友聊聊天，再去打一會王者榮耀....這就保證了每一個任務都在進行中.

2.2 進程與程序的區別

程序僅僅只是一堆代碼而已，而進程指的是程序的運行過程。

　　舉例：

想象一位有一手好廚藝的計算機科學家egon正在爲他的女兒元昊烘製生日蛋糕。

他有作生日蛋糕的食譜，

廚房裏有所需的原料:麪粉、雞蛋、韭菜，蒜泥等。

在這個比喻中：

作蛋糕的食譜就是程序(即用適當形式描述的算法)

計算機科學家就是處理器(cpu)

而作蛋糕的各類原料就是輸入數據。

進程就是廚師閱讀食譜、取來各類原料以及烘製蛋糕等一系列動做的總和。

如今假設計算機科學家egon的兒子alex哭着跑了進來，說：XXXXXXXXXXXXXX。

科學家egon想了想，處理兒子alex蟄傷的任務比給女兒元昊作蛋糕的任務更重要，因而計算機科學家就記錄下他照着食譜作到哪兒了(保存進程的當前狀態)，而後拿出一本急救手冊，按照其中的指示處理蟄傷。這裏，咱們看處處理機從一個進程(作蛋糕)切換到另外一個高優先級的進程(實施醫療救治)，每一個進程擁有各自的程序(食譜和急救手冊)。當蜜蜂蟄傷處理完以後，這位計算機科學家又回來作蛋糕，從他離開時的那一步繼續作下去。

　　須要強調的是：同一個程序執行兩次，那也是兩個進程，好比打開暴風影音，雖然都是同一個軟件，可是一個能夠播放蒼井空，一個能夠播放飯島愛。

2.3 併發與並行

不管是並行仍是併發，在用戶看來都是「同事」運行的，無論是進程仍是線程，都只是一個任務而已，真是幹活的是cpu，cpu來作這些任務，而一個cpu同一時刻只能執行一個任務。

一併發：是僞並行，即看起來是同時運行。單個cpu+多道技術就能夠實現併發，（並行也屬於併發）。

二並行：同時運行，只有具有多個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共享同一個物理內存）。

2.4 同步與異步

同步執行：一個進程在執行某個任務時，另一個進程必須等待其執行完畢，才能繼續執行。
異步執行：一個進程在執行某個任務時，另一個進程無需等待其執行完畢，就能夠繼續執行，當有消息返回時，系統會通知後者進行處理，這樣能夠提升執行效率。

舉個例子，打電話時就是同步通訊，發短息時就是異步通訊。

2.5 進程的建立

　　但凡是硬件，都須要有操做系統去管理，只要有操做系統，就有進程的概念，就須要有建立進程的方式，一些操做系統只爲一個應用程序設計，好比微波爐中的控制器，一旦啓動微波爐，全部的進程都已經存在。

　　而對於通用系統（跑不少應用程序），須要有系統運行過程當中建立或撤銷進程的能力，主要分爲4中形式建立新的進程

　　1. 系統初始化（查看進程linux中用ps命令，windows中用任務管理器，前臺進程負責與用戶交互，後臺運行的進程與用戶無關，運行在後臺而且只在須要時才喚醒的進程，稱爲守護進程，如電子郵件、web頁面、新聞、打印）

　　2. 一個進程在運行過程當中開啓了子進程（如nginx開啓多進程，os.fork,subprocess.Popen等）

　　3. 用戶的交互式請求，而建立一個新進程（如用戶雙擊暴風影音）

　　4. 一個批處理做業的初始化（只在大型機的批處理系統中應用）

　　不管哪種，新進程的建立都是由一個已經存在的進程執行了一個用於建立進程的系統調用而建立的：

　　1. 在UNIX中該系統調用是：fork，fork會建立一個與父進程如出一轍的副本，兩者有相同的存儲映像、一樣的環境字符串和一樣的打開文件（在shell解釋器進程中，執行一個命令就會建立一個子進程）

　　2. 在windows中該系統調用是：CreateProcess，CreateProcess既處理進程的建立，也負責把正確的程序裝入新進程。

　　關於建立的子進程，UNIX和windows

　　1.相同的是：進程建立後，父進程和子進程有各自不一樣的地址空間（多道技術要求物理層面實現進程之間內存的隔離），任何一個進程的在其地址空間中的修改都不會影響到另一個進程。

　　2.不一樣的是：在UNIX中，子進程的初始地址空間是父進程的一個副本，提示：子進程和父進程是能夠有隻讀的共享內存區的。可是對於windows系統來講，從一開始父進程與子進程的地址空間就是不一樣的。

2.6 進程的終止

　　1. 正常退出（自願，如用戶點擊交互式頁面的叉號，或程序執行完畢調用發起系統調用正常退出，在linux中用exit，在windows中用ExitProcess）

　　2. 出錯退出（自願，python a.py中a.py不存在）

　　3. 嚴重錯誤（非自願，執行非法指令，如引用不存在的內存，1/0等，能夠捕捉異常，try...except...）

　　4. 被其餘進程殺死（非自願，如kill -9）

2.7 進程的層次結構

　　不管UNIX仍是windows，進程只有一個父進程，不一樣的是：

　　1. 在UNIX中全部的進程，都是以init進程爲根，組成樹形結構。父子進程共同組成一個進程組，這樣，當從鍵盤發出一個信號時，該信號被送給當前與鍵盤相關的進程組中的全部成員。

　　2. 在windows中，沒有進程層次的概念，全部的進程都是地位相同的，惟一相似於進程層次的暗示，是在建立進程時，父進程獲得一個特別的令牌（稱爲句柄）,該句柄能夠用來控制子進程，可是父進程有權把該句柄傳給其餘子進程，這樣就沒有層次了。

2.8 進程的狀態

　　tail -f access.log |grep '404'

　　執行程序tail，開啓一個子進程，執行程序grep，開啓另一個子進程，兩個進程之間基於管道'|'通信，將tail的結果做爲grep的輸入。

　　進程grep在等待輸入（即I/O）時的狀態稱爲阻塞，此時grep命令都沒法運行

　　其實在兩種狀況下會致使一個進程在邏輯上不能運行，

　　1. 進程掛起是自身緣由，遇到I/O阻塞，便要讓出CPU讓其餘進程去執行，這樣保證CPU一直在工做

　　2. 與進程無關，是操做系統層面，可能會由於一個進程佔用時間過多，或者優先級等緣由，而調用其餘的進程去使用CPU。

　　於是一個進程由三種狀態

2.9 進程併發的實現

　　進程併發的實如今於，硬件中斷一個正在運行的進程，把此時進程運行的全部狀態保存下來，爲此，操做系統維護一張表格，即進程表（process table），每一個進程佔用一個進程表項（這些表項也稱爲進程控制塊）

　　該表存放了進程狀態的重要信息：程序計數器、堆棧指針、內存分配情況、全部打開文件的狀態、賬號和調度信息，以及其餘在進程由運行態轉爲就緒態或阻塞態時，必須保存的信息，從而保證該進程在再次啓動時，就像從未被中斷過同樣。

三線程

3.1-3.4（重點部分）

3.5-3.10（瞭解部分）

3.1 什麼是線程　　

　　在傳統操做系統中，每一個進程有一個地址空間，並且默認就有一個控制線程。

　　線程顧名思義，就是一條流水線工做的過程，一條流水線必須屬於一個車間，一個車間的工做過程是一個進程。

車間負責把資源整合到一塊兒，是一個資源單位，而一個車間內至少有一個流水線。

流水線的工做須要電源，電源就至關於cpu。

　　因此，進程只是用來把資源集中到一塊兒（進程只是一個資源單位，或者說資源集合），而線程纔是cpu上的執行單位。

　　多線程（即多個控制線程）的概念是，在一個進程中存在多個控制線程，多個控制線程共享該進程的地址空間，至關於一個車間內有多條流水線，都共用一個車間的資源。

　　例如，北京地鐵與上海地鐵是不一樣的進程，而北京地鐵裏的13號線是一個線程，北京地鐵全部的線路共享北京地鐵全部的資源，好比全部的乘客能夠被全部線路拉。

　　建立進程的開銷要遠大於線程？

若是咱們的軟件是一個工廠，該工廠有多條流水線，流水線工做須要電源，電源只有一個即cpu（單核cpu）

一個車間就是一個進程，一個車間至少一條流水線（一個進程至少一個線程）

建立一個進程，就是建立一個車間（申請空間，在該空間內建至少一條流水線）

而建線程，就只是在一個車間內造一條流水線，無需申請空間，因此建立開銷小。

進程之間是競爭關係，線程之間是協做關係？

車間直接是競爭/搶電源的關係，競爭（不一樣的進程直接是競爭關係，是不一樣的程序員寫的程序運行的，迅雷搶佔其餘進程的網速，360把其餘進程當作病毒乾死）
一個車間的不一樣流水線式協同工做的關係（同一個進程的線程之間是合做關係，是同一個程序寫的程序內開啓動，迅雷內的線程是合做關係，不會本身幹本身）

3.2 爲什麼要用多線程

　　多線程指的是，在一個進程中開啓多個線程，簡單的講：若是多個任務共用一塊地址空間，那麼必須在一個進程內開啓多個線程。詳細的講分爲4點：

　　1. 多線程共享一個進程的地址空間

2. 線程比進程更輕量級，線程比進程更容易建立可撤銷，在許多操做系統中，建立一個線程比建立一個進程要快10-100倍，在有大量線程須要動態和快速修改時，這一特性頗有用

3. 若多個線程都是cpu密集型的，那麼並不能得到性能上的加強，可是若是存在大量的計算和大量的I/O處理，擁有多個線程容許這些活動彼此重疊運行，從而會加快程序執行的速度。

4. 在多cpu系統中，爲了最大限度的利用多核，能夠開啓多個線程（比開進程開銷要小的多）

3.3 多線程的應用舉例

開啓一個字處理軟件進程，該進程確定須要辦不止一件事情，好比監聽鍵盤輸入，處理文字，定時自動將文字保存到硬盤，這三個任務操做的都是同一塊數據，於是不能用多進程。只能在一個進程裏併發地開啓三個線程,若是是單線程，那就只能是，鍵盤輸入時，不能處理文字和自動保存，自動保存時又不能輸入和處理文字。

3.4 線程與進程的區別

Threads share the address space of the process that created it; processes have their own address space.
Threads have direct access to the data segment of its process; processes have their own copy of the data segment of the parent process.
Threads can directly communicate with other threads of its process; processes must use interprocess communication to communicate with sibling processes.
New threads are easily created; new processes require duplication of the parent process.
Threads can exercise considerable control over threads of the same process; processes can only exercise control over child processes.
Changes to the main thread (cancellation, priority change, etc.) may affect the behavior of the other threads of the process; changes to the parent process does not affect child processes.

3.5 經典的線程模型

　　多個線程共享同一個進程的地址空間中的資源，是對一臺計算機上多個進程的模擬，有時也稱線程爲輕量級的進程

　　而對一臺計算機上多個進程，則共享物理內存、磁盤、打印機等其餘物理資源。

　　多線程的運行也多進程的運行相似，是cpu在多個線程之間的快速切換。

　　不一樣的進程之間是充滿敵意的，彼此是搶佔、競爭cpu的關係，若是迅雷會和QQ搶資源。而同一個進程是由一個程序員的程序建立，因此同一進程內的線程是合做關係，一個線程能夠訪問另一個線程的內存地址，你們都是共享的，一個線程乾死了另一個線程的內存，那純屬程序員腦子有問題。

　　相似於進程，每一個線程也有本身的堆棧

　　不一樣於進程，線程庫沒法利用時鐘中斷強制線程讓出CPU，能夠調用thread_yield運行線程自動放棄cpu，讓另一個線程運行。

　　線程一般是有益的，可是帶來了不小程序設計難度，線程的問題是：

　　1. 父進程有多個線程，那麼開啓的子線程是否須要一樣多的線程

　　　若是是，那麼附近中某個線程被阻塞，那麼copy到子進程後，copy版的線程也要被阻塞嗎，想想nginx的多線程模式接收用戶鏈接。

　　2. 在同一個進程中，若是一個線程關閉了問題，而另一個線程正準備往該文件內寫內容呢？

若是一個線程注意到沒有內存了，並開始分配更多的內存，在工做一半時，發生線程切換，新的線程也發現內存不夠用了，又開始分配更多的內存，這樣內存就被分配了屢次，這些問題都是多線程編程的典型問題，須要仔細思考和設計。

3.6 POSIX線程

爲了實現可移植的線程程序,IEEE在IEEE標準1003.1c中定義了線程標準，它定義的線程包叫Pthread。大部分UNIX系統都支持該標準，簡單介紹以下

3.7 在用戶空間實現的線程

線程的實現能夠分爲兩類：用戶級線程(User-Level Thread)和內核線線程(Kernel-Level Thread)，後者又稱爲內核支持的線程或輕量級進程。在多線程操做系統中，各個系統的實現方式並不相同，在有的系統中實現了用戶級線程，有的系統中實現了內核級線程。

用戶級線程內核的切換由用戶態程序本身控制內核切換,不須要內核干涉，少了進出內核態的消耗，但不能很好的利用多核Cpu,目前Linux pthread大致是這麼作的。

　　在用戶空間模擬操做系統對進程的調度，來調用一個進程中的線程，每一個進程中都會有一個運行時系統，用來調度線程。此時當該進程獲取cpu時，進程內再調度出一個線程去執行，同一時刻只有一個線程執行。

3.8 在內核空間實現的線程

內核級線程:切換由內核控制，當線程進行切換的時候，由用戶態轉化爲內核態。切換完畢要從內核態返回用戶態；能夠很好的利用smp，即利用多核cpu。windows線程就是這樣的。

3.9 用戶級與內核級線程的對比

一：如下是用戶級線程和內核級線程的區別：

內核支持線程是OS內核可感知的，而用戶級線程是OS內核不可感知的。
用戶級線程的建立、撤消和調度不須要OS內核的支持，是在語言（如Java）這一級處理的；而內核支持線程的建立、撤消和調度都需OS內核提供支持，並且與進程的建立、撤消和調度大致是相同的。
用戶級線程執行系統調用指令時將致使其所屬進程被中斷，而內核支持線程執行系統調用指令時，只致使該線程被中斷。
在只有用戶級線程的系統內，CPU調度仍是以進程爲單位，處於運行狀態的進程中的多個線程，由用戶程序控制線程的輪換運行；在有內核支持線程的系統內，CPU調度則以線程爲單位，由OS的線程調度程序負責線程的調度。
用戶級線程的程序實體是運行在用戶態下的程序，而內核支持線程的程序實體則是能夠運行在任何狀態下的程序。

二：內核線程的優缺點

　　優勢：

當有多個處理機時，一個進程的多個線程能夠同時執行。

　　缺點：

由內核進行調度。

三：用戶進程的優缺點

　　優勢：

線程的調度不須要內核直接參與，控制簡單。
能夠在不支持線程的操做系統中實現。
建立和銷燬線程、線程切換代價等線程管理的代價比內核線程少得多。
容許每一個進程定製本身的調度算法，線程管理比較靈活。
線程可以利用的表空間和堆棧空間比內核級線程多。
同一進程中只能同時有一個線程在運行，若是有一個線程使用了系統調用而阻塞，那麼整個進程都會被掛起。另外，頁面失效也會產生一樣的問題。

　　缺點：

資源調度按照進程進行，多個處理機下，同一個進程中的線程只能在同一個處理機下分時複用

3.10 混合實現

　　用戶級與內核級的多路複用，內核同一調度內核線程，每一個內核線程對應n個用戶線程

4、課後做業

豆瓣250電影爬蟲多線程與單線程對比：

import requests
import re
import json
import threading,time
li=[]
def getPage(url):
    res=requests.get(url)
    res.encoding=res.apparent_encoding
    return res.text
def match(s):
    mov = re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
                   '.*?<p.*?>.*?導演: (?P<br>.*?) .*?</p>.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)評價</span>',re.S)
    ret = mov.finditer(s)
    for i in ret:
        yield {
            "id": i.group("id"),
            "title": i.group("title"),
            "br":i.group("br"),
            "rating_num": i.group("rating_num"),
            "comment_num": i.group("comment_num"),
        }

def main(num):
    url='https://movie.douban.com/top250?start=%s&filter='%num
    ret=match(getPage(url))
    print(ret)
    with open('movie','a',encoding='utf-8') as f:
        for obj in ret:
            print(obj)
            date=json.dumps(obj,ensure_ascii=False)
            f.write(date+'\n')

if __name__ == '__main__':
    count=0
    s=time.time()
    for i in range(10):
        main(count)
        count+=25
    print(time.time()-s)
#運行時間：5.575318813323975

單線程

單線程

import requests
import re
import json
import threading,time
li=[]
def getPage(url):
    res=requests.get(url)
    res.encoding=res.apparent_encoding
    return res.text
def match(s):
    mov = re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
                   '.*?<p.*?>.*?導演: (?P<br>.*?) .*?</p>.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)評價</span>',re.S)
    ret = mov.finditer(s)
    for i in ret:
        yield {
            "id": i.group("id"),
            "title": i.group("title"),
            "br":i.group("br"),
            "rating_num": i.group("rating_num"),
            "comment_num": i.group("comment_num"),
        }
def main(num):
    url='https://movie.douban.com/top250？start=%s&filter='%num
    ret=match(getPage(url))
    # print(ret)
    for i in ret:
        li.append(i)
    # print('cost time:',time.time()-s)


if __name__ == '__main__':
    count=0
    s=time.time()
    a={}
    for i in range(10):
        a[i]=threading.Thread(target=main,args=(count,))
        a[i].start()
        count+=25

    for i in range(10):
        a[i].join()

    li=sorted(li,key=lambda x:int(x['id']))
    print(li)
    with open('movie','a',encoding='utf-8') as f:
        for obj in li:
            date=json.dumps(obj,ensure_ascii=False)
            f.write(date+'\n')

    print(time.time()-s)
#運行時間：4.137236595153809    

多線程