標籤: 貨運

本來想參照：https://mp.weixin.qq.com/s/e7Wd7aEatcLFGgJUDkg-EQ搞一個往年編程語言動態圖的，奈何找不到數據，有數據來源的歡迎在評論區留言。

這裏找到了一個，是2020年6月的編程語言排行，供大家看一下：https://www.tiobe.com/tiobe-index/

 

我們要實現的效果是：

大學排名來源：http://www.zuihaodaxue.com/ARWU2003.html

部分截圖：

在http://www.zuihaodaxue.com/ARWU2003.html中的年份可以選擇，我們解析的頁面就有了：

"http://www.zuihaodaxue.com/ARWU%s.html" % str(year)

初步獲取頁面的html信息的代碼：

def get_one_page(year):
    try:
        headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Safari/537.36'
            }
        url = "http://www.zuihaodaxue.com/ARWU%s.html" % str(year)
        response=requests.get(url,headers=headers)
        if response.status_code == 200:
            return response.content
    except RequestException:
        print('爬取失敗')

我們在頁面上進行檢查：

數據是存儲在表格中的，這樣我們就可以利用pandas獲取html中的數據，基本語法：

tb = pd.read_html(url)[num]

其中的num是標識網頁中的第幾個表格，這裏只有一個表格，所以標識為0。初步的解析代碼就有了：

def parse_on_page(html,i):
    tb=pd.read_html(html)[0]
    return tb

我們還要將爬取下來的數據存儲到csv文件中，基本代碼如下：

def save_csv(tb):
    start_time=time.time()
    tb.to_csv(r'university.csv', mode='a', encoding='utf_8_sig', header=True, index=0)
    endtime = time.time()-start_time
    print('程序運行了%.2f秒' %endtime)

最後是一個主函數，別忘了還有需要導入的包：

import requests
from requests.exceptions import RequestException
import pandas as pd
import time
def main(year):
    for i in range(2003,year):
        html=get_one_page(i)
        tb=parse_on_page(html,i)
        #print(tb)
        save_csv(tb)
if __name__ == "__main__":
    main(2004)

運行之後，我們在同級目錄下就可以看到university.csv，部分內容如下：

存在幾個問題：

（1）缺少年份

（2）最後一列沒有用

（3）國家由於是圖片表示，沒有爬取下來

（4）排名100以後的是一個區間

我們接下來一一解決：

（1）刪掉沒用的列

def parse_on_page(html,i):
    tb=pd.read_html(html)[0]
    # 重命名表格列，不需要的列用數字錶示
    tb.columns = ['world rank','university', 2, 'score',4]
    tb.drop([2,4],axis=1,inplace=True)
    return tb

新的結果：

（2） 對100以後的進行唯一化，增加一列index作為排名標識

tb['index_rank'] = tb.index
tb['index_rank'] = tb['index_rank'].astype(int) + 1

（3）新增加年份

tb['year'] = i

（4）新增加國家

首先我們進行檢查：

發現國家在td->a>img下的圖像路徑中有名字：UnitedStates。 我們可以取出src屬性，並用正則匹配名字即可。

def get_country(html):
    soup = BeautifulSoup(html,'lxml')
    countries = soup.select('td > a > img')
    lst = []
    for i in countries:
        src = i['src']
        pattern = re.compile('flag.*\/(.*?).png')
        country = re.findall(pattern,src)[0]
        lst.append(country)
    return lst

然後這麼使用：

# read_html沒有爬取country，需定義函數單獨爬取
tb['country'] = get_country(html)

最終解析的整體函數如下：

def parse_on_page(html,i):
    tb=pd.read_html(html)[0]
    # 重命名表格列，不需要的列用數字錶示
    tb.columns = ['world rank','university', 2, 'score',4]
    tb.drop([2,4],axis=1,inplace=True)
    tb['index_rank'] = tb.index
    tb['index_rank'] = tb['index_rank'].astype(int) + 1
    tb['year'] = i
    # read_html沒有爬取country，需定義函數單獨爬取
    tb['country'] = get_country(html)
    return tb

運行之後：

最後我們要提取屬於中國部分的相關信息：

首先將年份改一下，獲取到2019年為止的信息：

if __name__ == "__main__":
    main(2019)

然後我們提取到中國高校的信息，直接看代碼理解：

def analysis():
    df = pd.read_csv('university.csv')
    # 包含港澳台
    # df = df.query("(country == 'China')|(country == 'China-hk')|(country == 'China-tw')|(country == 'China-HongKong')|(country == 'China-Taiwan')|(country == 'Taiwan,China')|(country == 'HongKong,China')")[['university','year','index_rank']]

    # 只包括內地
    df = df.query("(country == 'China')")
    df['index_rank_score'] = df['index_rank']
    # 將index_rank列轉為整形
    df['index_rank'] = df['index_rank'].astype(int)

    # 美國
    # df = df.query("(country == 'UnitedStates')|(country == 'USA')")

    #求topn名
    def topn(df):
        top = df.sort_values(['year','index_rank'],ascending = True)
        return top[:20].reset_index()
    df = df.groupby(by =['year']).apply(topn)

    # 更改列順序
    df = df[['university','index_rank_score','index_rank','year']]
    # 重命名列
    df.rename (columns = {'university':'name','index_rank_score':'type','index_rank':'value','year':'date'},inplace = True)

    # 輸出結果
    df.to_csv('university_ranking.csv',mode ='w',encoding='utf_8_sig', header=True, index=False)
    # index可以設置

本來是想爬取從2003年到2019年的，運行時發現從2005年開始，頁面不一樣了，多了一列：

方便起見，我們就只從2005年開始了，還需要修改一下代碼：

    # 重命名表格列，不需要的列用數字錶示
    tb.columns = ['world rank','university', 2,3, 'score',5]
    tb.drop([2,3,5],axis=1,inplace=True)

最後是整體代碼：

import requests
from requests.exceptions import RequestException
import pandas as pd
import time
from bs4 import BeautifulSoup
import re
def get_one_page(year):
    try:
        headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Safari/537.36'
            }
        url = "http://www.zuihaodaxue.com/ARWU%s.html" % str(year)
        response=requests.get(url,headers=headers)
        if response.status_code == 200:
            return response.content
    except RequestException:
        print('爬取失敗')
def parse_on_page(html,i):
    tb=pd.read_html(html)[0]
    # 重命名表格列，不需要的列用數字錶示
    tb.columns = ['world rank','university', 2,3, 'score',5]
    tb.drop([2,3,5],axis=1,inplace=True)
    tb['index_rank'] = tb.index
    tb['index_rank'] = tb['index_rank'].astype(int) + 1
    tb['year'] = i
    # read_html沒有爬取country，需定義函數單獨爬取
    tb['country'] = get_country(html)
    return tb
def save_csv(tb):
    start_time=time.time()
    tb.to_csv(r'university.csv', mode='a', encoding='utf_8_sig', header=True, index=0)
    endtime = time.time()-start_time
    print('程序運行了%.2f秒' %endtime)
# 提取國家名稱
def get_country(html):
    soup = BeautifulSoup(html,'lxml')
    countries = soup.select('td > a > img')
    lst = []
    for i in countries:
        src = i['src']
        pattern = re.compile('flag.*\/(.*?).png')
        country = re.findall(pattern,src)[0]
        lst.append(country)
    return lst
def analysis():
    df = pd.read_csv('university.csv')
    # 包含港澳台
    # df = df.query("(country == 'China')|(country == 'China-hk')|(country == 'China-tw')|(country == 'China-HongKong')|(country == 'China-Taiwan')|(country == 'Taiwan,China')|(country == 'HongKong,China')")[['university','year','index_rank']]

    # 只包括內地
    df = df.query("(country == 'China')")
    df['index_rank_score'] = df['index_rank']
    # 將index_rank列轉為整形
    df['index_rank'] = df['index_rank'].astype(int)

    # 美國
    # df = df.query("(country == 'UnitedStates')|(country == 'USA')")

    #求topn名
    def topn(df):
        top = df.sort_values(['year','index_rank'],ascending = True)
        return top[:20].reset_index()
    df = df.groupby(by =['year']).apply(topn)

    # 更改列順序
    df = df[['university','index_rank_score','index_rank','year']]
    # 重命名列
    df.rename (columns = {'university':'name','index_rank_score':'type','index_rank':'value','year':'date'},inplace = True)

    # 輸出結果
    df.to_csv('university_ranking.csv',mode ='w',encoding='utf_8_sig', header=True, index=False)
    # index可以設置
def main(year):
    for i in range(2005,year):
        html=get_one_page(i)
        tb=parse_on_page(html,i)
        save_csv(tb)
        print(i,'年排名提取完成完成')
        analysis()
if __name__ == "__main__":
    main(2019)

運行之後會有一個university_ranking.csv，部分內容如下：

接下來就是可視化過程了。

1、 首先，到作者的github主頁：  
https://github.com/Jannchie/Historical-ranking-data-visualization-based-on-d3.js

2、克隆倉庫文件，使用git

# 克隆項目倉庫
git clone https://github.com/Jannchie/Historical-ranking-data-visualization-based-on-d3.js
# 切換到項目根目錄
cd Historical-ranking-data-visualization-based-on-d3.js
# 安裝依賴
npm install

這裏如果git clone超時可參考：

https://www.cnblogs.com/xiximayou/p/12305209.html

需要注意的是，這裏的npm是我之前裝node.js裝了的，沒有的自己需要裝一下。

在執行npm install時會報錯：

先執行：

npm init

之後一直回車即可：

再執行npm install

任意瀏覽器打開bargraph.html網頁，點擊選擇文件，然後選擇前面輸出的university_ranking.csv文件，看下效果：

只能製作動圖上傳了。

可以看到，有了大致的可視化效果，但還存在很多瑕疵，比如：表順序顛倒了、字體不合適、配色太花哨等。可不可以修改呢？

當然是可以的，只需要分別修改文件夾中這幾個文件的參數就可以了：

• config.js 全局設置各項功能的開關，比如配色、字體、文字名稱、反轉圖表等等功能；

• color.css 修改柱形圖的配色；

• stylesheet.css 具體修改配色、字體、文字名稱等的css樣式；

• visual.js 更進一步的修改，比如圖表的透明度等。

知道在哪裡修改了以後，那麼，如何修改呢？很簡單，只需要簡單的幾步就可以實現：

• 打開網頁，右鍵-檢查，箭頭指向想要修改的元素，然後在右側的css樣式表裡，雙擊各項參數修改參數，修改完元素就會發生變化，可以不斷微調，直至滿意為止。

    

• 把參數複製到四個文件中對應的文件里並保存。

• Git Bash運行npm run build，之後刷新網頁就可以看到優化后的效果。（我發現這一步其實不需要，而且會報錯，我直接修改config.js之後運行也成功了）

這裏我主要修改的是config.js的以下項：

  // 倒序，使得最短的條位於最上方 
  reverse: true,
  // 附加信息內容。
  // left label
  itemLabel: "本年度第一大學",
  // right label
  typeLabel: "世界排名",
  //為了避免名稱重疊
  item_x: 500,
  // 時間標籤坐標。建議x：1000 y：-50開始嘗試，默認位置為x:null,y:null
  dateLabel_x: 1000,
  dateLabel_y: -50,

最終效果：

至此，就全部完成了。

看起來簡單，還是得要自己動手才行。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※幫你省時又省力,新北清潔一流服務好口碑

※回頭車貨運收費標準

今日得到

• 計算機科學領域的任何問題都可以通過增加一個間接的中間層來解決

• 併發：Do not communicate by sharing memory; instead, share memory by communicate. (不要以共享內存的方式來通信，相反，要通過通信來共享內存)

1. 進程

進程是系統進行資源分配和調度的一個獨立單位，程序段、數據段、PCB三部分組成了進程實體（進程映像），PCB是進程存在的唯一標準

1.1 進程的組織方式：

• 鏈接方式
  • 按照進程狀態將PCB分為多個隊列，就緒隊列，阻塞隊列等
  • 操作系統持有指向各個隊列的指針
• 索引方式
  • 根據進程狀態的不同，建立幾張索引表
  • 操作系統持有指向各個索引表的指針

1.2 進程的狀態

• 創建態： 操作系統為進程分配資源，初始化PCB

• 就緒態：運行資源等條件都滿足，存儲在就緒隊列中，等待CPU調度

• 運行態：CPU正在執行進程

• 阻塞態：等待某些條件滿足，等待消息回復，等待同步鎖，sleep等，阻塞隊列

• 終止態 ：回收進程擁有的資源，撤銷PCB

1.3 進程的切換和調度

進程在操作系統內核程序臨界區中不能進行調度與切換

臨界資源：一個時間段內只允許一個進程使用資源，各進程需要互斥地訪問臨界資源

臨界區：訪問臨界資源的代碼

內核程序臨界區：訪問某種內核數據結構，如進程的就緒隊列（存儲各進程的PCB）

進程調度的方式：

• 非剝奪調度方式（非搶佔方式），只允許進程主動放棄處理機，在運行過程中即便有更緊迫的任務到達，當前進程依然會繼續使用處理機，直到該進程終止或者主動要求進入阻塞態
• 剝奪調度方式（又稱搶佔方式）當一個進程正在處理機上執行時，如果有一個優先級更高的進程需要處理機，則立即開中斷暫停正在執行的進程，將處理機飯呢陪給優先級高的那個進程

進程的切換與過程：進程的調度、切換是有代價的

1. 對原來運行進程各種數據的保存
2. 對新的進程各種數據恢復（程序計數器，程序狀態字，各種數據寄存器等處理機的現場）

進程調度算法的相關參數：

• CPU利用率：CPU忙碌時間/作業完成的總時間
• 系統吞吐量：單位時間內完成作業的數量
• 周轉時間：從作業被提交給系統開始，到作業完成為止的時間間隔 = 作業完成時間-作業提交時間
• 帶權周轉時間：（由於周轉時間相同的情況下，可能實際作業的運行時間不一樣，這樣就會給用戶帶來不一樣的感覺） 作業周轉時間/作業實際運行時間， 帶權周轉時間>=1, 越小越好
• 平均帶權周轉時間：各作業帶權周轉時間之和/作業數
• 等待時間
• 響應時間

調度算法：

算法思想，用於解決什麼問題？

算法規則，用於作業（PCB作業）調度還是進程調度？

搶佔式還是非搶佔式的？

優缺點？是否會導致飢餓？

以下調度算法是適用於當前交互式操作系統

• 時間片輪轉（Round-Robin）
  • 算法思想：公平地、輪流地為各個進程服務，讓每個進程在一定時間間隔內可以得到相應
  • 算法規則：按照各進程到達就緒隊列的順序，輪流讓各個進程執行一個時間片（如100ms）。若進程未在一個時間片內執行完，則剝奪處理機，將進程重新放到就緒隊列隊尾重新排隊。
  • 用於作業/進程調度：用於進程的調度（只有作業放入內存建立相應的進程后，才會被分配處理機時間片）
  • 是否可搶佔？若進程未能在規定時間片內完成，將被強行剝奪處理機使用權，由時鐘裝置發出時鐘中斷信號來通知CPU時間片到達
  • 優缺點：適用於分時操作系統，由於高頻率的進程切換，因此有一定開銷；不區分任務的緊急程度
  • 是否會導致飢餓？ 不會
• 優先級調度算法
  • 算法思想：隨着計算機的發展，特別是實時操作系統的出現，越來越多的應用場景需要根據任務的進程成都決定處理順序
  • 算法規則：每個作業/進程有各自的優先級，調度時選擇優先級最高的作業/進程
  • 用於作業/進程調度：即可用於作業調度（處於外存後備隊列中的作業調度進內存），也可用於進程調度（選擇就緒隊列中的進程，為其分配處理機），甚至I/O調度
  • 是否可搶佔？ 具有可搶佔版本，也有非搶佔式的
  • 優缺點：適用於實時操作系統，用優先級區分緊急程度，可靈活地調整對各種作業/及進程的偏好程度。缺點：若源源不斷地提供高優先級進程，則可能導致飢餓
  • 是否會導致飢餓： 會
• 多級反饋隊列調度算法

  • 算法思想：綜合FCFS、SJF(SPF)、時間片輪轉、優先級調度

  • 算法規則：

    • 1.設置多級就緒隊列，各級別隊列優先級從高到底，時間片從小到大
    • 2.新進程到達時先進入第1級隊列，按照FCFS原則排隊等待被分配時間片，若用完時間片進程還未結束，則進程進入下一級隊列隊尾
    • 3.只有第k級別隊列為空時，才會為k+1級對頭的進程分配時間片

  • 用於作業/進程調度：用於進程調度

  • 是否可搶佔？ 搶佔式算法。在k級隊列的進程運行過程中，若更上級別的隊列（1-k-1級）中進入一個新進程，則由於新進程處於優先級高的隊列中，因此新進程會搶佔處理機，原理運行的進程放回k級隊列隊尾。

  • 優缺點：對各類型進程相對公平（FCFS的有點）；每個新到達的進程都可以很快就得到相應（RR優點）；短進程只用較少的時間就可完成（SPF）的有點；不必實現估計進程的運行時間；可靈活地調整對各類進程的偏好程度，比如CPU密集型進程、I/O密集型進程（拓展：可以將因I/O而阻塞的進程重新放回原隊列，這樣I/O型進程就可以保持較高優先級）

  • 是否會導致飢餓： 會

2. 線程

引入線程之後，進程只作為除CPU之外的系統資源的分配單元（如：打印機，內存地址空間等都是分配給進程的）

線程的是實現方式：

• 用戶級線程（User-Level Thread），用戶級線程由應用程序通過線程庫是實現如python (import thread), 線程的管理工作由應用程序負責。
• 內核級線程（kernel-Level Thread），內核級線程的管理工作由操作系統內核完成，線程調度，切換等工作都由內核負責，因此內核級線程的切換必然需要在核心態下才能完成

進程和線程的關係：一條線程指的是進程中一個單一順序的控制流，一個進程中可以併發多個線程，每條線程并行執行不同的任務。CPU的最小調度單元是線程，所以單進程多線程是可以利用多核CPU的。

2.1 線程模型：

• 用戶級線程模型(一對多模型)

多個用戶態的線程對應着一個內核線程，程序線程的創建、終止、切換或者同步等線程工作必須自身來完成。python就是這種。雖然可以實現異步，但是不能有效利用多核（GIL）

• 內核級線程模型 (一對一)

這種模型直接調用操作系統的內核線程，所有線程的創建、終止、切換、同步等操作，都由內核來完成。C++就是這種

• 兩級線程模型(M:N)

這種線程模型會先創建多個內核級線程，然後用自身的用戶級線程去對應創建的多個內核級線程，自身的用戶級線程需要本身程序去調度，內核級的線程交給操作系統內核去調度。GO語言就是這種。

python中的多線程因為GIL的存在，並不能利用多核CPU優勢，但是在阻塞的系統調用中，如sock.connect(), sock.recv()等耗時的I/O操作，當前的線程會釋放GIL，讓出處理器。但是單個線程內，阻塞調用上還是阻塞的。除了GIL之外，所有的多線程還有通病，他們都是被OS調用的，調度策略是搶佔式的，以保證同等有限級的線程都有機執行，帶來的問題就是:並不知道下一刻執行那個線程，也不知道正在執行什麼代碼，會存在競態條件

3. 協程

協程通過在線程中實現調度，避免了陷入內核級別的上下文切換造成的性能損失，進而突破了線程在IO上的性能瓶頸。

python的協程源於yield指令

• yield item 用於產出一個值，反饋給next()的調用方法
• 讓出處理機，暫停執行生成器，讓調用方繼續工作，直到需要使用另一個值時再調用next()

協程式對線程的調度，yield類似惰性求職方式可以視為一種流程控制工具，實現協作式多任務，python3.5引入了async/await表達式，使得協程證實在語言層面得到支持和優化，大大簡化之前的yield寫法。線程正式在語言層面得到支持和優化。線程是內核進行搶佔式調度的，這樣就確保每個線程都有執行的機會。而coroutine運行在同一個線程中，有語言層面運行時中的EventLoop（事件循環）來進行調度。在python中協程的調度是非搶佔式的，也就是說一個協程必須主動讓出執行機會，其他協程才有機會運行。讓出執行的關鍵字 await， 如果一個協程阻塞了，持續不讓出CPU處理機，那麼整個線程就卡住了，沒有任何併發。

PS: 作為服務端，event loop最核心的就是I/O多路復用技術，所有來自客戶端的請求都由I/O多路復用函數來處理；作為客戶端，event loop的核心在於Future對象延遲執行，並使用send函數激發協程，掛起，等待服務端處理完成返回后再調用Callback函數繼續執行。[python 協程與go協程的區別]

3.1 Golang 協程

Go 天生在語言層面支持，和python類似都是用關鍵字，而GO語言使用了go關鍵字，go協程之間的通信，採用了channel關鍵字。

go實現了兩種併發形式：

• 多線程共享內存：如Java 或者C++在多線程中共享數據的時候，通過鎖來訪問
• Go語言特有的，也是Go語言推薦的 CSP(communicating sequential processes)併發模型。

package main 

import ("fmt")

func main() {
    jobs := make(chan int)
    done := make(chan bool)  // end flag
    
    go func() {
        for {
            j, ok := <- jobs 
            fmt.Println("---->:", j, ok)
            if ok {
                fmt.Println("received job")
            } else {
                fmt.Println("end received jobs")
                done <- true
                return
            }
        }
    }()
    
    go func() {
        for j:= 1; j <= 3; j++ {
            jobs <-j
            fmt.Println("sent job", j)
        }
        close(jobs)
        fmt.Println("close(jobs)")
    }()
    
    fmt.Println("sent all jobs")
    <-done  // 阻塞 讓main等待協程完成
}

Go的CSP併發模型是通過goroutine 和 channel來實現的。

• goroutine是go語言中併發的執行單位。
• channel是Go語言中各個併發結構體之間的通信機制。
  • channel -< data 寫數據
  • <- channel 讀數據

協程本質上來說是一種用戶態的線程，不需要系統來執行搶佔式調度，而是在語言測個面實現線程的調度。

4. 併發

併發：Do not communicate by sharing memory; instead, share memory by communicate.

4.1 Actor模型

Actor模型和CSP模型的區別：

• CSP並不Focus發送消息的實體/Task， 而是關注發送消息時消息所使用的載體，即channel。
• 在Actor的設計中，Actor與信箱是耦合的，而在CSP中channel是作為first-class獨立存在的
• Actor中有明確的send/receive關係，而channel中並不區分這樣的關係，執行快可以任意選擇發送或者取消息

好文推薦：Go/Python/Erlang編程語言對比分析及示例

4.4 Go 協程調度器 GPM

• G 指的是Goroutine，其本質上也是一種輕量級的線程
• P proessor， 代表M所需要的上下文環境，也是處理用戶級代碼邏輯處理器。同一時間只有一個線程(M)可以擁有P, P中的數據都是鎖自由(lock free)的, 讀寫這些數據的效率會非常的高
• M Machine，一個M直接關聯一個內核線程，可以運行go代碼 即goroutine, M運行go代碼需要一個P, 另外就是運行原生代碼，如 syscall。運行原生代碼不需要P。

一個M會對應一個內核線程，一個M也會連接一個上下文P，一個上下文P相當於一個“處理器”，一個上下文連接一個或者多個Goroutine。P(Processor)的數量是在啟動時被設置為環境變量GOMAXPROCS的值，或者通過運行時調用函數runtime.GOMAXPROCS()進行設置

erlang和golang都是採用CSP模型，python中協程是eventloop模型。但是erlang是基於進程的消息通信，go是基於goroutine和channel通信。

python和golang都引入了消息調度系統模型，來避免鎖的影響和進程線程的開銷問題。

計算機科學領域的任何問題都可以通過增加一個間接的中間層來解決 — G-P-M模型正是此理論踐行者,此理論也用到了python的asyncio對地獄回調的處理上(使用Task+Future避免回調嵌套),是不是巧合?
其實異步≈可中斷的函數+事件循環+回調,go和python都把嵌套結構轉換成列表結構有點像算法中的遞歸轉迭代.

調度器在計算機中是分配工作時所需要的資源，Linux的調度是CPU找到可運行的線程，Go的調度是為M線程找到P(內存，執行票據)和可運行的G(協程)

Go協程是輕量級的，棧初始2KB（OS操作系統的線程一般都是固有的棧內存2M）， 調度不涉及系統調用，用戶函數調用前會檢查棧空間是否足夠，不夠的話，會進行站擴容，棧大小限制可以達到1GB。

Go的網絡操作是封裝了epoll， 為NonBlocking模式，切換協程不阻塞線程。

Go語言相比起其他語言的優勢在於OS線程是由OS內核來調度的，goroutine則是由Go運行時（runtime）自己的調度器調度的，這個調度器使用一個稱為m:n調度的技術（復用/調度m個goroutine到n個OS線程）。 其一大特點是goroutine的調度是在用戶態下完成的， 不涉及內核態與用戶態之間的頻繁切換，包括內存的分配與釋放，都是在用戶態維護着一塊大的內存池， 不直接調用系統的malloc函數（除非內存池需要改變），成本比調度OS線程低很多。 另一方面充分利用了多核的硬件資源，近似的把若干goroutine均分在物理線程上， 再加上本身goroutine的超輕量，以上種種保證了go調度方面的性能。點我了解更多

4.5 Go 調度器的實現 以及搶佔式調度

legendtkl阿里雲技術專家

Golang源碼探索(二) 協程的實現原理

相關參考文獻：

王道操作系統

操作系統中調度算法（FCFS、RR、SPN、SRT、HRRN）

Python協程與Go協程的區別二

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※幫你省時又省力,新北清潔一流服務好口碑

※回頭車貨運收費標準