2. 程式人生 > >hashmap深入分析

hashmap深入分析

阿新 • • 發佈：2019-01-28

 java.util.HashMap是很常見的類，前段時間公司系統由於對HashMap使用不當，導致cpu百分之百，在併發環境下使用HashMap 而沒有做同步，可能會引起死迴圈，關於這一點，sun的官方網站上已有闡述，這並非是bug。

HashMap的資料結構
         HashMap主要是用陣列來儲存資料的，我們都知道它會對key進行雜湊運算，哈系運算會有重複的雜湊值，對於雜湊值的衝突，HashMap採用連結串列來解決的。在HashMap裡有這樣的一句屬性宣告：
transient Entry[] table;
Entry就是HashMap儲存資料所用的類，它擁有的屬性如下
final K key;
V value;
final int hash;
Entry<K,V> next;


看到next了嗎？next就是為了雜湊衝突而存在的。比如通過雜湊運算，一個新元素應該在陣列的第10個位置，但是第10個位置已經有Entry，那麼好吧，將新加的元素也放到第10個位置，將第10個位置的原有Entry賦值給當前新加的 Entry的next屬性。陣列儲存的是連結串列，連結串列是為了解決雜湊衝突的，這一點要注意。


幾個關鍵的屬性
儲存資料的陣列
transient Entry[] table; 這個上面已經講到了
預設容量
static final int DEFAULT_INITIAL_CAPACITY = 16;
最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;

預設載入因子，載入因子是一個比例，當HashMap的資料大小>=容量*載入因子時，HashMap會將容量擴容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
當實際資料大小超過threshold時，HashMap會將容量擴容，threshold＝容量*載入因子
int threshold;
載入因子
final float loadFactor;


HashMap的初始過程
建構函式1

Java程式碼 複製程式碼 收藏程式碼
  1. public HashMap(int initialCapacity, float loadFactor) {   
  2. if (initialCapacity < 
    0)   
  3. thrownew IllegalArgumentException("Illegal initial capacity: " +   
  4.                                            initialCapacity);   
  5. if (initialCapacity > MAXIMUM_CAPACITY)   
  6.         initialCapacity = MAXIMUM_CAPACITY;   
  7. if (loadFactor <= 0 || Float.isNaN(loadFactor))   
  8. thrownew IllegalArgumentException("Illegal load factor: " +   
  9.                                            loadFactor);   
  10. // Find a power of 2 >= initialCapacity
  11. int capacity = 1;   
  12. while (capacity < initialCapacity)   
  13.         capacity <<= 1;   
  14. this.loadFactor = loadFactor;   
  15.     threshold = (int)(capacity * loadFactor);   
  16.     table = new Entry[capacity];   
  17.     init();   
  18. }  
Java程式碼
  1. public HashMap(int initialCapacity, float loadFactor) {  
  2.     if (initialCapacity < 0)  
  3.         thrownew IllegalArgumentException("Illegal initial capacity: " +  
  4.                                            initialCapacity);  
  5.     if (initialCapacity > MAXIMUM_CAPACITY)  
  6.         initialCapacity = MAXIMUM_CAPACITY;  
  7.     if (loadFactor <= 0 || Float.isNaN(loadFactor))  
  8.         thrownew IllegalArgumentException("Illegal load factor: " +  
  9.                                            loadFactor);  
  10.     // Find a power of 2 >= initialCapacity
  11.     int capacity = 1;  
  12.     while (capacity < initialCapacity)  
  13.         capacity <<= 1;  
  14.     this.loadFactor = loadFactor;  
  15.     threshold = (int)(capacity * loadFactor);  
  16.     table = new Entry[capacity];  
  17.     init();  
  18. }  



重點注意這裡

Java程式碼 複製程式碼 收藏程式碼
  1. while (capacity < initialCapacity)   
  2.             capacity <<= 1;  
Java程式碼
  1. while (capacity < initialCapacity)  
  2.             capacity <<= 1;  


capacity才是初始容量，而不是initialCapacity，這個要特別注意，如果執行new HashMap(9,0.75)；那麼HashMap的初始容量是16，而不是9，想想為什麼吧。

建構函式2

Java程式碼 複製程式碼 收藏程式碼
  1. public HashMap(int initialCapacity) {   
  2. this(initialCapacity, DEFAULT_LOAD_FACTOR);   
  3.     }  
Java程式碼
  1. public HashMap(int initialCapacity) {  
  2.         this(initialCapacity, DEFAULT_LOAD_FACTOR);  
  3.     }  


建構函式3，全部都是預設值

Java程式碼 複製程式碼 收藏程式碼
  1. public HashMap() {   
  2. this.loadFactor = DEFAULT_LOAD_FACTOR;   
  3.      threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);   
  4.      table = new Entry[DEFAULT_INITIAL_CAPACITY];   
  5.      init();   
  6.  }  
Java程式碼
  1. public HashMap() {  
  2.      this.loadFactor = DEFAULT_LOAD_FACTOR;  
  3.      threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);  
  4.      table = new Entry[DEFAULT_INITIAL_CAPACITY];  
  5.      init();  
  6.  }  


建構函式4

Java程式碼 複製程式碼 收藏程式碼
  1. public HashMap(Map<? extends K, ? extends V> m) {   
  2. this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,   
  3.                     DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);   
  4.       putAllForCreate(m);   
  5.   }  
Java程式碼
  1. public HashMap(Map<? extends K, ? extends V> m) {  
  2.       this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,  
  3.                     DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);  
  4.       putAllForCreate(m);  
  5.   }  



如何雜湊
        HashMap並不是直接將物件的hashcode作為雜湊值的，而是要把key的hashcode作一些運算以得到最終的雜湊值，並且得到的雜湊值也不是在陣列中的位置哦，無論是get還是put還是別的方法，計算雜湊值都是這一句：
int hash = hash(key.hashCode());
hash函式如下：

Java程式碼 複製程式碼 收藏程式碼
  1. staticint hash(int h) {   
  2. return useNewHash ? newHash(h) : oldHash(h);   
  3.   }  
Java程式碼
  1. staticint hash(int h) {  
  2.   return useNewHash ? newHash(h) : oldHash(h);  
  3.   }  


useNewHash宣告如下：
 

Java程式碼 複製程式碼 收藏程式碼
  1. privatestaticfinalboolean useNewHash;   
  2. static { useNewHash = false; }  
Java程式碼
  1. privatestaticfinalboolean useNewHash;  
  2.    static { useNewHash = false; }  

這說明useNewHash其實一直為false且不可改變的，hash函式裡對 useNewHash的判斷真是多餘的。

Java程式碼 複製程式碼 收藏程式碼
  1. privatestaticint oldHash(int h) {   
  2.     h += ~(h << 9);   
  3.     h ^=  (h >>> 14);   
  4.     h +=  (h << 4);   
  5.     h ^=  (h >>> 10);   
  6. return h;   
  7. }   
  8. privatestaticint newHash(int h) {   
  9. // This function ensures that hashCodes that differ only by
  10. // constant multiples at each bit position have a bounded
  11. // number of collisions (approximately 8 at default load factor).
  12.     h ^= (h >>> 20) ^ (h >>> 12);   
  13. return h ^ (h >>> 7) ^ (h >>> 4);   
  14. }  
Java程式碼
  1. privatestaticint oldHash(int h) {  
  2.     h += ~(h << 9);  
  3.     h ^=  (h >>> 14);  
  4.     h +=  (h << 4);  
  5.     h ^=  (h >>> 10);  
  6.     return h;  
  7. }  
  8. privatestaticint newHash(int h) {  
  9.     // This function ensures that hashCodes that differ only by
  10.     // constant multiples at each bit position have a bounded
  11.     // number of collisions (approximately 8 at default load factor).
  12.     h ^= (h >>> 20) ^ (h >>> 12);  
  13.     return h ^ (h >>> 7) ^ (h >>> 4);  
  14. }  



其實HashMap的雜湊函式會一直都是oldHash。


如果確定資料的位置
看下面兩行
 

Java程式碼 複製程式碼 收藏程式碼
  1. int hash = hash(k.hashCode());   
  2. int i = indexFor(hash, table.length);  
Java程式碼
  1. int hash = hash(k.hashCode());  
  2.   int i = indexFor(hash, table.length);  

第一行，上面講過了，是得到雜湊值，第二行，則是根據雜湊指計算元素在陣列中的位置了，位置的計算是將雜湊值和陣列長度按位與運算。

Java程式碼 複製程式碼 收藏程式碼
  1. staticint indexFor(int h, int length) {   
  2. return h & (length-1);   
  3.  }  
Java程式碼
  1. staticint indexFor(int h, int length) {  
  2.      return h & (length-1);  
  3.  }  

“h & (length-1)”其實這裡是很有講究的，為什麼是和(length-1)進行按位與運算呢？這樣做是為了提高HashMap的效率。什麼？這樣能提高效率？且聽我細細道來。

首先我們要確定一下，HashMap的陣列長度永遠都是偶數，即使你在初始化的時候是這樣的new HashMap(15,0.75);因為在建構函式內部，上面也講過，有這樣的一段程式碼：

Java程式碼 複製程式碼 收藏程式碼
  1. while (capacity < initialCapacity)   
  2.             capacity <<= 1;  
Java程式碼
  1. while (capacity < initialCapacity)  
  2.             capacity <<= 1;  

所以length-1一定是個奇數，假設現在長度為16，減去1後就是15，對應的二進位制是：1111。

假設有兩個元素，一個雜湊值是8，二進位制是1000，一個雜湊值是9，二進位制是1001。和1111與運算後，分別還是1000和1001，它們被分配在了陣列的不同位置，這樣，雜湊的分佈非常均勻。

那麼，如果陣列長度是奇數，減去1後就是偶數了，偶數對應的二進位制最低位一定是0了，例如14二進位制1110。對上面兩個數子分別與運算，得到1000和1000。看到了嗎？都是一樣的值，雜湊值8和9的元素多被儲存在陣列同一個位置的連結串列中。在操作的時候，連結串列中的元素越多，效率越低，因為要不停的對連結串列迴圈比較。所以，一定要雜湊均勻分佈，儘量減少雜湊衝突，減少了雜湊衝突，就減少了連結串列迴圈，就提高了效率。


put方法到底作了什麼？

Java程式碼 複製程式碼 收藏程式碼
  1. public V put(K key, V value) {   
  2. if (key == null)   
  3. return putForNullKey(value);   
  4. int hash = hash(key.hashCode());   
  5. int i = indexFor(hash, table.length);   
  6. for (Entry<K,V> e = table[i]; e != null; e = e.next) {   
  7.          Object k;   
  8. if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {   
  9.              V oldValue = e.value;   
  10.              e.value = value;   
  11.              e.recordAccess(this);   
  12. return oldValue;   
  13.          }   
  14.      }   
  15.      modCount++;   
  16.      addEntry(hash, key, value, i);   
  17. returnnull;   
  18.  }  
Java程式碼
  1. public V put(K key, V value) {  
  2.  if (key == null)  
  3.      return putForNullKey(value);  
  4.      int hash = hash(key.hashCode());  
  5.      int i = indexFor(hash, table.length);  
  6.      for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
  7.          Object k;  
  8.          if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
  9.              V oldValue = e.value;  
  10.              e.value = value;  
  11.              e.recordAccess(this);  
  12.              return oldValue;  
  13.          }  
  14.      }  
  15.      modCount++;  
  16.      addEntry(hash, key, value, i);  
  17.      returnnull;  
  18.  }  


如果key為NULL，則是單獨處理的，看看putForNullKey方法：
 

Java程式碼 複製程式碼 收藏程式碼
  1. private V putForNullKey(V value) {   
  2. int hash = hash(NULL_KEY.hashCode());   
  3. int i = indexFor(hash, table.length);   
  4. for (Entry<K,V> e = table[i]; e != null; e = e.next) {   
  5. if (e.key == NULL_KEY) {   
  6.               V oldValue = e.value;   
  7.               e.value = value;   
  8.               e.recordAccess(this);   
  9. return oldValue;   
  10.           }   
  11.       }   
  12.       modCount++;   
  13.       addEntry(hash, (K) NULL_KEY, value, i);   
  14. returnnull;   
  15.   }  
Java程式碼
  1. private V putForNullKey(V value) {  
  2.       int hash = hash(NULL_KEY.hashCode());  
  3.       int i = indexFor(hash, table.length);  
  4.       for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
  5.           if (e.key == NULL_KEY) {  
  6.               V oldValue = e.value;  
  7.               e.value = value;  
  8.               e.recordAccess(this);  
  9.               return oldValue;  
  10.           }  
  11.       }  
  12.       modCount++;  
  13.       addEntry(hash, (K) NULL_KEY, value, i);  
  14.       returnnull;  
  15.   }  

NULL_KEY的宣告：static final Object NULL_KEY = new Object();
這一段程式碼是處理雜湊衝突的，就是說，在陣列某個位置的物件可能並不是唯一的，它是一個連結串列結構，根據雜湊值找到連結串列後，還要對連結串列遍歷，找出key相等的物件，替換它，並且返回舊的值。

Java程式碼 複製程式碼 收藏程式碼
  1. for (Entry<K,V> e = table[i]; e != null; e = e.next) {   
  2. if (e.key == NULL_KEY) {   
  3.              V oldValue = e.value;   
  4.              e.value = value;   
  5.              e.recordAccess(this);   
  6. return oldValue;   
  7.          }   
  8.      }  
Java程式碼
  1. for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
  2.          if (e.key == NULL_KEY) {  
  3.              V oldValue = e.value;  
  4.              e.value = value;  
  5.              e.recordAccess(this);  
  6.              return oldValue;  
  7.          }  
  8.      }  

如果遍歷完了該位置的連結串列都沒有找到有key相等的，那麼將當前物件增加到連結串列裡面去

Java程式碼 複製程式碼 收藏程式碼
  1. modCount++;   
  2. addEntry(hash, (K) NULL_KEY, value, i);   
  3. returnnull;  
Java程式碼
  1. modCount++;  
  2. addEntry(hash, (K) NULL_KEY, value, i);  
  3. returnnull;  

且看看addEntry方法

Java程式碼 複製程式碼 收藏程式碼
  1. void addEntry(int hash, K key, V value, int bucketIndex) {   
  2. Entry<K,V> e = table[bucketIndex];   
  3.     table[bucketIndex] = new Entry<K,V>(hash, key, value, e);   
  4. if (size++ >= threshold)   
  5.         resize(2 * table.length);   
  6. }  
Java程式碼
  1. void addEntry(int hash, K key, V value, int bucketIndex) {  
  2. Entry<K,V> e = table[bucketIndex];  
  3.     table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
  4.     if (size++ >= threshold)  
  5.         resize(2 * table.length);  
  6. }  

table[bucketIndex] = new Entry<K,V>(hash, key, value, e);新建一個Entry物件，並放在當前位置的Entry連結串列的頭部，看看下面的 Entry建構函式就知道了，注意紅色部分。

Java程式碼 複製程式碼 收藏程式碼
  1. Entry(int h, K k, V v, Entry<K,V> n) {   
  2.        value = v;   
  3.        next = n;   
  4.        key = k;   
  5.        hash = h;   
  6.    }  
Java程式碼
  1. Entry(int h, K k, V v, Entry<K,V> n) {  
  2.        value = v;  
  3.        next = n;  
  4.        key = k;  
  5.        hash = h;  
  6.    }  

如何擴容？
        當put一個元素時，如果達到了容量限制，HashMap就會擴容，新的容量永遠是原來的2倍。
上面的put方法裡有這樣的一段：

Java程式碼 複製程式碼 收藏程式碼
  1. if (size++ >= threshold)   
  2.             resize(2 * table.length);  
Java程式碼
  1. if (size++ >= threshold)  
  2.             resize(2 * table.length);  

這是擴容判斷，要注意，並不是資料尺寸達到HashMap的最大容量時才擴容，而是達到 threshold指定的值時就開始擴容， threshold＝最大容量＊載入因子。 看看resize方法

Java程式碼 複製程式碼 收藏程式碼
  1. void resize(int newCapacity) {   
  2.       Entry[] oldTable = table;   
  3. int oldCapacity = oldTable.length;   
  4. if (oldCapacity == MAXIMUM_CAPACITY) {   
  5.           threshold = Integer.MAX_VALUE;   
  6. return;   
  7.       }   
  8.       Entry[] newTable = new Entry[newCapacity];   
  9.       transfer(newTable);   
  10.       table = newTable;   
  11.       threshold = (int)(newCapacity * loadFactor);   
  12.   }  
Java程式碼
  1. void resize(int newCapacity) {  
  2.       Entry[] oldTable = table;  
  3.       int oldCapacity = oldTable.length;  
  4.       if (oldCapacity == MAXIMUM_CAPACITY) {  
  5.           threshold = Integer.MAX_VALUE;  
  6.           return;  
  7.       }  
  8.       Entry[] newTable = new Entry[newCapacity];  
  9.       transfer(newTable);  
  10.       table = newTable;  
  11.       threshold = (int)(newCapacity * loadFactor);  
  12.   }  

重點看看紅色部分的 transfer方法
 

Java程式碼 複製程式碼 收藏程式碼
  1. void transfer(Entry[] newTable) {   
  2.       Entry[] src = table;   
  3. int newCapacity = newTable.length;   
  4. for (int j = 0; j < src.length; j++) {   
  5.           Entry<K,V> e = src[j];   
  6. if (e != null) {   
  7.               src[j] = null;   
  8. do {   
  9.                   Entry<K,V> next = e.next;   
  10. int i = indexFor(e.hash, newCapacity);   
  11.                   e.next = newTable[i];   
  12.                   newTable[i] = e;   

    相關推薦

    hashmap深入分析

     java.util.HashMap是很常見的類，前段時間公司系統由於對HashMap使用不當，導致cpu百分之百，在併發環境下使用HashMap 而沒有做同步，可能會引起死迴圈，關於這一點，sun的官方網站上已有闡述，這並非是bug。HashMap的資料結構       

    終極HashSet HashMap TreeSet TreeMap深入分析上

    首先講解HashSet Set<String> set = new HashSet<>();         set.add("e");         

    終極HashSet HashMap TreeSet TreeMap深入分析下

    最常用的 Map<String,String> map =new HashMap<String,String>();  System.out.println("常用==============");    這是最常用的  &nb

    深入分析hashmap

    一、傳統 HashMap的缺點 (1)JDK 1.8 以前 HashMap 的實現是 陣列+連結串列，即使雜湊函式取得再好，也很難達到元素百分百均勻分佈。 (2)當 HashMap 中有大量的元素都存放到同一個桶中時，這個桶下有一條長長的連結串列，這個時候 HashMap 就相當於一個單鏈

    java集合類深入分析之HashSet, HashMap

        Map和Set是比較常用的兩種資料結構。我們在平常的程式設計中經常會用到他們。只是他們的內部實現機制到底是怎麼樣的呢？瞭解他們的具體實現對於我們如何有效的去使用他們也是很有幫助的。這裡主要是針對Map, Set這兩種型別的資料結構規約和典型的HashMap,HashSet實現做一個討論。 Map

    【集合框架】之深入分析HashMap

    提出並解決問題如下： 問題1：初始容量為什麼是16，為什麼必須是2的冪？ 問題2： hash方法為什麼是無符號右移16位？ 問題3： 問題4： 問題5： HashMap 非執行緒安全 繼承於AbstractMap 實現了Map、Clon

    深入分析HashMap的底層實現

    底層實現     當向 HashMap 中 put 一對鍵值時：         它會根據 key 的 hashCode 的hash演算法值計算出一個位置， 該位置就是此物件準備往陣列中存放的位置。 

    深入分析Volatile的實現原理

    queue 鏈接地址 什麽 高速緩存 spa 其中 帶來 系統內存 單詞 引言 在多線程並發編程中synchronized和Volatile都扮演著重要的角色，Volatile是輕量級的synchronized，它在多處理器開發中保證了共享變量的“可見性”。可見性的意思是當

    Activity啟動模式的深入分析

    啟用 ide net 啟動模式 soft adding class 任務 新的 網上關於Activity啟動模式的文章許多。可是看起來都千篇一律，看完之後我們都能理解這4種啟動模式。只是官方api對singleTask這個啟動模式解釋有些爭議，導致我事實

    Buffer源碼深入分析

    buffer本機環境：Linux 4.4.0-21-generic #37-Ubuntu SMP Mon Apr 18 18:33:37 UTC 2016 x86_64 x86_64 x86_64 GNU/LinuxBufferBuffer的類圖如下：除了Boolean，其他基本數據類型都有對應的Buffer

    深入分析JavaWeb Item13 -- jsp指令具體解釋

    性能 異常信息 content ... pin 簡單 markdown 分隔 一個 一、JSP指令簡單介紹 　　JSP指令（directive）是為JSP引擎而設計的。它們並不直接產生不論什麽可見輸出，而僅僅是告訴引擎怎樣處理JSP頁面中的其余部分。

    深入分析JavaWeb Item47 -- Struts2攔截器與文件上傳下載

    com custom public 面向切面 lang down pri 多功能 art 一、struts2中的攔截器（框架功能核心） 1、過濾器VS攔截器 過濾器VS攔截器功能是一回事。過濾器是Servlet規範中的技術，能夠對請求和響應進行過濾。

    深入分析Java ClassLoader原理

    lec version 虛擬機 open rdl nds str rac pro 一、什麽是ClassLoader? 大家都知道。當我們寫好一個Java程序之後。不是管是CS還是BS應用，都是由若幹個.class文件組織而成的一個完整的Java應用程序

    <<深入分析javaWeb技術內幕>>讀書筆記-JVM內存管理2

    空間 不同 class logs 減少 src 一次 ges jvm垃圾回收 JVM垃圾回收策略 1.靜態內存分配和回收 　　編譯時已經確定了內存空間大小,程序被加載後則一次性分配好內存空間.程序結束後,則對應棧幀撤銷,分配的靜態內存空間則被回收. 2.動態內存分配和回收

    Servlet工作原理（讀許令波《深入分析javaWeb技術內幕》）筆記

    container 創建 onf 應用 最重要的 深入分析 conf con 技術內幕 在介紹servlet的工作原理之前首先我們要先了解一下與servlet配套的servlet容器，本文以tomcat為例 1.Tomcat容器的基礎知識 Tomcat的容器是分級管理共分為

    深入分析_linux_spinlock_實現機制【轉】

    源碼 idt 內存 獲取 編寫 存在 www 浪費 理論 轉自：http://blog.csdn.net/electrombile/article/details/51289813 在 x86 平臺上，spinlock 主要通過處理器的 lock 指令前綴實現當某個線

    深入分析Java ClassLoader的原理

    reflect 打包成 dog ret tail package nod jdk1 分析 一、什麽是ClassLoader? 大家都知道，當我們寫好一個Java程序之後，不是管是CS還是BS應用，都是由若幹個.class文件組織而成的一個完整的Java應用

    深入分析一波，你們說的雲安全到底是什麽鬼？

    基於 區塊鏈 workload 策略 直接 未來 國家 場景 大數據 雲安全到底是什麽？是傳統廠商的盒子的iso化？是雲廠商自身具備的安全能力？還是SaaS提供安全服務？這些觀點都比較片面，作為聊天話題還可以，但落地還需要認真討論。 一、雲安全標準 要想了解雲安全

    深入分析JavaWeb技術內幕（修訂版）》【PDF】下載

    java技術 js文件 pan nio 基於 java服務 域名 緩存機制 分析 《深入分析JavaWeb技術內幕（修訂版）》【PDF】下載鏈接: https://u253469.pipipan.com/fs/253469-230062569 內容簡介 《深入分

    Java Web 深入分析（4） Java I/O 深入分析

    lock 異步 瓶頸 系統 基本結構 java 同步異步 nio -i I/O問題可以說是現在大部分web系統的瓶頸。我們要了解的java I/O(後面簡稱為（io）) io類庫的基本結構 -磁盤io的工作機制 -網絡io的工作機制 -NIO的工作方式 -同步異步、阻