2. 程式人生 > >malloc基本實現

malloc基本實現

阿新 • • 發佈：2018-03-19
tutorial 來源 而是 關鍵字 bin 說明 研究 ria 關註

轉自：http://www.cnblogs.com/wangshide/p/3932539.html

任何一個用過或學過C的人對malloc都不會陌生。大家都知道malloc可以分配一段連續的內存空間，並且在不再使用時可以通過free釋放掉。但是，許多程序員對malloc背後的事情並不熟悉，許多人甚至把malloc當做操作系統所提供的系統調用或C的關鍵字。實際上，malloc只是C的標準庫中提供的一個普通函數，而且實現malloc的基本思想並不復雜，任何一個對C和操作系統有些許了解的程序員都可以很容易理解。

這篇文章通過實現一個簡單的malloc來描述malloc背後的機制。當然與現有C的標準庫實現（例如glibc）相比，我們實現的malloc並不是特別高效，但是這個實現比目前真實的malloc實現要簡單很多，因此易於理解。重要的是，這個實現和真實實現在基本原理上是一致的。

這篇文章將首先介紹一些所需的基本知識，如操作系統對進程的內存管理以及相關的系統調用，然後逐步實現一個簡單的malloc。為了簡單起見，這篇文章將只考慮x86_64體系結構，操作系統為Linux。

  • 1 什麽是malloc
  • 2 預備知識
    • 2.1 Linux內存管理
      • 2.1.1 虛擬內存地址與物理內存地址
      • 2.1.2 頁與地址構成
      • 2.1.3 內存頁與磁盤頁
    • 2.2 Linux進程級內存管理
      • 2.2.1 內存排布
      • 2.2.2 Heap內存模型
      • 2.2.3 brk與sbrk
      • 2.2.4 資源限制與rlimit
  • 3 實現malloc
    • 3.1 玩具實現
    • 3.2 正式實現
      • 3.2.1 數據結構
      • 3.2.2 尋找合適的block
      • 3.2.3 開辟新的block
      • 3.2.4 分裂block
      • 3.2.5 malloc的實現
      • 3.2.6 calloc的實現
      • 3.2.7 free的實現
      • 3.2.8 realloc的實現
    • 3.3 遺留問題和優化
  • 4 其它參考

1 什麽是malloc

在實現malloc之前，先要相對正式地對malloc做一個定義。

根據標準C庫函數的定義，malloc具有如下原型：

  1. void* malloc(size_t size);

這個函數要實現的功能是在系統中分配一段連續的可用的內存，具體有如下要求：

  • malloc分配的內存大小至少為size參數所指定的字節數
  • malloc的返回值是一個指針，指向一段可用內存的起始地址
  • 多次調用malloc所分配的地址不能有重疊部分，除非某次malloc所分配的地址被釋放掉
  • malloc應該盡快完成內存分配並返回（不能使用NP-hard的內存分配算法）
  • 實現malloc時應同時實現內存大小調整和內存釋放函數（即realloc和free）

對於malloc更多的說明可以在命令行中鍵入以下命令查看：

  1. man malloc

2 預備知識

在實現malloc之前，需要先解釋一些Linux系統內存相關的知識。

2.1 Linux內存管理

2.1.1 虛擬內存地址與物理內存地址

為了簡單，現代操作系統在處理內存地址時，普遍采用虛擬內存地址技術。即在匯編程序（或機器語言）層面，當涉及內存地址時，都是使用虛擬內存地址。采用這種技術時，每個進程仿佛自己獨享一片2N字節的內存，其中N是機器位數。例如在64位CPU和64位操作系統下，每個進程的虛擬地址空間為264Byte。

這種虛擬地址空間的作用主要是簡化程序的編寫及方便操作系統對進程間內存的隔離管理，真實中的進程不太可能（也用不到）如此大的內存空間，實際能用到的內存取決於物理內存大小。

由於在機器語言層面都是采用虛擬地址，當實際的機器碼程序涉及到內存操作時，需要根據當前進程運行的實際上下文將虛擬地址轉換為物理內存地址，才能實現對真實內存數據的操作。這個轉換一般由一個叫MMU（Memory Management Unit）的硬件完成。

2.1.2 頁與地址構成

在現代操作系統中，不論是虛擬內存還是物理內存，都不是以字節為單位進行管理的，而是以頁（Page）為單位。一個內存頁是一段固定大小的連續內存地址的總稱，具體到Linux中，典型的內存頁大小為4096Byte（4K）。

所以內存地址可以分為頁號和頁內偏移量。下面以64位機器，4G物理內存，4K頁大小為例，虛擬內存地址和物理內存地址的組成如下：

技術分享圖片

上面是虛擬內存地址，下面是物理內存地址。由於頁大小都是4K，所以頁內便宜都是用低12位表示，而剩下的高地址表示頁號。

MMU映射單位並不是字節，而是頁，這個映射通過查一個常駐內存的數據結構頁表來實現。現在計算機具體的內存地址映射比較復雜，為了加快速度會引入一系列緩存和優化，例如TLB等機制。下面給出一個經過簡化的內存地址翻譯示意圖，雖然經過了簡化，但是基本原理與現代計算機真實的情況的一致的。

技術分享圖片

2.1.3 內存頁與磁盤頁

我們知道一般將內存看做磁盤的的緩存，有時MMU在工作時，會發現頁表表明某個內存頁不在物理內存中，此時會觸發一個缺頁異常（Page Fault），此時系統會到磁盤中相應的地方將磁盤頁載入到內存中，然後重新執行由於缺頁而失敗的機器指令。關於這部分，因為可以看做對malloc實現是透明的，所以不再詳細講述，有興趣的可以參考《深入理解計算機系統》相關章節。

最後附上一張在維基百科找到的更加符合真實地址翻譯的流程供大家參考，這張圖加入了TLB和缺頁異常的流程（圖片來源頁）。

技術分享圖片

2.2 Linux進程級內存管理

2.2.1 內存排布

明白了虛擬內存和物理內存的關系及相關的映射機制，下面看一下具體在一個進程內是如何排布內存的。

以Linux 64位系統為例。理論上，64bit內存地址可用空間為0x0000000000000000 ~ 0xFFFFFFFFFFFFFFFF，這是個相當龐大的空間，Linux實際上只用了其中一小部分（256T）。

根據Linux內核相關文檔描述，Linux64位操作系統僅使用低47位，高17位做擴展（只能是全0或全1）。所以，實際用到的地址為空間為0x0000000000000000 ~ 0x00007FFFFFFFFFFF和0xFFFF800000000000 ~ 0xFFFFFFFFFFFFFFFF，其中前面為用戶空間（User Space），後者為內核空間（Kernel Space）。圖示如下：

技術分享圖片

對用戶來說，主要關註的空間是User Space。將User Space放大後，可以看到裏面主要分為如下幾段：

  • Code：這是整個用戶空間的最低地址部分，存放的是指令（也就是程序所編譯成的可執行機器碼）
  • Data：這裏存放的是初始化過的全局變量
  • BSS：這裏存放的是未初始化的全局變量
  • Heap：堆，這是我們本文重點關註的地方，堆自低地址向高地址增長，後面要講到的brk相關的系統調用就是從這裏分配內存
  • Mapping Area：這裏是與mmap系統調用相關的區域。大多數實際的malloc實現會考慮通過mmap分配較大塊的內存區域，本文不討論這種情況。這個區域自高地址向低地址增長
  • Stack：這是棧區域，自高地址向低地址增長

下面我們主要關註Heap區域的操作。對整個Linux內存排布有興趣的同學可以參考其它資料。

2.2.2 Heap內存模型

一般來說，malloc所申請的內存主要從Heap區域分配（本文不考慮通過mmap申請大塊內存的情況）。

由上文知道，進程所面對的虛擬內存地址空間，只有按頁映射到物理內存地址，才能真正使用。受物理存儲容量限制，整個堆虛擬內存空間不可能全部映射到實際的物理內存。Linux對堆的管理示意如下：

技術分享圖片

Linux維護一個break指針，這個指針指向堆空間的某個地址。從堆起始地址到break之間的地址空間為映射好的，可以供進程訪問；而從break往上，是未映射的地址空間，如果訪問這段空間則程序會報錯。

2.2.3 brk與sbrk

由上文知道，要增加一個進程實際的可用堆大小，就需要將break指針向高地址移動。Linux通過brk和sbrk系統調用操作break指針。兩個系統調用的原型如下：

  1. int brk(void *addr);
  2. void *sbrk(intptr_t increment);

brk將break指針直接設置為某個地址，而sbrk將break從當前位置移動increment所指定的增量。brk在執行成功時返回0，否則返回-1並設置errno為ENOMEM；sbrk成功時返回break移動之前所指向的地址，否則返回(void *)-1。

一個小技巧是，如果將increment設置為0，則可以獲得當前break的地址。

另外需要註意的是，由於Linux是按頁進行內存映射的，所以如果break被設置為沒有按頁大小對齊，則系統實際上會在最後映射一個完整的頁，從而實際已映射的內存空間比break指向的地方要大一些。但是使用break之後的地址是很危險的（盡管也許break之後確實有一小塊可用內存地址）。

2.2.4 資源限制與rlimit

系統對每一個進程所分配的資源不是無限的，包括可映射的內存空間，因此每個進程有一個rlimit表示當前進程可用的資源上限。這個限制可以通過getrlimit系統調用得到，下面代碼獲取當前進程虛擬內存空間的rlimit：

  1. int main() {
  2. struct rlimit *limit = (struct rlimit *)malloc(sizeof(struct rlimit));
  3. getrlimit(RLIMIT_AS, limit);
  4. printf("soft limit: %ld, hard limit: %ld\n", limit->rlim_cur, limit->rlim_max);
  5. }

其中rlimit是一個結構體：

  1. struct rlimit {
  2. rlim_t rlim_cur; /* Soft limit */
  3. rlim_t rlim_max; /* Hard limit (ceiling for rlim_cur) */
  4. };

每種資源有軟限制和硬限制，並且可以通過setrlimit對rlimit進行有條件設置。其中硬限制作為軟限制的上限，非特權進程只能設置軟限制，且不能超過硬限制。

3 實現malloc

3.1 玩具實現

在正式開始討論malloc的實現前，我們可以利用上述知識實現一個簡單但幾乎沒法用於真實的玩具malloc，權當對上面知識的復習：

  1. /* 一個玩具malloc */
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. void *malloc(size_t size)
  5. {
  6. void *p;
  7. p = sbrk(0);
  8. if (sbrk(size) == (void *)-1)
  9. return NULL;
  10. return p;
  11. }

這個malloc每次都在當前break的基礎上增加size所指定的字節數，並將之前break的地址返回。這個malloc由於對所分配的內存缺乏記錄，不便於內存釋放，所以無法用於真實場景。

3.2 正式實現

下面嚴肅點討論malloc的實現方案。

3.2.1 數據結構

首先我們要確定所采用的數據結構。一個簡單可行方案是將堆內存空間以塊（Block）的形式組織起來，每個塊由meta區和數據區組成，meta區記錄數據塊的元信息（數據區大小、空閑標誌位、指針等等），數據區是真實分配的內存區域，並且數據區的第一個字節地址即為malloc返回的地址。

可以用如下結構體定義一個block：

  1. typedef struct s_block *t_block;
  2. struct s_block {
  3. size_t size; /* 數據區大小 */
  4. t_block next; /* 指向下個塊的指針 */
  5. int free; /* 是否是空閑塊 */
  6. int padding; /* 填充4字節，保證meta塊長度為8的倍數 */
  7. char data[1] /* 這是一個虛擬字段，表示數據塊的第一個字節，長度不應計入meta */
  8. };

由於我們只考慮64位機器，為了方便，我們在結構體最後填充一個int，使得結構體本身的長度為8的倍數，以便內存對齊。示意圖如下：

技術分享圖片

3.2.2 尋找合適的block

現在考慮如何在block鏈中查找合適的block。一般來說有兩種查找算法：

  • First fit：從頭開始，使用第一個數據區大小大於要求size的塊所謂此次分配的塊
  • Best fit：從頭開始，遍歷所有塊，使用數據區大小大於size且差值最小的塊作為此次分配的塊

兩種方法各有千秋，best fit具有較高的內存使用率（payload較高），而first fit具有更好的運行效率。這裏我們采用first fit算法。

  1. /* First fit */
  2. t_block find_block(t_block *last, size_t size) {
  3. t_block b = first_block;
  4. while(b && !(b->free && b->size >= size)) {
  5. *last = b;
  6. b = b->next;
  7. }
  8. return b;
  9. }

find_block從frist_block開始，查找第一個符合要求的block並返回block起始地址，如果找不到這返回NULL。這裏在遍歷時會更新一個叫last的指針，這個指針始終指向當前遍歷的block。這是為了如果找不到合適的block而開辟新block使用的，具體會在接下來的一節用到。

3.2.3 開辟新的block

如果現有block都不能滿足size的要求，則需要在鏈表最後開辟一個新的block。這裏關鍵是如何只使用sbrk創建一個struct：

  1. #define BLOCK_SIZE 24 /* 由於存在虛擬的data字段，sizeof不能正確計算meta長度，這裏手工設置 */
  3. t_block extend_heap(t_block last, size_t s) {
  4. t_block b;
  5. b = sbrk(0);
  6. if(sbrk(BLOCK_SIZE + s) == (void *)-1)
  7. return NULL;
  8. b->size = s;
  9. b->next = NULL;
  10. if(last)
  11. last->next = b;
  12. b->free = 0;
  13. return b;
  14. }

3.2.4 分裂block

First fit有一個比較致命的缺點，就是可能會讓很小的size占據很大的一塊block，此時，為了提高payload，應該在剩余數據區足夠大的情況下，將其分裂為一個新的block，示意如下：

技術分享圖片

實現代碼：

  1. void split_block(t_block b, size_t s) {
  2. t_block new;
  3. new = b->data + s;
  4. new->size = b->size - s - BLOCK_SIZE ;
  5. new->next = b->next;
  6. new->free = 1;
  7. b->size = s;
  8. b->next = new;
  9. }

3.2.5 malloc的實現

有了上面的代碼，我們可以利用它們整合成一個簡單但初步可用的malloc。註意首先我們要定義個block鏈表的頭first_block，初始化為NULL；另外，我們需要剩余空間至少有BLOCK_SIZE + 8才執行分裂操作。

由於我們希望malloc分配的數據區是按8字節對齊，所以在size不為8的倍數時，我們需要將size調整為大於size的最小的8的倍數：

  1. size_t align8(size_t s) {
  2. if(s & 0x7 == 0)
  3. return s;
  4. return ((s >> 3) + 1) << 3;
  5. }
  1. #define BLOCK_SIZE 24
  2. void *first_block=NULL;
  4. /* other functions... */
  6. void *malloc(size_t size) {
  7. t_block b, last;
  8. size_t s;
  9. /* 對齊地址 */
  10. s = align8(size);
  11. if(first_block) {
  12. /* 查找合適的block */
  13. last = first_block;
  14. b = find_block(&last, s);
  15. if(b) {
  16. /* 如果可以，則分裂 */
  17. if ((b->size - s) >= ( BLOCK_SIZE + 8))
  18. split_block(b, s);
  19. b->free = 0;
  20. } else {
  21. /* 沒有合適的block，開辟一個新的 */
  22. b = extend_heap(last, s);
  23. if(!b)
  24. return NULL;
  25. }
  26. } else {
  27. b = extend_heap(NULL, s);
  28. if(!b)
  29. return NULL;
  30. first_block = b;
  31. }
  32. return b->data;
  33. }

3.2.6 calloc的實現

有了malloc，實現calloc只要兩步：

  1. malloc一段內存
  2. 將數據區內容置為0

由於我們的數據區是按8字節對齊的，所以為了提高效率，我們可以每8字節一組置0，而不是一個一個字節設置。我們可以通過新建一個size_t指針，將內存區域強制看做size_t類型來實現。

  1. void *calloc(size_t number, size_t size) {
  2. size_t *new;
  3. size_t s8, i;
  4. new = malloc(number * size);
  5. if(new) {
  6. s8 = align8(number * size) >> 3;
  7. for(i = 0; i < s8; i++)
  8. new[i] = 0;
  9. }
  10. return new;
  11. }

3.2.7 free的實現

free的實現並不像看上去那麽簡單，這裏我們要解決兩個關鍵問題：

  1. 如何驗證所傳入的地址是有效地址，即確實是通過malloc方式分配的數據區首地址
  2. 如何解決碎片問題

首先我們要保證傳入free的地址是有效的，這個有效包括兩方面：

  • 地址應該在之前malloc所分配的區域內，即在first_block和當前break指針範圍內
  • 這個地址確實是之前通過我們自己的malloc分配的

第一個問題比較好解決，只要進行地址比較就可以了，關鍵是第二個問題。這裏有兩種解決方案：一是在結構體內埋一個magic number字段，free之前通過相對偏移檢查特定位置的值是否為我們設置的magic number，另一種方法是在結構體內增加一個magic pointer，這個指針指向數據區的第一個字節（也就是在合法時free時傳入的地址），我們在free前檢查magic pointer是否指向參數所指地址。這裏我們采用第二種方案：

首先我們在結構體中增加magic pointer（同時要修改BLOCK_SIZE）：

  1. typedef struct s_block *t_block;
  2. struct s_block {
  3. size_t size; /* 數據區大小 */
  4. t_block next; /* 指向下個塊的指針 */
  5. int free; /* 是否是空閑塊 */
  6. int padding; /* 填充4字節，保證meta塊長度為8的倍數 */
  7. void *ptr; /* Magic pointer，指向data */
  8. char data[1] /* 這是一個虛擬字段，表示數據塊的第一個字節，長度不應計入meta */
  9. };

然後我們定義檢查地址合法性的函數：

  1. t_block get_block(void *p) {
  2. char *tmp;
  3. tmp = p;
  4. return (p = tmp -= BLOCK_SIZE);
  5. }
  7. int valid_addr(void *p) {
  8. if(first_block) {
  9. if(p > first_block && p < sbrk(0)) {
  10. return p == (get_block(p))->ptr;
  11. }
  12. }
  13. return 0;
  14. }

當多次malloc和free後，整個內存池可能會產生很多碎片block，這些block很小，經常無法使用，甚至出現許多碎片連在一起，雖然總體能滿足某此malloc要求，但是由於分割成了多個小block而無法fit，這就是碎片問題。

一個簡單的解決方式時當free某個block時，如果發現它相鄰的block也是free的，則將block和相鄰block合並。為了滿足這個實現，需要將s_block改為雙向鏈表。修改後的block結構如下：

  1. typedef struct s_block *t_block;
  2. struct s_block {
  3. size_t size; /* 數據區大小 */
  4. t_block prev; /* 指向上個塊的指針 */
  5. t_block next; /* 指向下個塊的指針 */
  6. int free; /* 是否是空閑塊 */
  7. int padding; /* 填充4字節，保證meta塊長度為8的倍數 */
  8. void *ptr; /* Magic pointer，指向data */
  9. char data[1] /* 這是一個虛擬字段，表示數據塊的第一個字節，長度不應計入meta */
  10. };

合並方法如下：

  1. t_block fusion(t_block b) {
  2. if (b->next && b->next->free) {
  3. b->size += BLOCK_SIZE + b->next->size;
  4. b->next = b->next->next;
  5. if(b->next)
  6. b->next->prev = b;
  7. }
  8. return b;
  9. }

有了上述方法，free的實現思路就比較清晰了：首先檢查參數地址的合法性，如果不合法則不做任何事；否則，將此block的free標為1，並且在可以的情況下與後面的block進行合並。如果當前是最後一個block，則回退break指針釋放進程內存，如果當前block是最後一個block，則回退break指針並設置first_block為NULL。實現如下：

  1. void free(void *p) {
  2. t_block b;
  3. if(valid_addr(p)) {
  4. b = get_block(p);
  5. b->free = 1;
  6. if(b->prev && b->prev->free)
  7. b = fusion(b->prev);
  8. if(b->next)
  9. fusion(b);
  10. else {
  11. if(b->prev)
  12. b->prev->prev = NULL;
  13. else
  14. first_block = NULL;
  15. brk(b);
  16. }
  17. }
  18. }

3.2.8 realloc的實現

為了實現realloc，我們首先要實現一個內存復制方法。如同calloc一樣，為了效率，我們以8字節為單位進行復制：

  1. void copy_block(t_block src, t_block dst) {
  2. size_t *sdata, *ddata;
  3. size_t i;
  4. sdata = src->ptr;
  5. ddata = dst->ptr;
  6. for(i = 0; (i * 8) < src->size && (i * 8) < dst->size; i++)
  7. ddata[i] = sdata[i];
  8. }

然後我們開始實現realloc。一個簡單（但是低效）的方法是malloc一段內存，然後將數據復制過去。但是我們可以做的更高效，具體可以考慮以下幾個方面：

  • 如果當前block的數據區大於等於realloc所要求的size，則不做任何操作
  • 如果新的size變小了，考慮split
  • 如果當前block的數據區不能滿足size，但是其後繼block是free的，並且合並後可以滿足，則考慮做合並

下面是realloc的實現：

  1. void *realloc(void *p, size_t size) {
  2. size_t s;
  3. t_block b, new;
  4. void *newp;
  5. if (!p)
  6. /* 根據標準庫文檔，當p傳入NULL時，相當於調用malloc */
  7. return malloc(size);
  8. if(valid_addr(p)) {
  9. s = align8(size);
  10. b = get_block(p);
  11. if(b->size >= s) {
  12. if(b->size - s >= (BLOCK_SIZE + 8))
  13. split_block(b,s);
  14. } else {
  15. /* 看是否可進行合並 */
  16. if(b->next && b->next->free
  17. && (b->size + BLOCK_SIZE + b->next->size) >= s) {
  18. fusion(b);
  19. if(b->size - s >= (BLOCK_SIZE + 8))
  20. split_block(b, s);
  21. } else {
  22. /* 新malloc */
  23. newp = malloc (s);
  24. if (!newp)
  25. return NULL;
  26. new = get_block(newp);
  27. copy_block(b, new);
  28. free(p);
  29. return(newp);
  30. }
  31. }
  32. return (p);
  33. }
  34. return NULL;
  35. }

3.3 遺留問題和優化

以上是一個較為簡陋，但是初步可用的malloc實現。還有很多遺留的可能優化點，例如：

  • 在分配較大快內存時，考慮使用mmap而非sbrk，這通常更高效
  • 可以考慮維護多個鏈表而非單個，每個鏈表中的block大小均為一個範圍內，例如8字節鏈表、16字節鏈表、24-32字節鏈表等等。此時可以根據size到對應鏈表中做分配，可以有效減少碎片，並提高查詢block的速度
  • 可以考慮鏈表中只存放free的block，而不存放已分配的block，可以減少查找block的次數，提高效率

還有很多可能的優化，這裏不一一贅述。下面附上一些參考文獻，有興趣的同學可以更深入研究。

4 其它參考

  1. 這篇文章大量參考了A malloc Tutorial，其中一些圖片和代碼直接引用了文中的內容，這裏特別指出
  2. Computer Systems: A Programmer‘s Perspective, 2/E一書有許多值得參考的地方
  3. 關於Linux的虛擬內存模型，Anatomy of a Program in Memory是很好的參考資料，另外作者還有一篇How the Kernel Manages Your Memory對於Linux內核中虛擬內存管理的部分有很好的講解
  4. 對於真實世界的malloc實現，可以參考glic的實現
  5. 本文寫作過程中大量參考了維基百科，再次感謝這個偉大的網站，並且呼籲大家在手頭允許的情況下可以適當捐助維基百科，幫助這個造福人類的系統運行下去

malloc基本實現

相關推薦

malloc基本實現

tutorial 來源 而是 關鍵字 bin 說明 研究 ria 關註 轉自：http://www.cnblogs.com/wangshide/p/3932539.html 任何一個用過或學過C的人對malloc都不會陌生。大家都知道malloc可以分配一段連續的內

記憶體動態分配函式malloc的基本實現原理

    malloc是C語言最常用的標準庫函式之一，用於在程式執行中動態地申請記憶體空間。我們都會使用它，其函式原型為： extern void *malloc(unsigned int num_by

JAVA類庫LinkList的基本實現

ble set tof nts rem marker ext err bounds 寫完調試了好久，邊界不優點理，具體的請看JDK類庫，下面僅僅是基本實現：import java.util.Iterator; /** * 類名：MyLinkedList 說明：Lin

01_網頁源碼查看器基本實現

alt host 基本實現 手機 com 技術分享 流量 基本 查看 安卓上面敲127.0.0.1或者是localhost是不行的，安卓上面的localhost/127.0.0.1默認是10.0.2.2.有些第三方的模擬器可能不是這個值。安卓自帶的模擬器

Java web server 基本實現原理

tro 主線程 inpu 請求報文 永遠 原理 args ket io阻塞 public class WebServer { //服務端Socket只要一個，所以定義成static, 同一時間只能一個線程訪問(主線程) private static Se

Spring源碼閱讀之Springs-beans（一）容器的基本實現

beans 閱讀 gin com -i add wid ans lock 一、Spring-beans Spring源碼閱讀之Springs-beans（一）容器的基本實現

功能二：上傳文件功能的基本實現

tro enc 舉例 二進制 存儲 multipart file 瀏覽器 實現 　　使用表單實現文件上傳： <form action="upload_file.php" method="post" enctype="multipart/form-data">

spring源碼--容器的基本實現

init turn try consumer ica not www ask queue 在工作中見得非常多的容器使用是：<beans xmlns="http://www.springframework.org/schema/beans" xml

前端hash路由基本原理,及代碼的基本實現

alt ide class javascrip r.js border pop display 早期 路由就是指隨著瀏覽器地址欄的變化，展示給用戶的頁面也不相同。 早期的路由都是後端實現的，直接根據 url 來 reload 頁面，頁面變得越來越復雜服務器端壓力變大，隨著

Centos 7.4 中http-2.4 的基本實現和 https 的實現

http-2.4 https 1.建立httpd服務，要求： 1) 提供兩個基於名稱的虛擬主機www1, www2；要求每個虛擬主機都有單獨的錯誤日誌和訪問日誌； 2) 通過www1的/server-status提供狀態信

nfs基本實現

nfs 基本實現 51cto NFS（Network File System）即網絡文件系統，是FreeBSD支持的文件系統中的一種，它允許網絡中的計算機之間通過TCP/IP網絡共享資源。在NFS的應用中，本地NFS的客戶端應用可以透明地讀寫位於遠端NFS服務器上的文件，就像訪問本地文件一樣。　　

頻率域去噪基本實現思想

思想 圖像去噪 con 相關 性能 變化 copy 比較 class 1. 頻率域去噪基本實現思想：首先將原始圖像通過一些積分變換，將其變換到頻率域，接著再通過頻率域對其進行操作，得到的結果再反變換到空間域中，進而使圖像得到增強。根據傅裏葉頻譜的特性可得到，圖像的平均灰度級

ASP.NET中的幾種彈出框提示基本實現方法

sys find xxxxx 文章 hello sage rtu msg CI 我們在.NET程序的開發過程中，常常需要和用戶進行信息交互，比如執行某項操作是否成功，“確定”還是“取消”，以及選擇“確定”或“取消”後是否需要跳轉到某個頁面等，下面是本人對常用對話框使用的小結

基於argparser模塊實現 ls 功能（基本實現）

script ESS etime code lib 獲取文件 from rom art 第一版：實現基本功能，但是沒有獲取屬主，屬組，只能在一個目錄下，不能傳入多個目錄：如 ls /etc /tmp 1 import argparse 2 from pathlib

【隨筆】express中間件系統的基本實現

req 初始 add res 處理 通過 第一個 tostring 自定義 一直覺得express的中間件系統這種流式處理非常形象，就好像加工流水線一樣，每個環節都在針對同一個產品的不同部分完成自己的工作，最後得到一個成品。今天就來實現一個簡易的【中間件隊列】。 一. A

常見分布式鎖的基本實現

多系統 哪些 abi 場景 方式 分析 返回 了解 重入 二、分布式鎖應該具備哪些條件 在分析分布式鎖的三種實現方式之前，先了解一下分布式鎖應該具備哪些條件： 1、在分布式系統環境下，一個方法在同一時間只能被一個機器的一個線程執行； 2、高可用的獲取鎖與釋放

LRU(最近最少使用淘汰算法)基本實現

置換 lin ron sta recent 頁式 inf ext block LRU(Least Recently Used) 出發點：在頁式存儲管理中，如果一頁很長時間未被訪問，則它在最近一段時間內也不會被訪問，即時間局部性，那我們就把它調出（置換出）內存。 為了實

第5章 面對Windows開發的基本實現

自己 執行 文件 pan window style 可執行 文件類型 courier 　　Delphi可以實現Windows系統中的大多數可執行文件類型，這主要包括可執行程序（.EXE）和動態鏈接庫（.DLL）.其他的一些文件類型，通常以動態鏈接庫的形式編譯，只是輸出的文件

ssm基本實現

Mybatis    ssm專案基本介紹   用mybatis實現單表增刪查改   必須重現，將mysql安裝完成   通過用介面的形式實現簡單的增刪查改  可選擇   將sql命令通過註解的形式來寫在類中  可選

Spring 事務——事務介紹以及事務在Spring框架中的基本實現

事務介紹 事務一般發生在和持久層打交道的地方，比如資料庫。 假設一個工作由兩件事共同組成，那麼這兩件事要麼全部完成，這個工作才算完成。要麼全部回退到初始狀態。不存在只完成一件，還有一件事沒完成的。這項工作可稱為一個事務。常用的場景就是銀行轉賬。A向B轉賬100元這項工作由兩件事組成：A帳