前面幾章蜻蜓點水的介紹了elasticsearch、apm相關的內容。本片主要介紹怎麼使用ELK Stack幫助我們打造一個支撐起日產TB級的日誌監控系統

背景

在企業級的微服務環境中，跑着成百上千個服務都算是比較小的規模了。在生產環境上，日誌扮演着很重要的角色，排查異常需要日誌，性能優化需要日誌，業務排查需要業務等等。然而在生產上跑着成百上千個服務，每個服務都只會簡單的本地化存儲，當需要日誌協助排查問題時，很難找到日誌所在的節點。也很難挖掘業務日誌的數據價值。那麼將日誌統一輸出到一個地方集中管理，然後將日誌處理化，把結果輸出成運維、研發可用的數據是解決日誌管理、協助運維的可行方案，也是企業迫切解決日誌的需求。

我們的解決方案

通過上面的需求我們推出了日誌監控系統。

• 日誌統一收集、過濾清洗。
• 生成可視化界面、監控，告警，日誌搜索。

功能流程概覽

• 在每個服務節點上埋點，實時採集相關日誌。
• 統一日誌收集服務、過濾、清洗日誌後生成可視化界面、告警功能。

我們的架構

1. 日誌文件採集端我們使用filebeat,運維通過我們的後台管理界面化配置，每個機器對應一個filebeat，每個filebeat日誌對應的topic可以是一對一、多對一，根據日常的日誌量配置不同的策略。除了採集業務服務日誌外，我們還收集了mysql的慢查詢日誌和錯誤日誌,還有別的第三方服務日誌，如:nginx等。最後結合我們的自動化發布平台，自動發布並啟動每一個filebeat進程。
2. 調用棧、鏈路、進程監控指標我們使用的代理方式：Elastic APM，這樣對於業務側的程序無需任何改動。對於已經在運營中的業務系統來說，為了加入監控而需要改動代碼，那是不可取的，也是無法接受的。Elastic APM可以幫我們收集http接口的調用鏈路、內部方法調用棧、使用的sql、進程的cpu、內存使用指標等。可能有人會有疑問，用了Elastic APM，其它日誌基本都可以不用採集了。還要用filebeat幹嘛？是的，Elastic APM採集的信息確實能幫我們定位80%以上的問題，但是它不是所有的語言都支持的比如：C。其二、它無法幫你採集你想要的非error日誌和所謂的關鍵日誌，比如：某個接口調用時出了錯，你想看出錯時間點的前後日誌；還有打印業務相關方便做分析的日誌。其三、自定義的業務異常，該異常屬於非系統異常，屬於業務範疇，APM會把這類異常當成系統異常上報，如果你後面對系統異常做告警，那這些異常將會幹擾告警的準確度，你也不能去過濾業務異常，因為自定義的業務異常種類也不少。
3. 同時我們對agent進行了二開。採集更詳細的gc、堆棧、內存、線程信息。
4. 服務器採集我們採用普羅米修斯。
5. 由於我們是saas服務化，服務N多，很多的服務日誌做不到統一規範化，這也跟歷史遺留問題有關，一個與業務系統無關的系統去間接或直接地去對接已有的業務系統，為了適配自己而讓其更改代碼，那是推不動的。牛逼的設計是讓自己去兼容別人，把對方當成攻擊自己的對象。很多日誌是沒有意義的，比如：開發過程中為了方便排查跟蹤問題，在if else里打印只是有標誌性的日誌，代表是走了if代碼塊還是else代碼塊。甚至有些服務還打印着debug級別的日誌。在成本、資源的有限條件下，所有所有的日誌是不現實的，即使資源允許，一年下來將是一比很大的開銷。所以我們採用了過濾、清洗、動態調整日誌優先級採集等方案。首先把日誌全量採集到kafka集群中，設定一個很短的有效期。我們目前設置的是一個小時，一個小時的數據量，我們的資源暫時還能接受。
6. Log Streams是我們的日誌過濾、清洗的流處理服務。為什麼還要ETL過濾器呢？因為我們的日誌服務資源有限，但不對啊，原來的日誌分散在各各服務的本地存儲介質上也是需要資源的哈。現在我們也只是彙集而已哈，收集上來后，原來在各服務上的資源就可以釋放掉日誌佔用的部分資源了呀。沒錯，這樣算確實是把原來在各服務上的資源化分到了日誌服務資源上來而已，並沒有增加資源。不過這隻是理論上的，在線上的服務，資源擴大容易，收縮就沒那麼容易了，實施起來極其困難。所以短時間內是不可能在各服務上使用的日誌資源化分到日誌服務上來的。這樣的話，日誌服務的資源就是當前所有服務日誌使用資源的量。隨存儲的時間越長，資源消耗越大。如果解決一個非業務或非解決不可的問題，在短時間內需要投入的成本大於解決當前問題所帶來收益的話，我想，在資金有限的情況下，沒有哪個領導、公司願意採納的方案。所以從成本上考慮，我們在Log Streams服務引入了過濾器，過濾沒有價值的日誌數據，從而減少了日誌服務使用的資源成本。技術我們採用Kafka Streams作為ETL流處理。通過界面化配置實現動態過濾清洗的規則：

• 界面化配置日誌採集。默認error級別的日誌全量採集
• 以錯誤時間點為中心，在流處理中開窗，輻射上下可配的N時間點採集非error級別日誌，默認只採info級別
• 每個服務可配100個關鍵日誌，默認關鍵日誌全量採集
• 在慢sql的基礎上，按業務分類配置不同的耗時再次過濾
• 按業務需求實時統計業務sql,比如：高峰期階段，統計一小時內同類業務sql的查詢頻率。可為dba提供優化數據庫的依據，如按查詢的sql創建索引
• 高峰時段按業務類型的權重指標、日誌等級指標、每個服務在一個時段內日誌最大限制量指標、時間段指標等動態清洗過濾日誌 
• 根據不同的時間段動態收縮時間窗口
• 日誌索引生成規則：按服務生成的日誌文件規則生成對應的index，比如：某個服務日誌分為：debug、info、error、xx_keyword，那麼生成的索引也是debug、info、error、xx_keyword加日期作後綴。這樣做的目的是為研發以原習慣性地去使用日誌

    7. 可視化界面我們主要使用grafana，它支持的眾多數據源中，其中就有普羅米修斯和elasticsearch，與普羅米修斯可謂是無縫對接。而kibana我們主要用於apm的可視分析

日誌可視化

【版權聲明】

本文版權歸作者(深圳伊人網網絡有限公司)和博客園共有，歡迎轉載，但未經作者同意必須在文章頁面給出原文鏈接，否則保留追究法律責任的權利。如您有任何商業合作或者授權方面的協商，請給我留言：siqing0822@163.com

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※教你寫出一流的銷售文案?

※別再煩惱如何寫文案,掌握八大原則!

Linux 服務器我們天天打交道，特別是 Linux 工程師更是如此。為了保證服務器的安全與性能，我們經常需要監控服務器的一些狀態，以保證工作能順利開展。

本文介紹的幾個命令，不僅僅適用於服務器監控，也適用於我們日常情況下的開發。

1. watch

watch 命令我們的使用頻率很高，它的基本作用是，按照指定頻率重複執行某一條指令。使用這個命令，我們可以重複調用一些命令來達到監控服務器的作用。

默認情況下，watch 命令的執行周期是 2 秒，但我們可以使用 -n 選項來指定運行頻率，比如我們想要每隔 5 秒執行 date 命令，可以這麼執行：

$ watch -n 5 date

一台服務器肯定有多人在用，特別是本部門的小夥伴。對於這些小夥伴有沒渾水摸魚，我們可以使用一些命令來監控他們。

我們可以每隔 10 秒執行 who 命令，來看看都有誰在使用服務器。

$ watch -n 10 who
Every 10.0s: who                             butterfly: Tue Jan 23 16:02:03 2019

shs      :0           2019-01-23 09:45 (:0)
dory     pts/0        2019-01-23 15:50 (192.168.0.5)
alvin     pts/1        2019-01-23 16:01 (192.168.0.15)
shark    pts/3        2019-01-23 11:11 (192.168.0.27)

如果發現系統運行很慢，我們可以調用 uptime 命令來查看系統平均負載情況。

$ watch uptime
Every 2.0s: uptime                           butterfly: Tue Jan 23 16:25:48 2019

 16:25:48 up 22 days,  4:38,  3 users,  load average: 1.15, 0.89, 1.02

一些關鍵的進程肯定不能掛，否則可能會影響到業務開展，所以我們可以重複統計服務器中的所有進程數量。

$ watch -n 5 'ps -ef | wc -l'
Every 5.0s: ps -ef | wc -l                   butterfly: Tue Jan 23 16:11:54 2019

245

想動態知道服務器內存使用情況，可以重複執行 free 命令。

$ watch -n 5 free -m
Every 5.0s: free -m                          butterfly: Tue Jan 23 16:34:09 2019

              total        used        free      shared  buff/cache   available
Mem:           5959         776        3276          12        1906        4878
Swap:          2047           0        2047

當然不僅僅是這些，我們還可以重複調用很多命令來對服務器一些關鍵參數進行監控，

2. top

使用 top 命令我們可以知道系統的很多關鍵參數，而且是動態更新的。默認情況下，top 監控的是系統的整體狀態，如果我們只想知道某個人的使用情況，可以使用 -u 選項來指定這個人。

$ top -u alvin
top - 16:14:33 up 2 days,  4:27,  3 users,  load average: 0.00, 0.01, 0.02
Tasks: 199 total,   1 running, 198 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.0 us,  0.2 sy,  0.0 ni, 99.8 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   5959.4 total,   3277.3 free,    776.4 used,   1905.8 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   4878.4 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
23026 alvin      20   0   46340   7820   6504 S   0.0   0.1   0:00.05 systemd
23033 alvin      20   0  149660   3140     72 S   0.0   0.1   0:00.00 (sd-pam)
23125 alvin      20   0   63396   5100   4092 S   0.0   0.1   0:00.00 sshd
23128 alvin      20   0   16836   5636   4284 S   0.0   0.1   0:00.03 zsh

在這個結果里，你不僅僅可以看到 alvin 這個用戶運行的所有的進程數，也可以看到每個進程所消耗的系統資源（CPU，內存），同時依然可以看到整個系統的關鍵參數。

3. ac

如果你想知道每個用戶登錄服務器所使用的時間，你可以使用 ac 命令。這個命令需要你安裝 acct 包（Debian）或 psacct 包（RHEL，Centos）。

如果我們想知道所有用戶登陸服務器所使用的時間之和，我們可以直接運行 ac 命令，無需任何參數。

$ ac
        total     1261.72

如果我們想知道各個用戶所使用時間，可以加上 -p 選項。

$ ac -p
        shark                                5.24
        alvin                                5.52
        shs                               1251.00
        total     1261.76

我們還可以通過加上 -d 選項來查看具體每一天用戶使用服務器時間之和。

$ ac -d | tail -10
Jan 11  total        0.05
Jan 12  total        1.36
Jan 13  total       16.39
Jan 15  total       55.33
Jan 16  total       38.02
Jan 17  total       28.51
Jan 19  total       48.66
Jan 20  total        1.37
Jan 22  total       23.48
Today   total        9.83

小結

我們可以使用很多命令來監控系統的運行狀態，本文主要介紹了三個：watch 命令可以讓你重複執行某一條命令來監控一些參數的變化，top 命令可以查看某個用戶運行的進程數以及消耗的資源，而 ac 命令則可以查看每個用戶使用服務器時間。你經常使用哪個命令呢？歡迎留言討論！

公眾號：良許Linux

有收穫？希望老鐵們來個三連擊，給更多的人看到這篇文章

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

※回頭車貨運收費標準

所有知識體系文章，GitHub已收錄，歡迎Star！再次感謝，願你早日進入大廠！

GitHub地址： https://github.com/Ziphtracks/JavaLearningmanual

Java註解

一、Java註解概述

註解（Annotation），也叫元數據。一種代碼級別的說明。它是JDK1.5及以後版本引入的一個特性，與類、接口、枚舉是在同一個層次。它可以聲明在包、類、字段、方法、局部變量、方法參數等的前面，用來對這些元素進行說明，註釋。

二、註解的作用分類

• 編寫文檔： 通過代碼里標識的元數據生成文檔【生成文檔doc文檔】
• 代碼分析： 通過代碼里標識的元數據對代碼進行分析【使用反射】
• 編譯檢查： 通過代碼里標識的元數據讓編譯器能夠實現基本的編譯檢查【Override等】

編寫文檔

首先，我們要知道Java中是有三種註釋的，分別為單行註釋、多行註釋和文檔註釋。而文檔註釋中，也有@開頭的元註解，這就是基於文檔註釋的註解。我們可以使用javadoc命令來生成doc文檔，此時我們文檔的內元註解也會生成對應的文檔內容。這就是編寫文檔的作用。

代碼分析

我們頻繁使用之一，也是包括使用反射來通過代碼里標識的元數據對代碼進行分析的，此內容我們在後續展開講解。

編譯檢查

至於在編譯期間在代碼中標識的註解，可以用來做特定的編譯檢查，它可以在編譯期間就檢查出“你是否按規定辦事”，如果不按照註解規定辦事的話，就會在編譯期間飄紅報錯，並予以提示信息。可以就可以為我們代碼提供了一種規範制約，避免我們後續在代碼中處理太多的代碼以及功能的規範。比如，@Override註解是在我們覆蓋父類（父接口）方法時出現的，這證明我們覆蓋方法是繼承於父類（父接口）的方法，如果該方法稍加改變就會報錯；@FunctionInterface註解是在編譯期檢查是否是函數式接口的，如果不遵循它的規範，同樣也會報錯。

三、jdk的內置註解

3.1 內置註解分類

• @Override： 標記在成員方法上，用於標識當前方法是重寫父類（父接口）方法，編譯器在對該方法進行編譯時會檢查是否符合重寫規則，如果不符合，編譯報錯。
• @Deprecated： 用於標記當前類、成員變量、成員方法或者構造方法過時如果開發者調用了被標記為過時的方法，編譯器在編譯期進行警告。
• @SuppressWarnings： 壓制警告註解，可放置在類和方法上，該註解的作用是阻止編譯器發出某些警告信息。

3.2 @Override註解

標記在成員方法上，用於標識當前方法是重寫父類（父接口）方法，編譯器在對該方法進行編譯時會檢查是否符合重寫規則，如果不符合，編譯報錯。

這裏解釋一下@Override註解，在我們的Object基類中有一個方法是toString方法，我們通常在實體類中去重寫此方法來達到打印對象信息的效果，這時候也會發現重寫的toString方法上方就有一個@Override註解。如下所示：

image-20200604203535421

於是，我們試圖去改變重寫后的toString方法名稱，將方法名改為toStrings。你會發現在編譯期就報錯了！如下所示：

image-20200604203645332

那麼這說明什麼呢？這就說明該方法不是我們重寫其父類（Object）的方法。這就是@Override註解的作用。

3.3 @Deprecated註解

用於標記當前類、成員變量、成員方法或者構造方法過時如果開發者調用了被標記為過時的方法，編譯器在編譯期進行警告。

我們解釋@Deprecated註解就需要模擬一種場景了。假設我們公司的產品，目前是V1.0版本，它為用戶提供了show1方法的功能。這時候我們為產品的show1方法的功能又進行了擴展，打算髮布V2.0版本。但是，我們V1.0版本的產品需要拋棄嗎？也就是說我們V1.0的產品功能還繼續讓用戶使用嗎？答案肯定是不能拋棄的，因為有一部分用戶是一直用V1.0版本的。如果拋棄了該版本會損失很多的用戶量，所以我們不能拋棄該版本。這時候，我們對功能進行了擴展后，發布了V2.0版本，我們給予用戶的通知就可以了，也就是告知用戶我們在V2.0版本中為功能進行了擴展。可以讓用戶自行選擇版本。

但是，除了發布告知用戶版本情況之外，我們還需要在原來版本的功能上給予提示，在上面的模擬場景中我們需要在show1方法上方加@Deprecated註解給予提示。通過這種方式也告知用戶“這是舊版本時候的功能了，我們不建議再繼續使用舊版本的功能”，這句話的意思也就正是給用戶做了提示。用戶也會這麼想“奧，這版本的這個功能不好用了，肯定有新版本，又更好用的功能。我要去官網查一下下載新版本”，還會有用戶這麼想“我明白了，又更新出更好的功能了，但是這個版本的功能我已經夠用了，不需要重新下載新版本了”。

那麼我們怎麼查看我上述所說的在功能上給予的提示呢？這時候我需要去創建一個方法，然後去調用show1方法，並查看調用時它是如何提示的。

圖已經貼出來了，你是否發現的新舊版本功能的異同點呢？很明顯，在方法中的提示是在調用的方法名上加了一道橫線把該方法劃掉了。這就體現了show1方法過時了，已經不建議使用了，我們為你提供了更好的。

回想起來，在我們的api中也會有方法是過時的，比如我們的Date日期類中的方法有很多都已經過時了。如下圖：

image-20200604210154348 image-20200604210416762

如你所見，是不是有很多方法都過時了呢？那它的方法上是加了@Deprecated註解嗎？來跟着我的腳步，我帶你們看一下。

我們已經知道的Date類中的這些方法已經是過時的了，如果我們使用該方法並執行該程序的話。執行的過程中就會提示該方法已過時的內容，但是只是提示，並不影響你使用該方法。如下：

image-20200604221938895

OK！這也就是@Deprecated註解的作用了。

3.4 @SuppressWarnings註解

壓制警告註解，可放置在類和方法上，該註解的作用是阻止編譯器發出某些警告信息，該註解為單值註解，只有 一個value參數，該參數為字符串數組類型，參數值常用的有如下幾個。

• unchecked：未檢查的轉化，如集合沒有指定類型還添加元素
• unused：未使用的變量
• resource：有泛型未指定類型
• path：在類路徑，原文件路徑中有不存在的路徑
• deprecation：使用了某些不贊成使用的類和方法
• fallthrough：switch語句執行到底沒有break關鍵字
• rawtypes：沒有寫泛型，比如: List list = new ArrayList();
• all：全部類型的警告

壓制警告註解，顧名思義就是壓制警告的出現。我們都知道，在Java代碼的編寫過程中，是有很多黃色警告出現的。但是我不知道你的導師是否教過你，程序員只需要處理紅色的error，不需要理會黃色的warning。如果你的導師說過此問題，那是有原因的。因為在你學習階段，我們認清處理紅色的error即可，這樣可以減輕你學習階段在腦部的記憶內容。如果你剛剛加入學習Java的隊列中，需要大腦記憶的東西就有太多了，也就是我們目前不需要額外記憶其他的東西，只記憶重點即可。至於黃色warning嘛，在你的學習過程中慢慢就會有所了解的，而不是死記硬背的。

那為了解釋@SuppressWarnings註解，我們還使用上一個例子，因為在那個例子中就有黃色的warning出現。

而每一個黃色的warning都會有警告信息的。比如，這一個圖中的警告信息，就告知你show2()方法沒有被使用，簡單來說，你創建的show2方法，但是你在代碼中並沒有調用過此方法。以後你便會遇到各種各樣黃色的warning。然後， 我們就可以使用不同的註解參數來壓制不同的註解。但是在該註解的參數中，提供了一個all參數可以壓制全部類型的警告。而這個註解是需要加到類的上方，並賦予all參數，即可壓制所有警告。如下：

image-20200604213943722

我們加入註解並賦予all參數后，你會發現use方法和show2方法的警告沒有了，實際上導Date包的警告還在，因為我們Date包導入到了該類中，但是我們並沒有創建Date對象，也就是並沒有寫入Date在代碼中，你也會發現那一行是灰色的，也就證明了我們沒有去使用導入這個包的任何信息的說法，出現這種情況我們就需要把這個沒有用的導包內容刪除掉，使用Ctrl + X刪除導入沒有用到的包即可。還有一種辦法就是在包的上方修飾壓制警告註解，但是我認為在一個沒有用的包上加壓制註解是毫無意義的，所以，我們直接刪除就好。

然後，我們還見到上圖，註解那一行出現了警告信息提示。這一行的意思是冗餘的警告壓制。這就是說我們壓制以下的警告並沒有什麼意義而造成的冗餘，但是如果我們使用了該類並做了點什麼的話，壓制註解的冗餘警告就會消失，畢竟我們使用了該類，此時就不會早場冗餘了。

上述解釋@SuppressWarnings註解也差不多就這些了。OK，繼續向下看吧。持續為大家講解。

3.5 @Repeatable註解

@Repeatable 表明標記的註解可以多次應用於相同的聲明或類型，此註解由Java8版本引入。我們知道註解是不能重複定義的，其實該註解就是一個語法糖，它可以重複多此使用，更適用於我們的特殊場景。

首先，我們先創建一個可以重複使用的註解。

package com.mylifes1110.anno;

import java.lang.annotation.Repeatable;

@Repeatable(Hour.class)
public @interface Hours {
    double[] hours() default 0;
}

你會發現註解要求傳入的值是一個類對象，此類對象就需要傳入另外一個註解，這裏也就是另外一個註解容器的類對象。我們去創建一下。

package com.mylifes1110.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//容器
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Hour {
    Hours[] value();
}

其實，這兩個註解的套用，就是將一個普通的註解封裝了一個可重複使用的註解，來達到註解的復用性。最後，我們創建一下測試類，隨後帶你去看一下源碼。

package com.mylifes1110.java;

import com.mylifes1110.anno.Hours;

@Hours(hours = 4)
@Hours(hours = 4.5)
@Hours(hours = 2)
public class Worker {
    public static void main(String[] args) {
        //通過Hours註解類型來獲取Worker中的值數組對象
        Hours[] hours = Worker.class.getAnnotationsByType(Hours.class);
        //遍曆數組
        for (Hours h : hours) {
            System.out.println(h);
        }
    }
}

測試類，是一個工人測試類，該工人使用註解記錄早中晚的工作時間。測試結果如下：

image-20200606183652359

然後我們進入到源碼一探究竟。

image-20200606183737877

我們發現進入到源碼后，就只看見一個返回值為類對象的抽象方法。這也就驗證了該註解只是一個可實現重複性註解的語法糖而已。

四、註解分類

4.1 註解分類

註解可以根據註解參數分為三大類：

• 標記註解： 沒有參數的註解，僅用自身的存在與否為程序提供信息，如@Override註解，該註解沒有參數，用於表示當前方法為重寫方法。
• 單值註解： 只有一個參數的註解，如果該參數的名字為value，那麼可以省略參數名，如 @SuppressWarnings(value = “all”)，可以簡寫為@SuppressWarnings(“all”)。
• 完整註解： 有多個參數的註解。

4.2 標記註解

說到@Override註解是一個標記註解，那我們進入到該註解的源碼查看一下。從上往下看該註解源碼，發現它繼承了導入了java.lang.annotation.*，也就是有使用到該包的內容。然後下面就又是兩個看不懂的註解，其實發現註解的定義格式是public修飾的@Interface，最終看到該註解中方法體並沒有任何參數，也就是只起到標記作用。

4.3 單值註解

在上面我們用到的@SuppressWarnings註解就是一個單值註解。那我們進入到它的源碼看一下是怎麼個情況。其實，和標記註解比較，它就多一個value參數而已，而這就是單值註解的必要條件，即只有一個參數。並且這一個參數為value時，我們可以省略value。

4.4 完整註解

上述兩個類型註解講解完，至於完整註解嘛，這下就能更明白了。其中的方法體就是有多個參數而已。

五、自定義註解

5.1 自定義註解格式

格式： public @Interface 註解名 {屬性列表/無屬性}

注意： 如果註解體中無任何屬性，其本質就是標記註解。但是與其標註註解還少了上邊修飾的元註解。

如下，這就是一個註解。但是它與jdk自定義註解有點區別，jdk自定義註解的上方還有註解來修飾該註解，而那註解就叫做元註解。元註解我會在後面詳細的說到。

image-20200606104149069

這裏我們的確不知道@Interface是什麼，那我們就把自定義的這個註解反編譯一下，看一下反編譯信息。反編譯操作如下：

image-20200606104818131

反編譯后的反編譯內容如下：

public interface com.mylifes1110.anno.MyAnno extends java.lang.annotation.Annotation {
}

首先，看過反編譯內容后，我們可以直觀的得知他是一個接口，因為它的public修飾符後面的關鍵字是interface。

其次，我們發現MyAnno這個接口是繼承了java.lang.annotation包下的Annotation接口。

所以，我們可以得知註解的本質就是一個接口，該接口默認繼承了Annotation接口。

既然，是繼承的Annotation接口，那我們就去進入到這個接口中，看它定義了什麼。以下是我抽取出來的接口內容。我們發現它看似很常見，其實它們不是很常用，作為了解即可。

public interface Annotation {
    boolean equals(Object obj);
    int hashCode();
    String toString();
    Class<? extends Annotation> annotationType();
}

最後，我們的註解中也是可以寫有屬性的，它的屬性不同於普通的屬性，它的屬性是抽象方法。既然註解也是一個接口，那麼我們可以說接口體中可以定義什麼，它同樣也可以定義，而它的修飾符與接口一樣，也是默認被public abstract修飾。

而註解體中的屬性也是有要求的。其屬性要求如下：

• 屬性的返回值類型必須是以下幾種：
• 基本數據類型
• String類型
• 枚舉類型
• 註解
• 以上類型的數組
• 注意： 在這裏不能有void的無返回值類型和以上類型以外的類型
• 定義的屬性，在使用時需要給註解中的屬性賦值
• 如果定義屬性時，使用default關鍵字給屬性默認初始化值，則使用註解時可以不為屬性賦值，它取的是默認值。如果為它再次傳入值，那麼就發生了對原值的覆蓋。
• 如果只有一個屬性需要賦值，並且屬性的名稱為value，則賦值時value可以省略，可以直接定義值
• 數組賦值時，值使用{}存儲值。如果數組中只有一個值，則可以省略{}。

5.2 自定義註解屬性的返回值

屬性返回值既然有以上幾種，那麼我就在這裏寫出這幾種演示一下是如何寫的。

首先，定義一個枚舉類和另外一個註解備用。

package com.mylifes1110.enums;

public enum Lamp {
    RED, GREEN, YELLOW
}

package com.mylifes1110.anno;

public @interface MyAnno2 {
}

其次，我們來定義上述幾種類型，如下：

package com.mylifes1110.anno;

import com.mylifes1110.enums.Lamp;

public @interface MyAnno {
    //基本數據類型
    int num();

    //String類型
    String value();

    //枚舉類型
    Lamp lamp();

    //註解類型
    MyAnno2 myAnno2();

    //以上類型的數組
    String[] values();
    Lamp[] lamps();
    MyAnno2[] myAnno2s();
    int[] nums();
}

5.3 自定義註解的屬性賦值

這裏我們演示一下，首先，我們使用該註解來進行演示。

package com.mylifes1110.anno;

public @interface MyAnno {
    //基本數據類型
    int num();

    //String類型
    String value();
}

隨後創建一個測試類，在類的上方寫上註解，你會發現，註解的參數中會讓你寫這兩個參數（int、String）。

image-20200606113037920

此時，傳參是這樣來做的。格式為：名稱 = 返回值類型參數。如下：

上述所說，如果使用default關鍵字給屬性默認初始化值，就不需要為其參數賦值，如果賦值的話，就把默認初始化的值覆蓋掉了。

當然還有一個規則，如果只有一個屬性需要賦值，並且屬性的名稱為value，則賦值時value可以省略，可以直接定義值。那麼，我們的num已經有了默認值，就可以不為它傳值。我們發現，註解中定義的屬性就剩下了一個value屬性值，那麼我們就可以來演示這個規則了。

image-20200606113849685

這裏，我並沒有寫屬性名稱value，而是直接為value賦值。如果我將num的default關鍵字修飾去掉呢，那意思也就是說在使用該註解時必須為num賦值，這樣可以省略value嗎？那我們看一下。

image-20200606114216801

結果，就是我們所想的，它報錯了，必須讓我們給num賦值。其實想想這個規則也是很容易懂的，定義一個為value的值，就可以省略其value名稱。如果定義多個值，它們可以省略名稱就無法區分定義的是那個值了，關鍵是還有數組，數組內定義的是多個值呢，對吧。

5.4 自定義註解的多種返回值類型賦值

這裏我們演示一下，上述的多種返回值類型是如何賦值的。這裏我們定義這幾個參數來看一下，是如何為屬性賦值的。

num是一個int基本數據類型，即num = 1

value是一個String類型，即value = "str"

lamp是一個枚舉類型，即lamp = Lamp.RED

myAnno2是一個註解類型，即myAnno2 = @MyAnno2

values是一個String類型數組，即values = {"s1", "s2", "s3"}

values是一個String類型數組，其數組中只有一個值，即values = "s4"

注意： 值與值之間是,隔開的；數組是用{}來存儲值的，如果數組中只有一個值可以省略{}；枚舉類型是枚舉名.枚舉值

六、元註解

6.1 元註解分類

元註解就是用來描述註解的註解。一般使用元註解來限制自定義註解的使用範圍、生命周期等等。

而在jdk的中java.lang.annotation包中定義了四個元註解，如下：

元註解	描述
@Target	指定被修飾的註解的作用範圍
@Retention	指定了被修飾的註解的生命周期
@Documented	指定了被修飾的註解是可以Javadoc等工具文檔化
@Inherited	指定了被修飾的註解修飾程序元素的時候是可以被子類繼承的

6.2 @Target

@Target 指定被修飾的註解的作用範圍。其作用範圍可以在源碼中找到參數值。

屬性	描述
CONSTRUCTOR	用於描述構造器
FIELD（常用）	用於描述屬性
LOCAL_VARIABLE	用於描述局部變量
METHOD（常用）	用於描述方法
PACKAGE	用於描述包
PARAMETER	用於描述參數
TYPE（常用）	用於描述類、接口(包括註解類型) 或enum聲明
ANNOTATION_TYPE	用於描述註解類型
TYPE_USE	用於描述使用類型

由此可見，該註解體內只有一個value屬性值，但是它的類型是一個ElementType數組。那我們進入到這個數組中繼續查看。

進入到該數組中，你會發現他是一個枚舉類，其中定義了上述表格中的各個屬性。

了解了@Target的作用和屬性值后，我們來使用一下該註解。首先，我們要先用該註解來修飾一個自定義註解，定義該註解的指定作用在類上。如下：

而你觀察如下測試類，我們把註解作用在類上時是沒有錯誤的。而當我們的註解作用在其他地方就會報錯。這也就說明了，我們@Target的屬性起了作用。

注意： 如果我們定義多個作用範圍時，也是可以省略該參數名稱了，因為該類型是一個數組，雖然能省略名稱但是，我們還需要用{}來存儲。

6.3 @Retention

@Retention 指定了被修飾的註解的生命周期

屬性	描述
RetentionPolicy.SOURCE	註解只在源碼階段保留，在編譯器進行編譯時它將被丟棄忽視。
RetentionPolicy.CLASS	註解只被保留到編譯進行時的class文件，但 JVM 加載class文件時候被遺棄，也就是在這個階段不會讀取到該class文件。
RetentionPolicy.RUNTIME（常用）	註解可以保留到程序運行的時候，它會被加載進入到 JVM 中，所以在程序運行時可以獲取到它們。

注意： 我們常用的定義即是RetentionPolicy.RUNTIME，因為我們使用反射來實現的時候是需要從JVM中獲取class類對象並操作類對象的。

首先，我們要了解反射的三個生命周期階段，這部分內容我在Java反射機制中也是做了非常詳細的說明，有興趣的小夥伴可以去看看我寫的Java反射機制，相信你在其中也會有所收穫。

這裏我再次強調一下這三個生命周期是源碼階段 – > class類對象階段 – > Runtime運行時階段。

那我們進入到源碼，看看@Retention註解中是否有這些參數。

我們看到該註解中的屬性只有一個value，而它的類型是一個RetentionPolicy類型，我們進入到該類型中看看有什麼參數，是否與表格中的參數相同呢？

image-20200606145449931

至於該註解怎麼使用，其實是相同的，用法如下：

這就證明了我們的註解可以保留到Runtime運行階段，而我們在反射中大多數是定義到Runtime運行時階段的，因為我們需要從JVM中獲取class類對象並操作類對象。

6.4 @Documented

@Documented 指定了被修飾的註解是可以Javadoc等工具文檔化

@Documented註解是比較好理解的，它是一個標記註解。被該標記註解標記的註解，生成doc文檔時，註解是可以被加載到文檔中显示的。

image-20200606152526551

還拿api中過時的Date中的方法來說，在api中显示Date中的getYear方法是這樣的。

正如你看到的，註解在api中显示了出來，證明該註解是@Documented註解修飾並文檔化的。那我們就看看這個註解是否被@Documented修飾吧。

然後，我們發現該註解的確是被文檔化了。所以在api中才會显示該註解的。如果不信，你可以自己使用javadoc命令來生成一下doc文檔，看看被該註解修飾的註解是否存在。

至於Javadoc文檔生成，我在javadoc文檔生成一文中有過詳細記載，大家可以進行參考，生成doc文檔查看。

6.5 @Inherited

@Inherited 指定了被修飾的註解修飾程序元素的時候是可以被子類繼承的

首先進入到源碼中，我們也可以清楚的知道，該註解也是一個標記註解。而且它也是被文檔化的註解。

其次，我們去在自定義註解中，標註上@Inherited註解。

演示@Inherited註解，我需要創建兩個類，同時兩個類中有一層的繼承關係。如下：

我們在Person類中標記了@MyAnno註解，由於該註解被@Inherited註解修飾，我們就可以得出繼承於Person類的Student類也同樣被@MyAnno註解標記了，如果你要獲取該註解的值的話，肯定獲取的也是父類上註解值的那個”1″。

七、使用反射機制解析註解

自定義註解

package com.mylifes1110.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @InterfaceName Sign
 * @Description 描述需要執行的類名和方法名
 * @Author Ziph
 * @Date 2020/6/6
 * @Since 1.8
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Sign {
    String methodName();

    String className();
}

Cat

package com.mylifes1110.java;

/**
 * @ClassName Cat
 * @Description 描述一隻貓的類
 * @Author Ziph
 * @Date 2020/6/6
 * @Since 1.8
 */
public class Cat {
    /*
     * @Description 描述一隻貓吃魚的方法 
     * @Author Ziph
     * @Date 2020/6/6
     * @Param []
     * @return void
     */
    public void eat() {
        System.out.println("貓吃魚");
    }
}

準備好，上述代碼后，我們就可以開始編寫使用反射技術來解析註解的測試類。如下：

首先，我們先通過反射來獲取註解中的methodName和className參數。

package com.mylifes1110.java;

import com.mylifes1110.anno.Sign;

/**
 * @ClassName SignTest
 * @Description 要求創建cat對象並執行其類中eat方法
 * @Author Ziph
 * @Date 2020/6/6
 * @Since 1.8
 */
@Sign(className = "com.mylifes1110.java.Cat", methodName = "eat")
public class SignTest {
    public static void main(String[] args) {
        //獲取該類的類對象
        Class<SignTest> signTestClass = SignTest.class;
        //獲取類對象中的註解對象
        //原理實際上是在內存中生成了一個註解接口的子類實現對象
        Sign sign = signTestClass.getAnnotation(Sign.class);
        //調用註解對象中定義的抽象方法（註解中的屬性）來獲取返回值
        String className = sign.className();
        String methodName = sign.methodName();
        System.out.println(className);
        System.out.println(methodName);
    }
}

此時的打印結果證明我們已經成功獲取到了該註解的兩個參數。

image-20200606162810165

注意： 獲取類對象中的註解對象時，其原理實際上是在內存中生成了一個註解接口的子類實現對象並返回的字符串內容。如下：

public class SignImpl implements Sign {
    public String methodName() {
        return "eat";
    }

    public String className() {
        return "com.mylifes1110.java.Cat";
    }
}

繼續編寫我們後面的代碼，代碼完整版如下：

完整版代碼

package com.mylifes1110.java;

import com.mylifes1110.anno.Sign;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @ClassName SignTest
 * @Description 要求創建cat對象並執行其類中eat方法
 * @Author Ziph
 * @Date 2020/6/6
 * @Since 1.8
 */
@Sign(className = "com.mylifes1110.java.Cat", methodName = "eat")
public class SignTest {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //獲取該類的類對象
        Class<SignTest> signTestClass = SignTest.class;
        //獲取類對象中的註解對象
        //原理實際上是在內存中生成了一個註解接口的子類實現對象
        Sign sign = signTestClass.getAnnotation(Sign.class);
        //調用註解對象中定義的抽象方法（註解中的屬性）來獲取返回值
        String className = sign.className();
        String methodName = sign.methodName();
        //獲取className名稱的類對象
        Class<?> clazz = Class.forName(className);
        //創建對象
        Object o = clazz.newInstance();
        //獲取methodName名稱的方法對象
        Method method = clazz.getMethod(methodName);
        //執行該方法
        method.invoke(o);
    }
}

執行結果

執行后成功的調用了eat方法，並打印了貓吃魚的結果，如下：

八、自定義註解改變JDBC工具類

首先，我們在使用JDBC的時候是需要通過properties文件來獲取配置JDBC的配置信息的，這次我們通過自定義註解來獲取配置信息。其實使用註解並沒有用配置文件好，但是我們需要了解這是怎麼做的，獲取方法也是魚使用反射機制解析註解，所謂“萬變不離其宗”，它就是這樣的。

自定義註解

package com.mylifes1110.java.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @InterfaceName DBInfo
 * @Description 給予註解聲明周期為運行時並限定註解只能用在類上
 * @Author Ziph
 * @Date 2020/6/6
 * @Since 1.8
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DBInfo {
    String driver() default "com.mysql.jdbc.Driver";

    String url() default "jdbc:mysql://localhost:3306/temp?useUnicode=true&characterEncoding=utf8";

    String username() default "root";

    String password() default "123456";
}

數據庫連接工具類

為了代碼的健全我也在裏面加了properties文件獲取連接的方式。

package com.mylifes1110.java.utils;

import com.mylifes1110.java.anno.DBInfo;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * @ClassName DBUtils
 * @Description 數據庫連接工具類
 * @Author Ziph
 * @Date 2020/6/6
 * @Since 1.8
 */
@DBInfo()
public class DBUtils {
    private static final Properties PROPERTIES = new Properties();
    private static String driver;
    private static String url;
    private static String username;
    private static String password;

    static {
        Class<DBUtils> dbUtilsClass = DBUtils.class;
        boolean annotationPresent = dbUtilsClass.isAnnotationPresent(DBInfo.class);
        if (annotationPresent) {
            /**
             * DBUilts類上有DBInfo註解，並獲取該註解
             */
            DBInfo dbInfo = dbUtilsClass.getAnnotation(DBInfo.class);
//            System.out.println(dbInfo);
            driver = dbInfo.driver();
            url = dbInfo.url();
            username = dbInfo.username();
            password = dbInfo.password();
        } else {
            InputStream inputStream = DBUtils.class.getResourceAsStream("db.properties");
            try {
                PROPERTIES.load(inputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() {
        try {
            return DriverManager.getConnection(url, username, password);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    public static void closeAll(Connection connection, Statement statement, ResultSet resultSet) {
        try {
            if (resultSet != null) {
                resultSet.close();
                resultSet = null;
            }

            if (statement != null) {
                statement.close();
                statement = null;
            }
            if (connection != null) {
                connection.close();
                connection = null;
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

測試類

package com.mylifes1110.java.test;

import com.mylifes1110.java.utils.DBUtils;

import java.sql.Connection;

/**
 * @ClassName GetConnectionDemo
 * @Description 測試連接是否可以獲取到
 * @Author Ziph
 * @Date 2020/6/6
 * @Since 1.8
 */
public class GetConnectionDemo {
    public static void main(String[] args) {
        Connection connection = DBUtils.getConnection();
        System.out.println(connection);
    }
}

測試結果

為了證明獲取的連接是由註解的配置信息獲取到的連接，我將properties文件中的所有配置信息刪除后測試的。

九、自定義@MyTest註解實現單元測試

我不清楚小夥伴們是否了解，Junit單元測試。@Test是單元測試的測試方法上方修飾的註解。此註解的核心原理也是由反射來實現的。如果有小夥伴不知道什麼是單元測試或者對自定義@MyTest註解實現單元測試感興趣的話，可以點進來看看哦！

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

※回頭車貨運收費標準

基於blazor實現的一個簡單的TODO List

最近看到一些大佬都開始關注blazor，我也想學習一下。做了一個小的demo，todolist，僅是一個小示例，參考此vue項目的實現http://www.jq22.com/code1339

先看實現的效果圖

不BB,直接可以去看

源碼與預覽地址

• 示例地址 http://baimocore.cn:8081/
• 源碼地址 BlazorAppTodoList

源碼介紹

我們這裏刪除了默認的一些源碼。只保留最簡單的結構,在Pages/Index.razor中。

@code代碼結構中寫如下內容

1. 創建一個類，裡面包含 id,label,isdone三個屬性值。

public class TodoItem
{
    public TodoItem () { }
    public TodoItem (int id, string label, bool isDone)
    {
        Id = id;
        Label = label;
        IsDone = isDone;
    }
    public int Id { get; set; }
    public string Label { get; set; }
    public bool IsDone { get; set; }
}

1. 我們可以通過override重寫初始化，並給Todos設置一些數據。

private IList<TodoItem> Todos;
private int id = 0;
protected override void OnInitialized ()
{
    Todos = new List<TodoItem> ()
    {
        new TodoItem (++id, "Learn Blazor", false),
        new TodoItem (++id, "Code a todo list", false),
        new TodoItem (++id, "Learn something else", false)
    };
}

展示還有多少未完成的任務

<h1>
        Todo List(@Todos.Count(todo => !todo.IsDone))
        <span>Get things done, one item at a time.</span>
</h1>

當任務沒有時，我們展示默認效果，提示用戶無任務

<p class="emptylist" style="display: @(Todos.Count()>0?"none":"");">Your todo list is empty.</p>

新增一個任務

<form name="newform">
    <label for="newitem">Add to the todo list</label>
    <input type="text" name="newitem" id="newitem" @bind-value="Label">
    <button type="button" @onclick="AddItem">Add item</button>
</form>

這裏我們用了一個Label變量，一個onclick事件。

private string Label;

private void AddItem()
{
    if (!string.IsNullOrWhiteSpace(Label))
    {
        Todos.Add (new TodoItem { Id = ++id, Label = Label });
        Label = string.Empty;
    }
    this.SortByStatus();
}

this.SortByStatus
因為我們這裏還實現一個功能，就是當勾選（當任務完成時，我們將他移到最下面）

<div class="togglebutton-wrapper@(IsActive==true?" togglebutton-checked":"")">
    <label for="todosort">
        <span class="togglebutton-Label">Move done items at the end?</span>
        <span class="tooglebutton-box"></span>
    </label>
    <input type="checkbox" name="todosort" id="todosort" value="@IsActive" @onchange="ActiveChanged">
</div>

一個IsActive的變量，用於指示當前checkbox的樣式，是否開啟已完成的任務移動到最下面。當勾選時，改變IsActive的值。並調用排序的功能。

private bool IsActive = false;
private void ActiveChanged()
{
    this.IsActive = !this.IsActive;
    this.SortByStatus();
}
private void SortByStatus()
{
    if (this.IsActive)
    {
        Todos = Todos.OrderBy(r => r.IsDone).ThenByDescending(r => r.Id).ToList();
    }
    else
    {
        Todos = Todos.OrderByDescending(r => r.Id).ToList();
    }
}

對於列表的展示我們使用如下ul li @for實現

<ul>
    @foreach (var item in Todos)
    {
        <li stagger="5000" class="@(item.IsDone?"done":"")">
            <span class="label">@item.Label</span>
            <div class="actions">
                <button class="btn-picto" type="button"
                        @onclick="@((e)=> {MarkAsDoneOrUndone(item);})"
                        title="@(item.IsDone ? "Undone" :"Done")"
                        aria-label="@(item.IsDone ? "Undone" :"Done")">
                    <i aria-hidden="true" class="material-icons">@(item.IsDone ? "check_box" : "check_box_outline_blank")</i>
                </button>
                <button class="btn-picto" type="button"
                        @onclick="@((e)=> { DeleteItemFromList(item); })"
                        aria-Label="Delete" title="Delete">
                    <i aria-hidden="true" class="material-icons">delete</i>
                </button>
            </div>
        </li>
    }
</ul>

循環Todos，然後，根據item.IsDone，改變li的樣式，從而實現一个中劃線的功能，二個按鈕的功能，一個是勾選任務表示此任務已完成，另一個是刪除此任務。同理，我們仍然通過IsDone來標識完成任務的圖標，標題等。

• 任務設置已完成/設置為未完成： @onclick調用方法MarkAsDoneOrUndone，並將當前的一行記錄item傳給方法，需要使用一個匿名函數調用@code中的方法,將isDone取相反的值，並重新排序。

private void MarkAsDoneOrUndone(TodoItem item)
{
    item.IsDone = !item.IsDone;
    this.SortByStatus();
}

• 刪除一個任務，同理，使用匿名函數，DeleteItemFromList直接通過IList的方法Remove刪除一個對象，並排序。

private void DeleteItemFromList(TodoItem item)
{
    Todos.Remove(item);
    this.SortByStatus();
}

當然，我們可以 在ul，外包裹一層,根據Count判斷有沒有任務，從而显示這個列表。

<div style="display: @(Todos.Count()>0?"":"none");"><ul>xxx</ul></div>

其他的樣式與圖標，請看最上面的源碼wwwroot/css目錄獲取。

deploy(部署)

• 有興趣的可以看官網 https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/blazor/?view=aspnetcore-3.1&tabs=visual-studio

在項目根目錄執行如下命令

dotnet publish -c Release

我們就能得到一個發布包，他的位置在 （BlazorAppTodoList\bin\Release\netstandard2.1\publish） ，我們把他複製到服務器上，這裏我放到/var/www/todolilst目錄中。

它相當於一個靜態文件，你可以將他部署到任何一個web服務器上。

這裏我們把他放到nginx中，並在目錄/etc/nginx/conf.d/ 新建一個文件 todolist.conf，然後放入如下內容。

 server {
        listen 8081;

        location / {
            root /var/www/todolist/wwwroot;
            try_files $uri $uri/ /index.html =404;
        }
}

記得在etc/nginx/nginx.conf中配置gzip壓縮。

gzip  on;
gzip_min_length 5k; #gzip壓縮最小文件大小，超出進行壓縮（自行調節）
gzip_buffers 4 16k; #buffer 不用修改
gzip_comp_level 8; #壓縮級別:1-10，数字越大壓縮的越好，時間也越長
gzip_types text/plain application/x-javascript application/javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png application/octet-stream; #  壓縮文件類型 
gzip_vary on; # 和http頭有關係，加個vary頭，給代理服務器用的，有的瀏覽器支持壓縮，有的不支持，所以避免浪費不支持的也壓縮，所以根據客戶端的HTTP頭來判斷，是否需要壓縮

我遇到dll，wasm，後綴的文件壓縮無效。因為gzip_types ，沒有配置他們的Content-Type。我們在瀏覽器中找到響應頭Content-Type: application/octet-stream,然後在上文中的nginx配置文件中，gzip_types加上application/octet-stream，

最後執行

nginx -t
nginx -s reload

打開網站看效果

http://baimocore.cn:8081

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※教你寫出一流的銷售文案?

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

Python 內存管理分層架構

/* An object allocator for Python.

   Here is an introduction to the layers of the Python memory architecture,
   showing where the object allocator is actually used (layer +2), It is
   called for every object allocation and deallocation (PyObject_New/Del),
   unless the object-specific allocators implement a proprietary allocation
   scheme (ex.: ints use a simple free list). This is also the place where
   the cyclic garbage collector operates selectively on container objects.


    Object-specific allocators
    _____   ______   ______       ________
   [ int ] [ dict ] [ list ] ... [ string ]       Python core         |
+3 | <----- Object-specific memory -----> | <-- Non-object memory --> |
    _______________________________       |                           |
   [   Python's object allocator   ]      |                           |
+2 | ####### Object memory ####### | <------ Internal buffers ------> |
    ______________________________________________________________    |
   [          Python's raw memory allocator (PyMem_ API)          ]   |
+1 | <----- Python memory (under PyMem manager's control) ------> |   |
    __________________________________________________________________
   [    Underlying general-purpose allocator (ex: C library malloc)   ]
 0 | <------ Virtual memory allocated for the python process -------> |

   =========================================================================
    _______________________________________________________________________
   [                OS-specific Virtual Memory Manager (VMM)               ]
-1 | <--- Kernel dynamic storage allocation & management (page-based) ---> |
    __________________________________   __________________________________
   [                                  ] [                                  ]
-2 | <-- Physical memory: ROM/RAM --> | | <-- Secondary storage (swap) --> |

*/

reference：Objects/obmalloc.c

layer 3: Object-specific memory(int/dict/list/string....)
		python 實現並維護
		用戶對Python對象的直接操作，主要是各類特定對象的緩衝池機制，緩衝池，比如小整數對象池等等
layer 2: Python's object allocator
		實現了創建/銷毀python對象的接口(PyObject_New/Del),涉及對象參數/引用計數等

layer 1: Python's raw memory allocator (PyMem_ API)
		包裝了第0層的內存管理接口，提供同一個raw memory管理接口
		封裝的原因：不同操作系統C行為不一致，保證可移植性，相同語義相同行為
		
layer 0: Underlying general-purpose allocator (ex: C library malloc)
		操作系統提供的內存管理接口，由操作系統實現並管理，Python不能干涉這一層的行為,大內存 分配調用malloc函數分配內存

Python 內存分配策略之-block,pool

Python中有分為大內存和小內存，512K為分界線

• 大內存使用系統malloc進行分配

• 小內存使用python內存池進行分配

1. 如果要分配的內存空間大於 SMALL_REQUEST_THRESHOLD bytes(512 bytes), 將直接使用layer 1的內存分配接口進行分配
2. 否則, 使用不同的block來滿足分配需求

申請一塊大小28字節的內存, 實際從內存中劃到32字節的一個block (從size class index為3的pool裏面劃出)

block

內存塊block 是python內存的最小單位

* For small requests we have the following table:
 *
 * Request in bytes     Size of allocated block      Size class idx
 * ----------------------------------------------------------------
 *        1-8                     8                       0
 *        9-16                   16                       1
 *       17-24                   24                       2
 *       25-32                   32                       3
 *       33-40                   40                       4
 *       41-48                   48                       5
 *       49-56                   56                       6
 *       57-64                   64                       7
 *       65-72                   72                       8
 *        ...                   ...                     ...
 *      497-504                 504                      62
 *      505-512                 512                      63
 *
 *      0, SMALL_REQUEST_THRESHOLD + 1 and up: routed to the underlying
 *      allocator.
 */

pool

pool內存池，管理block, 一個pool管理着一堆固定大小的內存塊，在Python中, 一個pool的大小通常為一個系統內存頁. 4kB

#define SYSTEM_PAGE_SIZE        (4 * 1024)
#define SYSTEM_PAGE_SIZE_MASK   (SYSTEM_PAGE_SIZE - 1)

#define POOL_SIZE               SYSTEM_PAGE_SIZE        /* must be 2^N */
#define POOL_SIZE_MASK          SYSTEM_PAGE_SIZE_MASK

pool的4kB內存 = pool_header + block集合(N多大小一樣的block)

typedef uint8_t block;

/* Pool for small blocks. */
struct pool_header {
    union { block *_padding;
            uint count; } ref;          /* number of allocated blocks    */
    block *freeblock;                   /* pool's free list head         */
    struct pool_header *nextpool;       /* next pool of this size class  */
    struct pool_header *prevpool;       /* previous pool       ""        */
    uint arenaindex;                    /* index into arenas of base adr */
    uint szidx;                         /* block size class index        */
    uint nextoffset;                    /* bytes to virgin block         */
    uint maxnextoffset;                 /* largest valid nextoffset      */
};

pool_header 作用

與其他pool鏈接, 組成雙向鏈表
2. 維護pool中可用的block, 單鏈表
3. 保存 szidx , 這個和該pool中block的大小有關係, (block size=8, szidx=0), (block size=16, szidx=1)...用於內存分配時匹配到擁有對應大小block的pool

pool 初始化

void *
PyObject_Malloc(size_t nbytes)
{
  ...

          init_pool:
            // 1. 連接到 used_pools 雙向鏈表, 作為表頭
            // 注意, 這裏 usedpools[0] 保存着 block size = 8 的所有used_pools的表頭
            /* Frontlink to used pools. */
            next = usedpools[size + size]; /* == prev */
            pool->nextpool = next;
            pool->prevpool = next;
            next->nextpool = pool;
            next->prevpool = pool;
            pool->ref.count = 1;

            // 如果已經初始化過了...這裏看初始化, 跳過
            if (pool->szidx == size) {
                /* Luckily, this pool last contained blocks
                 * of the same size class, so its header
                 * and free list are already initialized.
                 */
                bp = pool->freeblock;
                pool->freeblock = *(block **)bp;
                UNLOCK();
                return (void *)bp;
            }


            /*
             * Initialize the pool header, set up the free list to
             * contain just the second block, and return the first
             * block.
             */
            // 開始初始化pool_header
            // 這裏 size = (uint)(nbytes - 1) >> ALIGNMENT_SHIFT;  其實是Size class idx, 即szidx
            pool->szidx = size;

            // 計算獲得每個block的size
            size = INDEX2SIZE(size);

            // 注意 #define POOL_OVERHEAD           ROUNDUP(sizeof(struct pool_header))
            // bp => 初始化為pool + pool_header size,  跳過pool_header的內存
            bp = (block *)pool + POOL_OVERHEAD;

            // 計算偏移量, 這裏的偏移量是絕對值
            // #define POOL_SIZE               SYSTEM_PAGE_SIZE        /* must be 2^N */
            // POOL_SIZE = 4kb, POOL_OVERHEAD = pool_header size
            // 下一個偏移位置: pool_header size + 2 * size
            pool->nextoffset = POOL_OVERHEAD + (size << 1);
            // 4kb - size
            pool->maxnextoffset = POOL_SIZE - size;

            // freeblock指向 bp + size = pool_header size + size
            pool->freeblock = bp + size;

            // 賦值NULL
            *(block **)(pool->freeblock) = NULL;
            UNLOCK();
            return (void *)bp;
        }

pool 進行block分配 – 總體代碼

  if (pool != pool->nextpool) {   //
            /*
             * There is a used pool for this size class.
             * Pick up the head block of its free list.
             */
            ++pool->ref.count;
            bp = pool->freeblock; // 指針指向空閑block起始位置
            assert(bp != NULL);

            // 代碼-1
            // 調整 pool->freeblock (假設A節點)指向鏈表下一個, 即bp首字節指向的下一個節點(假設B節點) , 如果此時!= NULL
            // 表示 A節點可用, 直接返回
            if ((pool->freeblock = *(block **)bp) != NULL) {
                UNLOCK();
                return (void *)bp;
            }

            // 代碼-2
            /*
             * Reached the end of the free list, try to extend it.
             */
            // 有足夠的空間, 分配一個, pool->freeblock 指向後移
            if (pool->nextoffset <= pool->maxnextoffset) {
                /* There is room for another block. */
                // 變更位置信息
                pool->freeblock = (block*)pool +
                                  pool->nextoffset;
                pool->nextoffset += INDEX2SIZE(size);


                *(block **)(pool->freeblock) = NULL; // 注意, 指向NULL
                UNLOCK();

                // 返回bp
                return (void *)bp;
            }

            // 代碼-3
            /* Pool is full, unlink from used pools. */  // 滿了, 需要從下一個pool獲取
            next = pool->nextpool;
            pool = pool->prevpool;
            next->prevpool = pool;
            pool->nextpool = next;
            UNLOCK();
            return (void *)bp;
        }

pool進行block分配 -1

內存塊尚未分配完, 且此時不存在回收的block, 全新進來的時候, 分配第一塊block

(pool->freeblock = *(block **)bp) == NULL

當進入代碼邏輯2時，表示有空閑的block, 代碼2的執行流程圖如下

pool進行block分配 – 2 回收了某幾個block

回收涉及的代碼：

void
PyObject_Free(void *p)
{
    poolp pool;
    block *lastfree;
    poolp next, prev;
    uint size;

    pool = POOL_ADDR(p);
    if (Py_ADDRESS_IN_RANGE(p, pool)) {
        /* We allocated this address. */
        LOCK();
        /* Link p to the start of the pool's freeblock list.  Since
         * the pool had at least the p block outstanding, the pool
         * wasn't empty (so it's already in a usedpools[] list, or
         * was full and is in no list -- it's not in the freeblocks
         * list in any case).
         */
        assert(pool->ref.count > 0);            /* else it was empty */
        // p被釋放, p的第一個字節值被設置為當前freeblock的值
        *(block **)p = lastfree = pool->freeblock;
        // freeblock被更新為指向p的首地址
        pool->freeblock = (block *)p;

        // 相當於往list中頭插入了一個節點

     ...
    }
}

每釋放一個block，該blcok就會變成pool->freeblock的頭結點， 假設已經連續分配了5塊, 第1塊和第4塊被釋放，此時的內存圖示如下：

此時再一個block分配調用進來, 執行分配, 進入的邏輯是代碼-1

bp = pool->freeblock; // 指針指向空閑block起始位置
// 代碼-1
// 調整 pool->freeblock (假設A節點)指向鏈表下一個, 即bp首字節指向的下一個節點(假設B節點) , 如果此時!= NULL
// 表示 A節點可用, 直接返回
if ((pool->freeblock = *(block **)bp) != NULL) {
    UNLOCK();
    return (void *)bp;
}

pool進行block分配 – 3 pool用完了

pool中內存空間都用完了, 進入代碼-3

/* Pool is full, unlink from used pools. */  // 滿了, 需要從下一個pool獲取
next = pool->nextpool;
pool = pool->prevpool;
next->prevpool = pool;
pool->nextpool = next;
UNLOCK();
return (void *)bp;

Python 內存分配策略之-arena

arena: 多個pool聚合的結果, 可放置64個pool

#define ARENA_SIZE              (256 << 10)     /* 256KB */

arena結構

一個完整的arena = arena_object + pool集合

/* Record keeping for arenas. */
struct arena_object {
    /* The address of the arena, as returned by malloc.  Note that 0
     * will never be returned by a successful malloc, and is used
     * here to mark an arena_object that doesn't correspond to an
     * allocated arena.
     */
    uintptr_t address;

    /* Pool-aligned pointer to the next pool to be carved off. */
    block* pool_address;

    /* The number of available pools in the arena:  free pools + never-
     * allocated pools.
     */
    uint nfreepools;

    /* The total number of pools in the arena, whether or not available. */
    uint ntotalpools;

    /* Singly-linked list of available pools. */
    struct pool_header* freepools;

    /* Whenever this arena_object is not associated with an allocated
     * arena, the nextarena member is used to link all unassociated
     * arena_objects in the singly-linked `unused_arena_objects` list.
     * The prevarena member is unused in this case.
     *
     * When this arena_object is associated with an allocated arena
     * with at least one available pool, both members are used in the
     * doubly-linked `usable_arenas` list, which is maintained in
     * increasing order of `nfreepools` values.
     *
     * Else this arena_object is associated with an allocated arena
     * all of whose pools are in use.  `nextarena` and `prevarena`
     * are both meaningless in this case.
     */
    struct arena_object* nextarena;
    struct arena_object* prevarena;
};

arena_object的作用
1. 與其他arena連接, 組成雙向鏈表
2. 維護arena中可用的pool, 單鏈表

• pool_header和管理的blocks內存是一塊連續的內存 => pool_header被申請時，其管理的的block集合的內存一併被申請 uint maxnextoffset; /* largest valid nextoffset */
• arena_object 和其管理的內存是分離的 => arena_object被申請時，其管理的pool集合的內存沒有被申請，而是在某一時刻建立關係的

arena的兩種狀態

/* The head of the singly-linked, NULL-terminated list of available
 * arena_objects.
 */
// 單鏈表
static struct arena_object* unused_arena_objects = NULL;

/* The head of the doubly-linked, NULL-terminated at each end, list of
 * arena_objects associated with arenas that have pools available.
 */
// 雙向鏈表
static struct arena_object* usable_arenas = NULL;

arena 初始化

* Allocate a new arena.  If we run out of memory, return NULL.  Else
 * allocate a new arena, and return the address of an arena_object
 * describing the new arena.  It's expected that the caller will set
 * `usable_arenas` to the return value.
 */
static struct arena_object*
new_arena(void)
{
    struct arena_object* arenaobj;
    uint excess;        /* number of bytes above pool alignment */
    void *address;
    static int debug_stats = -1;

    if (debug_stats == -1) {
        const char *opt = Py_GETENV("PYTHONMALLOCSTATS");
        debug_stats = (opt != NULL && *opt != '\0');
    }
    if (debug_stats)
        _PyObject_DebugMallocStats(stderr);

    // 判斷是否需要擴充"未使用"的arena_object列表
    if (unused_arena_objects == NULL) {
        uint i;
        uint numarenas;
        size_t nbytes;

        /* Double the number of arena objects on each allocation.
         * Note that it's possible for `numarenas` to overflow.
         */
        // 確定需要申請的個數, 首次初始化, 16, 之後每次翻倍
        numarenas = maxarenas ? maxarenas << 1 : INITIAL_ARENA_OBJECTS;
        if (numarenas <= maxarenas)
            return NULL;                /* overflow */
#if SIZEOF_SIZE_T <= SIZEOF_INT
        if (numarenas > SIZE_MAX / sizeof(*arenas))
            return NULL;                /* overflow */
#endif
        nbytes = numarenas * sizeof(*arenas);
        // 申請內存
        arenaobj = (struct arena_object *)PyMem_RawRealloc(arenas, nbytes);
        if (arenaobj == NULL)
            return NULL;
        arenas = arenaobj;

        /* We might need to fix pointers that were copied.  However,
         * new_arena only gets called when all the pages in the
         * previous arenas are full.  Thus, there are *no* pointers
         * into the old array. Thus, we don't have to worry about
         * invalid pointers.  Just to be sure, some asserts:
         */
        assert(usable_arenas == NULL);
        assert(unused_arena_objects == NULL);

        /* Put the new arenas on the unused_arena_objects list. */
        for (i = maxarenas; i < numarenas; ++i) {
            arenas[i].address = 0;              /* mark as unassociated */
            // 新申請的一律為0, 標識着這個arena處於"未使用"
            arenas[i].nextarena = i < numarenas - 1 ?
                                   &arenas[i+1] : NULL;
        }

         // 將其放入unused_arena_objects鏈表中
        // unused_arena_objects 為新分配內存空間的開頭
        /* Update globals. */
        unused_arena_objects = &arenas[maxarenas];
        maxarenas = numarenas;
    }

    /* Take the next available arena object off the head of the list. */
    assert(unused_arena_objects != NULL);
    // 從unused_arena_objects中, 獲取一個未使用的object
    arenaobj = unused_arena_objects;
    unused_arena_objects = arenaobj->nextarena;  // 更新鏈表
    assert(arenaobj->address == 0);
    // 申請內存, 256KB, 內存地址賦值給arena的address. 這塊內存可用
    address = _PyObject_Arena.alloc(_PyObject_Arena.ctx, ARENA_SIZE);
    if (address == NULL) {
        /* The allocation failed: return NULL after putting the
         * arenaobj back.
         */
        arenaobj->nextarena = unused_arena_objects;
        unused_arena_objects = arenaobj;
        return NULL;
    }
    arenaobj->address = (uintptr_t)address;

    ++narenas_currently_allocated;
    ++ntimes_arena_allocated;
    if (narenas_currently_allocated > narenas_highwater)
        narenas_highwater = narenas_currently_allocated;
    arenaobj->freepools = NULL;
    /* pool_address <- first pool-aligned address in the arena
       nfreepools <- number of whole pools that fit after alignment */
    arenaobj->pool_address = (block*)arenaobj->address;
    arenaobj->nfreepools = MAX_POOLS_IN_ARENA;
    // 將pool的起始地址調整為系統頁的邊界
    // 申請到 256KB, 放棄了一些內存, 而將可使用的內存邊界pool_address調整到了與系統頁對齊
    excess = (uint)(arenaobj->address & POOL_SIZE_MASK);
    if (excess != 0) {
        --arenaobj->nfreepools;
        arenaobj->pool_address += POOL_SIZE - excess;
    }
    arenaobj->ntotalpools = arenaobj->nfreepools;

    return arenaobj;
}

從arenas取一個arena進行初始化

arena分配

new一個全新的arena

static void*
pymalloc_alloc(void *ctx, size_t nbytes)
 {
            // 剛開始沒有可用的arena
            if (usable_arenas == NULL) {
              // new一個, 作為雙向鏈表的表頭
              usable_arenas = new_arena();
              if (usable_arenas == NULL) {
                  UNLOCK();
                  goto redirect;
              }

              usable_arenas->nextarena =
                  usable_arenas->prevarena = NULL;

           }

          .......

          // 從arena中獲取一個pool
          pool = (poolp)usable_arenas->pool_address;
          assert((block*)pool <= (block*)usable_arenas->address +
                                 ARENA_SIZE - POOL_SIZE);
          pool->arenaindex = usable_arenas - arenas;
          assert(&arenas[pool->arenaindex] == usable_arenas);
          pool->szidx = DUMMY_SIZE_IDX;

          // 更新 pool_address 向下一個節點
          usable_arenas->pool_address += POOL_SIZE;
          // 可用節點數量-1
          --usable_arenas->nfreepools;

}

從全新的arena中獲取一個pool

假設arena是舊的, 怎麼分配的pool, 跟pool分配block原理一樣，使用單鏈表記錄freepools

pool = usable_arenas->freepools;
if (pool != NULL) {

當arena中一整塊pool被釋放的時候

/* Free a memory block allocated by pymalloc_alloc().
   Return 1 if it was freed.
   Return 0 if the block was not allocated by pymalloc_alloc(). */
static int
pymalloc_free(void *ctx, void *p) {
    struct arena_object* ao;
    uint nf;  /* ao->nfreepools */

    /* Link the pool to freepools.  This is a singly-linked
               * list, and pool->prevpool isn't used there.
              */
    ao = &arenas[pool->arenaindex];
    pool->nextpool = ao->freepools;
    ao->freepools = pool;
    nf = ++ao->nfreepools;
}

在pool整塊被釋放的時候, 會將pool加入到arena->freepools作為單鏈表的表頭, 然後, 在從非全新arena中分配pool時, 優先從arena->freepools裏面取, 如果取不到, 再從arena內存塊裏面獲取

注: 上圖中nfreepools = n – 2

當arena1用完了，獲取arena1指向的下一個節點arena2

static void*
pymalloc_alloc(void *ctx, size_t nbytes)
{


          // 當發現用完了最後一個pool!!!!!!!!!!!
          // nfreepools = 0
          if (usable_arenas->nfreepools == 0) {
              assert(usable_arenas->nextarena == NULL ||
                     usable_arenas->nextarena->prevarena ==
                     usable_arenas);
              /* Unlink the arena:  it is completely allocated. */

              // 找到下一個節點!
              usable_arenas = usable_arenas->nextarena;
              // 右下一個
              if (usable_arenas != NULL) {
                  usable_arenas->prevarena = NULL; // 更新下一個節點的prevarens
                  assert(usable_arenas->address != 0);
              }
              // 沒有下一個, 此時 usable_arenas = NULL, 下次進行內存分配的時候, 就會從arenas數組中取一個

          }

  }

注意: 這裡有個邏輯, 就是每分配一個pool, 就檢查是不是用到了最後一個, 如果是, 需要變更usable_arenas到下一個可用的節點, 如果沒有可用的, 那麼下次進行內存分配的時候, 會判定從arenas數組中取一個

arena回收

內存分配和回收最小單位是block, 當一個block被回收的時候, 可能觸發pool被回收, pool被回收, 將會觸發arena的回收機制

• 1. arena中所有pool都是閑置的(empty), 將arena內存釋放, 返回給操作系統
• 1. 如果arena中之前所有的pool都是佔用的(used), 現在釋放了一個pool(empty), 需要將 arena加入到usable_arenas, 會加入鏈表表頭
• 1. 如果arena中empty的pool個數n, 則從useable_arenas開始尋找可以插入的位置. 將arena插入. (useable_arenas是一個有序鏈表, 按empty pool的個數, 保證empty pool數量越多, 被使用的幾率越小, 最終被整體釋放的機會越大)

內存分配的步驟

關注點：如何尋找到一塊可用的nbytes的blcok內存？

pool = usedpools[size + size]

if pool:

​ pool 沒滿，取一個blcok返回

​ pool 滿了，從下一個pool取一個blcok返回

else:

​ 獲取arena, 从里面初始化一個pool, 拿到第一個blcok返回

進行內存分配和銷毀, 所有操作都是在pool上進行的

問題: pool中所有block的size一樣, 但是在arena中, 每個pool的size都可能不一樣, 那麼最終這些pool是怎麼維護的? 怎麼根據大小找到需要的block所在的pool? => usedpools

pool在內存池中的三種狀態

1. used狀態：pool中至少有一個block已經被使用，並且至少有一個block未被使用，這種狀態的pool受控於Python內部維護的usedpool數組
2. full狀態：pool中所有的block都已經被使用，這種狀態的pool在arena中, 但不在arena的freepools鏈表中，處於full的pool各自獨立, 不會被鏈表維護起來
3. empty狀態：pool中所有的blcok都未被使用，處於這個狀態的pool的集合通過其pool_header中的nextpool構成一個鏈表，鏈表的表頭示arena_object中的freepools

Python內部維護的usedpools數組是一個非常巧妙的實現，維護着所有的處於used狀態的pool，當申請內存時，python就會通過usedpools尋找到一個可用的pool(處於used狀態)，從中分配一個block。因此我們想，一定有一個usedpools相關聯的機制，完成從申請的內存的大小到size class index之間的轉換，否則python就無法找到最合適的pool了。這種機制和usedpools的結構有着密切的關係，我們看一下它的結構

usedpools

usedpools數組: 維護着所有處於used狀態的pool, 當申請內存的時候, 會通過usedpools尋找到一塊可用的(處於used狀態的)pool, 從中分配一個block。

//obmalloc.c
typedef uint8_t block;
#define PTA(x)  ((poolp )((uint8_t *)&(usedpools[2*(x)]) - 2*sizeof(block *)))
#define PT(x)   PTA(x), PTA(x)

//在我當前的機器就是512/8=64個，對應的size class index就是從0到63
#define NB_SMALL_SIZE_CLASSES   (SMALL_REQUEST_THRESHOLD / ALIGNMENT)

static poolp usedpools[2 * ((NB_SMALL_SIZE_CLASSES + 7) / 8) * 8] = {
    PT(0), PT(1), PT(2), PT(3), PT(4), PT(5), PT(6), PT(7)
#if NB_SMALL_SIZE_CLASSES > 8
    , PT(8), PT(9), PT(10), PT(11), PT(12), PT(13), PT(14), PT(15)
#if NB_SMALL_SIZE_CLASSES > 16
    , PT(16), PT(17), PT(18), PT(19), PT(20), PT(21), PT(22), PT(23)
#if NB_SMALL_SIZE_CLASSES > 24
    , PT(24), PT(25), PT(26), PT(27), PT(28), PT(29), PT(30), PT(31)
#if NB_SMALL_SIZE_CLASSES > 32
    , PT(32), PT(33), PT(34), PT(35), PT(36), PT(37), PT(38), PT(39)
#if NB_SMALL_SIZE_CLASSES > 40
    , PT(40), PT(41), PT(42), PT(43), PT(44), PT(45), PT(46), PT(47)
#if NB_SMALL_SIZE_CLASSES > 48
    , PT(48), PT(49), PT(50), PT(51), PT(52), PT(53), PT(54), PT(55)
#if NB_SMALL_SIZE_CLASSES > 56
    , PT(56), PT(57), PT(58), PT(59), PT(60), PT(61), PT(62), PT(63)
#if NB_SMALL_SIZE_CLASSES > 64
#error "NB_SMALL_SIZE_CLASSES should be less than 64"
#endif /* NB_SMALL_SIZE_CLASSES > 64 */
#endif /* NB_SMALL_SIZE_CLASSES > 56 */
#endif /* NB_SMALL_SIZE_CLASSES > 48 */
#endif /* NB_SMALL_SIZE_CLASSES > 40 */
#endif /* NB_SMALL_SIZE_CLASSES > 32 */
#endif /* NB_SMALL_SIZE_CLASSES > 24 */
#endif /* NB_SMALL_SIZE_CLASSES > 16 */
#endif /* NB_SMALL_SIZE_CLASSES >  8 */
};

如果正在申請28字節， python首先會獲取(size class index) size = (uint )(nbytes - 1) >> ALIGNMENT_SHIFT 顯然這裏size=3， 那麼在usedpools中，尋找第3+3=6個元素，發現usedpools[6]的值是指向usedpools[4]的地址

//obmalloc.c
/* Pool for small blocks. */
struct pool_header {
    union { block *_padding;
            uint count; } ref;          /* 當然pool裏面的block數量    */
    block *freeblock;                   /* 一個鏈表，指向下一個可用的block   */
    struct pool_header *nextpool;       /* 指向下一個pool  */
    struct pool_header *prevpool;       /* 指向上一個pool       ""        */
    uint arenaindex;                    /* 在area裏面的索引 */
    uint szidx;                         /* block的大小(固定值？後面說)     */
    uint nextoffset;                    /* 下一個可用block的內存偏移量         */
    uint maxnextoffset;                 /* 最後一個block距離開始位置的距離     */
};

顯然是從usedpools[6](即usedpools+4)開始向後偏移8個字節(一個ref的大小加上一個freeblock的大小)后的內存，正好是usedpools[6]的地址(即usedpools+6)，這是python內部的trick

當我們要申請一個size class為32字節的pool，想要將其放入這個usedpools中時，要怎麼做呢？從上面的描述我們知道，只需要進行usedpools[i+i] -> nextpool = pool即可，其中i為size class index，對應於32字節，這個i為3.當下次需要訪問size class 為32字節(size class index為3)的pool時，只需要簡單地訪問usedpools[3+3]就可以得到了。python正是使用這個usedpools快速地從眾多的pool中快速地尋找到一個最適合當前內存需求的pool，從中分配一塊block。

//obmalloc.c
static int
pymalloc_alloc(void *ctx, void **ptr_p, size_t nbytes)
{
    block *bp;
    poolp pool;
    poolp next;
    uint size;
    ...
    LOCK();
    //獲得size class index
    size = (uint)(nbytes - 1) >> ALIGNMENT_SHIFT;
    //直接通過usedpools[size+size]，這裏的size不就是我們上面說的i嗎？
    pool = usedpools[size + size];
    //如果usedpools中有可用的pool
    if (pool != pool->nextpool) {
        ... //有可用pool
    }
    ... //無可用pool，嘗試獲取empty狀態的pool
}  

內存池全局結構

參考:

pyhton源碼閱讀-內存管理機制

python源碼解析第17章-python內存管理與垃圾回收

後期查缺補漏需要看的文章

Memory management by Zpoint
Memory management in Python

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※別再煩惱如何寫文案,掌握八大原則!

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※回頭車貨運收費標準

※台中搬家公司費用怎麼算?

前言

本節內容計劃是講解TLB與高速緩存的關係，但是在涉及高速緩的前提是我們必須要了解操作系統緩存原理，所以提前先詳細了解下緩存原理，我們依然是採取循序漸進的方式來解答緩存原理，若有敘述不當之處，還請批評指正。

緩存原理

高速緩存被劃分為多個塊，其大小可能不同，緩存中的塊數通常為2的冪。如下為一個具有八個塊的高速緩存，每個塊包含一個字節。

通過本節對緩存原理的學習我們能夠學習到四點：

【1】當我們將數據塊從主存儲器複製到緩存，我們到底應該放在哪裡？

【2】如何判斷一個字是否已經在緩存中，或者它是否必須首先從主存儲器中獲取？

【3】較小的緩存最終會填滿， 需要至從主存加載新塊，我們必須替換緩存中現有的哪個塊？

【4】存儲系統如何處理寫操作？

數據放在緩存哪裡？

緩存最簡單的數據結構是直接映射： 其中每個存儲器地址僅僅對應到緩存中的一個位置。例如如下，16個字節的主存和4個字節的緩存（每個塊一個字節），內存地址為0、4、8、12分別映射到緩存中為0的塊，而地址1、5、9、13被映射到塊1

等等，我們是不是講解的太快了，上述地址怎麼就劃分到比如塊0或塊1了呢？要找出緩存所在塊採取取模法：（塊地址）mod （緩存中的塊數），如果緩存包含2^k塊，則內存地址i處的數據將進入緩存塊索引為i mod 2^k。還是不懂？我們來舉個例子，如下緩存有4個塊，那麼地址為14將映射到塊2即（14 mod 4 = 2）。

為便於大家理解如上為10進製表示內存地址，將內存地址映射到緩存塊中實際等效的方式是將內存地址中的最低有效k位（二進制）進行映射。正如下面我們所看到的，內存地址14（1110，二進制）將最低有效位10作為塊中的索引

怎樣找到緩存中數據？

到目前為止我們知道了將地址利用直接映射的結構映射到緩存中，那麼我們找到數據是否在緩存中呢？如果要讀取內存地址i，則可以使用mod技巧來確定哪個緩存塊將包含i，如上所述，若其他地址也可能映射到相同的緩存塊，那麼我們如何區分它們呢？例如如下內存地址2、6、10、14都在緩存塊2中

為了解決這個問題，我們需要向高速緩存中添加標記（tag），通過內存地址的高位來提供標記位，以使我們能夠區分映射到同一高速緩存塊的不同存儲位置。例如如下。內存地址6即（0110，二進制），將低位10作為索引（index），高位01作為標記（tag）。

我們通過將高速緩存塊標記（tag）與塊索引（index）組合起來，可以準確地知道主存儲器的哪些地址存儲在高速緩存中。

當程序加載到內存中時，緩存為空，不包含有效數據，我們應該通過為每個緩存塊添加一個有效位來解決這個問題，系統初始化時，所有有效位均設置為0，當數據加載到特定的緩存塊中時，相應的有效位設置為1。

當CPU嘗試從內存中讀取數據時，該地址將被發送到緩存控制器，地址的最低k位將在緩存中索引一個塊，如果該塊有效且標籤與m位地址的高（m-k）位匹配，則該數據將被發送到CPU，如下為一個32位內存地址和2¹⁰字節高速緩存的圖。

到這裏我們會發現一個問題，將每一個字節對應一字節緩存塊並沒有很好的利用空間局部性，要是訪問一個地址后將訪問附近的地址，我們又該怎麼辦？我們要做的是將緩存塊的大小要大於1個字節。如下，我們使用兩個字節的塊，因此我們可以用兩個來加載緩存一次讀取一個字節，如果我們從內存地址12讀取數據，則地址中的數據12和13都將被複制到緩存塊2。

現在，我們又該如何確定數據應放在緩存中的位置？現在演變成塊地址，如果緩存塊大小為2ⁿ字節，我們也可以在概念上將主內存也劃分成2ⁿ字節塊，要確定字節地址i的塊地址，可以進行整數除法（i / 2ⁿ），如下示例中有2個字節的緩存塊，因此我們可以將16個字節的主存儲器視為8塊主存儲器，例如，存儲器地址12和13都對應於塊地址6，因為12 / 2 = 6和13 / 2 = 6。 

現在我們知道了塊地址，就可以像上述一樣將其映射到緩存：找到塊地址除以緩存塊數后的餘數。在如下示例中，內存塊6屬於緩存塊2，因為6 mod 4 =2，這對應於將來自存儲器字節地址12和13的數據都放入高速緩存塊2中。

當我們訪問內存中的一個字節數據時，我們會將其整個塊複製到緩存中以達到充分利用空間局部性。在我們的示例中，如果程序從字節地址12讀取，我們會將所有存儲塊6（地址12和13）都加載到緩存塊2中（注意：字節地址13對應於相同的存儲塊地址）因此，對地址13的讀取也會導致將存儲塊6（地址12和13）加載到高速緩存塊2中。為了簡化起見，存儲塊的字節i始終存儲在相應高速緩存塊的字節i中。

假設我們有一個包含2^k塊的緩存，每個塊包含2ⁿ個字節，我們可以通過查看其在主內存中的地址來確定該緩存中一個字節的數據位置，地址的k位將選擇2^k個高速緩存塊之一，最低的n位現在是一個塊偏移量，它決定了高速緩存塊中的2ⁿ個字節中的哪個將存儲數據。

我們來舉個例子加深理解，如下示例使用2²塊高速緩存，每個塊佔2¹字節，因此，存儲器地址13（1101）將存儲在高速緩存塊2的字節1中。

到這裏為止，我們才算分析清楚了緩存中有效位、標記位、索引、偏移它們的由來以及實際作用。同時對於緩存採用的直接映射（direct mapped）結構：索引和偏移量可以使用位運算符或簡單的算術運算，因為每個內存地址都恰好屬於一個塊。實際上我們可以將一個塊放置到緩存中的任何一個位置，這種機制稱為全相聯（fully associative）。全相聯的高速緩存允許將數據存儲在任何高速緩存塊中，而不是將每個內存地址強制映射到一個特定的塊中，從內存中獲取數據時，可以將其放置在高速緩存的任何未使用塊中。 這樣，我們將永遠不會在映射到單個緩存塊的兩個或多個內存地址之間發生衝突，在上述示例中，我們可能將內存地址2放在緩存塊2中，並將地址6放在塊3中。然後對2和6的後續重複訪問將全部命中而不是未命中，如果所有塊都已被使用，則使用LRU算法進行替換。但是在全相聯緩存中要查找一個指定的塊，由於該塊存放在緩存中的任何位置，因此需要檢索緩存中的所有項，為了是檢索更加有效，它是由一個與緩存中每個項都相關的比較器并行完成的，這些比較器加大了硬件開銷，因而，全相聯只適合塊數較少的緩存。介於直接映射和全相聯之間的設計是組相聯（set associative）。在組相聯緩存中，每個塊可被放置的位置數固定，每個塊有n個位置可放的緩存被稱作n路組相聯，一個n路組相聯緩存由很多組組成，每個組有n個塊。通過上述對直接映射的講解，最終我們得出指定內存地址所在存儲的塊號為：（塊號） mod （緩存中的塊數），而組相聯對於存儲塊號是：（塊號） mod （緩存中的組數）。如下為8塊高速緩存的組織

組相聯實際上就是將塊進行分組，比如如上第一個圖則是直接映射（我們大可將其看做是每一個塊就是一個組，所以是1路8組相聯），而第二張圖則是每2個塊作為一組，所以是2路4組相聯，同理第三張圖是4路2組相聯。換句話說，若每組有2ⁿ塊，那麼就是2ⁿ路相聯。通過對組相聯的講解，我們再敘內存地址在組相聯緩存中的位置。如果我們有2^s組並且每塊有2ⁿ字節，那麼內存地址映射在緩存中的位置則是如下這般

現在我們運算則是計算緩存中的組索引而非再是塊，上述Block offset（在組中塊偏移）= 內存地址 mod 2ⁿ，塊地址 = 內存地址 / 2ⁿ，set index（組索引） = 塊地址 mod 2^s。我們還是通過圖解來進行敘述，假設有一個8塊的高速緩存，然後每個塊是16個字節，那麼內存地址為6195的數據存儲在緩存哪裡呢？首先我們將6195轉換為二進制  = 110000 011 0011，因每個塊是16字節即2⁴，所以塊偏移量為4位即0011，若採用1路8組相聯（直接映射）那麼其組索引就是（6195 mod 8） = 3，取6195轉換而二進制去除偏移量4位，所以為011，同理（根據上述給定計算公式）對於2路4組相聯其組索引為（11），4路2組相聯其組索引為（1），如下：

到這裏我們知道將數據進行緩存我們可以採取直接映射、組相聯、全相聯的機制，通過增加相聯度通常可以降低緩存缺失率，但是增加相聯度也就增加了每組中的塊數，也就是并行查找時同時比較的次數，相聯度每增加兩倍就會使得每組中的塊數加倍而使得組數減半，所以增大了訪問時間的開銷。如何找到一個塊，當然也就依賴於所使用的將塊放置的機制（直接映射、組相聯、全相聯），相較於全相聯而言，它使用複雜的替換策略而降低缺失率且很容易被索引，而不需要額外的硬件，也不需要進行查找。因此虛擬存儲系統通常使用全相聯映射，而組相聯映射通常應用於緩存和TLB。

緩存缺失和寫操作

緩存缺失被分為以下三類（3C模型，three Cs model），因其三類名稱以字母c開頭而得名

強制缺失（compulsory miss）：對從沒有在緩存中出現的塊第一次進行訪問引起的缺失，也稱為冷啟動缺失（cold-start miss）

容量缺失：（capacity miss）：由於緩存容納不了一個程序執行所需要的所有塊而引起的緩存缺失，當某些塊被替換出去，隨後再被調入時，將發生容量缺失

衝突缺失（conflict miss）：在組相聯或者直接映射的緩存中，多個競爭同一個組時而引起的緩存缺失。衝突缺失在直接映射或組相聯緩存中存在，而在同樣大小的全相聯緩存中不存在，這種緩存缺失也稱為碰撞缺失（collision miss）

改變緩存設計的某一方面就能直接影響這些缺失的原因。衝突缺失是因為爭用同一個緩存塊而引起的，因此提高相聯度可以減少衝突缺失，然後提高相聯度會延長訪問時間，導致整個性能的降低，容量缺失可以簡單地通過增大緩存容量來減少，當然緩存容量增大的同時必然導致訪問時間的增加，也將導致整體性能的降低。

在相聯的緩存中發生缺失時，我們必須決定替換哪一塊，如若是全相聯，那麼所有的塊都是被替換的候選者，如若是組相聯，我們必須在某一組的塊中進行選擇，當然，直接映射的緩存替換很簡單，因為只有一個可以替換的候選者。因此在全相聯或組相聯緩存中 ，有兩種主要的替換策略

隨機法：隨機選擇候選塊，可能使用一些硬件來協助實現，例如TLB缺失、MIPS支持隨機替換

LRU（最近最少使用算法）：被替換的塊是最久沒有被使用過的塊 （在大多虛擬存儲器中，對於LRU都是通過提供引用位來近似實現（比如TLB））

指令緩存缺失（數據缺失也類似如此）處理步驟如下：

【1】將程序計數器（PC）的原始值送到寄存器

【2】通知主存執行一次讀操作，並等待主存訪問完成

【3】寫緩存項，將從主存取回的數據寫入緩存中存放數據的部分，並將高位（從ALU中得到）寫入標記域，設置有效位

【4】重啟指令執行第一步，重新取指，這次該指令發生在緩存中

數據訪問是對緩存的控制基本相同：發生缺失時，處理器發生阻塞，直到從存儲器中取回數據后才響應。在執行寫操作時，如果有一個存儲指令，我們只將數據寫入緩存而不改變主存中的內容，那麼在寫入緩存后將導致緩存和主存被認為不一致，保持主存和緩存一致性最簡單的方法是將數據同時寫入主存和緩存中，這種方法稱為【寫直達】法。但是這種方法無法提供良好的性能，因為每次寫操作都要把數據寫入主存中，這些寫操作將花費大量的時間，可能至少花費100個處理時鐘周期，並且大大降低了機器速度，解決這個問題的方案之一是採用【寫緩衝：一個保存等待寫入主存數據的緩衝隊列】，當一個數據在等待寫入緩存時，先將其寫入緩衝中，當數據寫入緩存和緩衝后，處理器可以繼續執行，當寫主存操作完成后，寫緩衝里的數據項也得到有效釋放。如果寫緩衝已經滿了，那麼當處理器執行到一個寫操作時就必須停下來直到寫緩衝中有一個空位置，當然，如果存儲器完成寫操作的速度比處理器產生寫操作的速度慢，那麼再多的緩衝器也無用，因為產生寫操作比存儲系統接收它們更快。

 

除了寫直達方法外，另外一種可選擇的方法是【寫回】，在寫回機制中，當發生寫操作時，新值僅僅被寫入到緩存塊中，只有當修改過的塊被替換時才需要寫到磁盤上，寫回機制可提高系統性能，尤其是當處理器寫操作的速度和主存處理寫操作速度一樣快甚至更快時，但是，寫回機制的實現比寫直達要複雜得多。大部分寫回機制的緩衝也是使用寫緩衝，當在發生缺失替換一個被修改的塊時，寫緩衝可以起到降低缺失代價的作用。在這種情況下，被修改的數據塊移入與緩存相聯的寫回緩衝器，同時從主存中讀出所需要的數據塊。隨後，寫回緩衝器再將數據寫入主存，如果下一次缺失沒有立刻發生，當臟數據塊必須被替換時，這種方法可以減少一半的缺失代價。

總結

一個緩存塊可以放在何處：一個位置（直接映射），一些位置（組相聯），任何位置（全相聯）。

如何找到一個塊：索引（直接映射的緩存中），有限的檢索（組相聯的緩存中），全部檢索（全相聯的緩存中）、專用查找頁表。

緩存缺失時替換哪一塊：隨機選取、LRU

寫操作如何處理：寫直達或寫回策略

本文我們非常詳細的講解了緩存的基本原理，當然對於如何處理緩存一致性並未涉及（大多採用監聽協議），希望通過我對緩存原理的理解能給閱讀的您能有力所能及的幫助，謝謝。 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※教你寫出一流的銷售文案?

※別再煩惱如何寫文案,掌握八大原則!