實際應用：

Java程式碼  

1.  ConcurrentMap<String, String> map = new ConcurrentHashMap<String, String>();  
2. String oldValue = map.put("zhxing", "value");  
3. String oldValue1 = map.put("zhxing", "value1");  
4. String oldValue2 = map.putIfAbsent("zhxing", "value2");  
5. String value = map.get("zhxing");  
6. System.out.println("oldValue:" + oldValue);  
7. System.out.println("oldValue1:" + oldValue1);  
8. System.out.println("oldValue2:" + oldValue2);  
9. System.out.println("value:" + value);  

輸出結果：

Java程式碼  

1. oldValue:null
2. oldValue1:value  
3. oldValue2:value1  
4. value:value1  

先從new 方法開始

Java程式碼  

1. /** 
2.      * Creates a new, empty map with a default initial capacity (16), load
    
3.      * factor (0.75) and concurrencyLevel（也就是鎖的個數） (16). 
4.      *  
5.      */
6. public ConcurrentHashMap() {  
7.         this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);  
8.     }  
9. // 當都是預設的設定引數
10.     public ConcurrentHashMap(int initialCapacity, float loadFactor,  
11.             int concurrencyLevel) {  
12.         if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)  
13.             thrownew IllegalArgumentException();  
14.         // MAX_SEGMENTS = 1 << 16，鎖的個數有限制
15.         if (concurrencyLevel > MAX_SEGMENTS)  
16.             concurrencyLevel = MAX_SEGMENTS;  
17.         // Find power-of-two sizes best matching arguments
18.         // 這裡是根據設定的併發數查詢最優的併發數
19.         int sshift = 0;  
20.         int ssize = 1;  
21.         while (ssize < concurrencyLevel) {  
22.             ++sshift;  
23.             ssize <<= 1;// 不斷右移
24.         }  
25.         // 到這裡，sshift=4，ssize=16.因為concurrencyLevel=16=1<<4
26.         segmentShift = 32 - sshift;// =16
27.         segmentMask = ssize - 1;// =3
28.         // 建立了16個分段（Segment），其實每個分段相當於一個帶鎖的map
29.         this.segments = Segment.newArray(ssize);  
30.         if (initialCapacity > MAXIMUM_CAPACITY)  
31.             initialCapacity = MAXIMUM_CAPACITY;  
32.         // 這裡是計算每個分段儲存的容量
33.         int c = initialCapacity / ssize;// c=16/16=1
34.         if (c * ssize < initialCapacity)// 防止分段的相加的容量小於總容量
35.             ++c;  
36.         int cap = 1;  
37.         // 如果初始容量比cap的容量小，則已雙倍的容量增加
38.         while (cap < c)  
39.             cap <<= 1;  
40.         // 分別new分段
41.         for (int i = 0; i < this.segments.length; ++i)  
42.             this.segments[i] = new Segment<K, V>(cap, loadFactor);  
43.     }  

這裡提到了一個Segment 這個類，其實這個是總map 的分段，就是為了實現分段鎖機制。

Java程式碼  

1. /** 
2.      * Segments are specialized versions of hash tables. This subclasses from 
3.      * ReentrantLock opportunistically, just to simplify some locking and avoid 
4.      * separate construction. map 的分段實現，擴充套件了鎖機制 
5.      */
6.     staticfinalclass Segment<K, V> extends ReentrantLock implements
7.             Serializable {  
8. //。。。
9. Segment(int initialCapacity, float lf) {  
10.             loadFactor = lf;  
11.             // 這個是開始初始化map容器了
12.             setTable(HashEntry.<K, V> newArray(initialCapacity));  
13.         }  
14.         /** 
15.          * Sets table to new HashEntry array. Call only while holding lock or in 
16.          * constructor. 
17.          */
18.         void setTable(HashEntry<K, V>[] newTable) {  
19.             threshold = (int) (newTable.length * loadFactor);  
20.             table = newTable;  
21.         }  
22. }  
23.     // 這個是實際儲存到map的東西了，如果對HashMap原始碼有了解的話，是不是覺得很像Hash.Entry，但又沒實現Map.Entry介面，它是用另外個類WriteThroughEntry
24.     // 來實現這個Map.Entry介面的。
25.     staticfinalclass HashEntry<K, V> {  
26.         final K key;  
27.         finalint hash;  
28.         volatile V value;  
29.         final HashEntry<K, V> next;  
30.         HashEntry(K key, int hash, HashEntry<K, V> next, V value) {  
31.             this.key = key;  
32.             this.hash = hash;  
33.             this.next = next;  
34.             this.value = value;  
35.         }  
36.         @SuppressWarnings("unchecked")  
37.         // 新建陣列，儲存著map裡的鍵值對
38.         staticfinal <K, V> HashEntry<K, V>[] newArray(int i) {  
39.             returnnew HashEntry[i];  
40.         }  

get方法實現

Java程式碼  

1. //ConcurrentHashMap類    
2. // 在這裡發現，get操作幾乎是不帶鎖的。。效率提高很多
3.     public V get(Object key) {  
4.         // key不能為null 。。
5.         int hash = hash(key); // throws NullPointerException if key null
6.         return segmentFor(hash).get(key, hash);  
7.     }  
8.     // 這個hash方式不太懂，估計是為了能均勻分佈吧
9.     staticint hash(Object x) {  
10.         int h = x.hashCode();  
11.         h += ~(h << 9);  
12.         h ^= (h >>> 14);  
13.         h += (h << 4);  
14.         h ^= (h >>> 10);  
15.         return h;  
16.     }  
17.     /** 
18.      * Returns the segment that should be used for key with given hash 這個是尋找所在分段 
19.      *  
20.      * @param hash 
21.      *            the hash code for the key 
22.      * @return the segment 
23.      */
24.     final Segment<K, V> segmentFor(int hash) {  
25.         // hash>>>16&3
26.         return segments[(hash >>> segmentShift) & segmentMask];  
27.     }  
28. //Segment 類方法
29.         /* Specialized implementations of map methods */
30.         // 獲得值了，和其他map的get的實現其實差不多
31.         V get(Object key, int hash) {  
32.             // count 是每個分段的鍵值對個數，而且是volatile，保證在記憶體中只有一份
33.             if (count != 0) { // read-volatile
34.                 // 獲得分段中hash連結串列的第一個值
35.                 HashEntry<K, V> e = getFirst(hash);  
36.                 while (e != null) {  
37.                     if (e.hash == hash && key.equals(e.key)) {  
38.                         V v = e.value;  
39.                         if (v != null)  
40.                             return v;  
41.                         // 這個做了一個挺有趣的檢查，如果v==null，而key!=null,的時候會等待鎖中value的值
42.                         return readValueUnderLock(e); // recheck
43.                     }  
44.                     e = e.next;  
45.                 }  
46.             }  
47.             returnnull;  
48.         }  
49.         /** 
50.          * Reads value field of an entry under lock. Called if value field ever 
51.          * appears to be null. This is possible only if a compiler happens to 
52.          * reorder a HashEntry initialization with its table assignment, which 
53.          * is legal under memory model but is not known to ever occur. 
54.          */
55.         V readValueUnderLock(HashEntry<K, V> e) {  
56.             lock();  
57.             try {  
58.                 return e.value;  
59.             } finally {  
60.                 unlock();  
61.             }  
62.         }  

put 方法

Java程式碼  

1. //ConcurrentHashMap類
2.     // 注意的是key 和value 都不能為空
3.     public V put(K key, V value) {  
4.         if (value == null)  
5.             thrownew NullPointerException();  
6.         // 和get方式一樣的hash 方式
7.         int hash = hash(key);  
8.         return segmentFor(hash).put(key, hash, value, false);  
9.     }  
10. //Segment 類
11.     V put(K key, int hash, V value, boolean onlyIfAbsent) {  
12.             // 這裡加鎖了
13.             lock();  
14.             try {  
15.                 int c = count;  
16.                 // 如果超過限制，就重新分配
17.                 if (c++ > threshold) // ensure capacity
18.                     rehash();  
19.                 HashEntry<K, V>[] tab = table;  
20.                 int index = hash & (tab.length - 1);  
21.                 HashEntry<K, V> first = tab[index];  
22.                 HashEntry<K, V> e = first;  
23.                 // e的值總是在連結串列的最後一個
24.                 while (e != null && (e.hash != hash || !key.equals(e.key)))  
25.                     e = e.next;  
26.                 V oldValue;  
27.                 if (e != null) {  
28.                     oldValue = e.value;  
29.                     // 這裡就是實現putIfAbsent 的方式
30.                     if (!onlyIfAbsent)  
31.                         e.value = value;  
32.                 } else {  
33.                     oldValue = null;  
34.                     ++modCount;  
35.                     tab[index] = new HashEntry<K, V>(key, hash, first, value);  
36.                     count = c; // write-volatile
37.                 }  
38.                 return oldValue;  
39.             } finally {  
40.                 unlock();  
41.             }  
42.         }  
43.         // 這中擴容方式應該和其他map 的擴容一樣
44.         void rehash() {  
45.             HashEntry<K, V>[] oldTable = table;  
46.             int oldCapacity = oldTable.length;  
47.             // 如果到了最大容量則不能再擴容了，max=1<<30，這將可能導致的一個後果是map的操作越來越慢
48.             if (oldCapacity >= MAXIMUM_CAPACITY)  
49.                 return;  
50.             /* 
51.              * Reclassify nodes in each list to new Map. Because we are using 
52.              * power-of-two expansion, the elements from each bin must either 
53.              * stay at same index, or move with a power of two offset. We 
54.              * eliminate unnecessary node creation by catching cases where old 
55.              * nodes can be reused because their next fields won't change. 
56.              * Statistically, at the default threshold, only about one-sixth of 
57.              * them need cloning when a table doubles. The nodes they replace 
58.              * will be garbage collectable as soon as they are no longer 
59.              * referenced by any reader thread that may be in the midst of 
60.              * traversing table right now. 
61.              */
62.             // 以兩倍的方式增長
63.             HashEntry<K, V>[] newTable = HashEntry.newArray(oldCapacity << 1);  
64.             threshold = (int) (newTable.length * loadFactor);  
65.             int sizeMask = newTable.length - 1;  
66.             // 下面的資料拷貝就沒多少好講的了
67.             for (int i = 0; i < oldCapacity; i++) {  
68.                 // We need to guarantee that any existing reads of old Map can
69.                 // proceed. So we cannot yet null out each bin.
70.                 HashEntry<K, V> e = oldTable[i];  
71.                 if (e != null) {  
72.                     HashEntry<K, V> next = e.next;  
73.                     int idx = e.hash & sizeMask;  
74.                     // Single node on list
75.                     if (next == null)  
76.                         newTable[idx] = e;  
77.                     else {  
78.                         // Reuse trailing consecutive sequence at same slot
79.                         HashEntry<K, V> lastRun = e;  
80.                         int lastIdx = idx;  
81.                         for (HashEntry<K, V> last = next; last != null; last = last.next) {  
82.                             int k = last.hash & sizeMask;  
83.                             if (k != lastIdx) {  
84.                                 lastIdx = k;  
85.                                 lastRun = last;  
86.                             }  
87.                         }  
88.                         newTable[lastIdx] = lastRun;  
89.                         // Clone all remaining nodes
90.                         for (HashEntry<K, V> p = e; p != lastRun; p = p.next) {  
91.                             int k = p.hash & sizeMask;  
92.                             HashEntry<K, V> n = newTable[k];  
93.                             newTable[k] = new HashEntry<K, V>(p.key, p.hash, n,  
94.                                     p.value);  
95.                         }  
96.                     }  
97.                 }  
98.             }  
99.             table = newTable;  
100.         }  

size 方法

Java程式碼  

1. /** 
2.  * Returns the number of key-value mappings in this map. If the map contains 
3.  * more than <tt>Integer.MAX_VALUE</tt> elements, returns 
4.  * <tt>Integer.MAX_VALUE</tt>. javadoc 上也寫明瞭，返回的數值不能超過Int的最大值，超過也返回最大值 
5.  * 在下面的分析也可以看出，為了減少鎖競爭做了一些效能優化，這種的優化方式在很多方法都有使用 
6.  *  
7.  * @return the number of key-value mappings in this map 
8.  */
9. publicint size() {  
10.     final Segment<K, V>[] segments = this.segments;  
11.     long sum = 0;  
12.     long check = 0;  
13.     int[] mc = newint[segments.length];  
14.     // Try a few times to get accurate count. On failure due to
15.     // continuous async changes in table, resort to locking.
16.     // 這裡最多試RETRIES_BEFORE_LOCK=2 次的檢查對比
17.     for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {  
18.         check = 0;  
19.         sum = 0;// size 總數
20.         int mcsum = 0;// 修改的總次數
21.         // 這裡儲存了一份對比值，供下次對比時使用
22.         for (int i = 0; i < segments.length; ++i) {  
23.             sum += segments[i].count;  
24.             mcsum += mc[i] = segments[i].modCount;  
25.         }  
26.         // 只有當map初始化的時候才等於0
27.         if (mcsum != 0) {  
28.             // 在此對比上面儲存的修改值
29.             for (int i = 0; i < segments.length; ++i) {  
30.                 check += segments[i].count;  
31.                 if (mc[i] != segments[i].modCount) {  
32.                     check = -1; // force retry
33.                     break;  
34.                 }  
35.             }  
36.         }  
37.         // 檢查和第一次儲存值一樣則結束迴圈
38.         if (check == sum)  
39.             break;  
40.     }  
41.     // 當不相等的時候，這裡就只有用鎖來保證正確性了
42.     if (check != sum) { // Resort to locking all segments
43.         sum = 0;  
44.         for (int i = 0; i < segments.length; ++i)  
45.             segments[i].lock();  
46.         for (int i = 0; i < segments.length; ++i)  
47.             sum += segments[i].count;  
48.         for (int i = 0; i < segments.length; ++i)  
49.             segments[i].unlock();  
50.     }  
51.     // 這裡也可以看出，如果超過int 的最大值值返回int 最大值
52.     if (sum > Integer.MAX_VALUE)  
53.         return Integer.MAX_VALUE;  
54.     else
55.         return (int) sum;  
56. }  

keys 方法

Java程式碼  

1. public Enumeration<K> keys() {  
2.         //這裡新建了一個內部Iteraotr 類
3.         returnnew KeyIterator();  
4.     }  
5. //這裡主要是繼承了HashIterator 方法，基本的實現都在HashIterator 中
6.     finalclass KeyIterator extends HashIterator implements Iterator<K>,  
7.             Enumeration<K> {  
8.         public K next() {  
9.             returnsuper.nextEntry().key;  
10.         }  
11.         public K nextElement() {  
12.             returnsuper.nextEntry().key;  
13.         }  
14.     }  
15.     /* ---------------- Iterator Support -------------- */
16.     // 分析程式碼發現，這個遍歷過程沒有涉及到鎖，檢視Javadoc 後可知該檢視的 iterator 是一個“弱一致”的迭代器。。
17.     abstractclass HashIterator {  
18.         int nextSegmentIndex;// 下一個分段的index
19.         int nextTableIndex;// 下一個分段的容器的index
20.         HashEntry<K, V>[] currentTable;// 當前容器
21.         HashEntry<K, V> nextEntry;// 下個鍵值對
22.         HashEntry<K, V> lastReturned;// 上次返回的鍵值對
23.         HashIterator() {  
24.             nextSegmentIndex = segments.length - 1;  
25.             nextTableIndex = -1;  
26.             advance();  
27.         }  
28.         publicboolean hasMoreElements() {  
29.             return hasNext();  
30.         }  
31.         // 先變數鍵值對的連結串列，再對table 陣列的index 遍歷，最後遍歷分段陣列的index。。這樣就可以完整的變數完所有的entry了
32.         finalvoid advance() {  
33.             // 先變數鍵值對的連結串列
34.             if (nextEntry != null && (nextEntry = nextEntry.next) != null)  
35.                 return;  
36.             // 對table 陣列的index 遍歷
37.             while (nextTableIndex >= 0) {  
38.                 if ((nextEntry = currentTable[nextTableIndex--]) != null)  
39.                     return;  
40.             }  
41.             // 遍歷分段陣列的index
42.             while (nextSegmentIndex >= 0) {  
43.                 Segment<K, V> seg = segments[nextSegmentIndex--];  
44.                 if (seg.count != 0) {  
45.                     currentTable = seg.table;  
46.                     for (int j = currentTable.length - 1; j >= 0; --j) {  
47.                         if ((nextEntry = currentTable[j]) != null) {  
48.                             nextTableIndex = j - 1;  
49.                             return;  
50.                         }  
51.                     }  
52.                 }  
53.             }  
54.         }  
55.         publicboolean hasNext() {  
56.             return nextEntry != null;  
57.         }  
58.         HashEntry<K, V> nextEntry() {  
59.             if (nextEntry == null)  
60.                 thrownew NoSuchElementException();  
61.             // 把上次的entry換成當前的entry
62.             lastReturned = nextEntry;  
63.             // 這裡做一些預操作
64.             advance();  
65.             return lastReturned;  
66.         }  
67.         publicvoid remove() {  
68.             if (lastReturned == null)  
69.                 thrownew IllegalStateException();  
70.             ConcurrentHashMap.this.remove(lastReturned.key);  
71.             lastReturned = null;  
72.         }  
73.     }  

keySet/Values/elements 這幾個方法都和keys 方法非常相似。。就不解釋了。。而entrySet 方法有點特別。。我也有點不是很明白。。

Java程式碼  

1. //這裡沒什麼好說的，看下就明白，主要在下面
2. public Set<Map.Entry<K, V>> entrySet() {  
3.         Set<Map.Entry<K, V>> es = entrySet;  
4.         return (es != null) ? es : (entrySet = new EntrySet());  
5.     }  
6.     finalclass EntrySet extends AbstractSet<Map.Entry<K, V>> {  
7.         public Iterator<Map.Entry<K, V>> iterator() {  
8.             returnnew EntryIterator();  
9.         }  
10. }  
11. 相關推薦

    併發集合在分析之CurrentHashMap之從應用去分析，分段加鎖應用

       實際應用： Java程式碼    ConcurrentMap<String, String> map = new ConcurrentHashMap<String, String>();  String oldValue = map.

    python之使用set對列表去重，並保持列表原來順序

    原來 div 無重復 列表 mys ddr body afa key #原始方法，但是會打亂順序 mylist = [1,2,2,2,2,3,3,3,4,4,4,4]myset = set(mylist) #myset是另外一個列表，裏面的內容是mylist裏面的無重復 項

    雲計算從零開始學，雲計算的應用領域

    box 中心 開始 三層 發展 有意思 ice dropbox 網絡架構 雲計算這個名詞來自於Google，而最早的雲計算產品來自於Amazon。有意思的是，Google在2006年正式提出雲計算這個名詞的時候，Amazon的雲計算產品AWS(Amazon Web Serv

    語音識別之——mfcc什麼是漢明窗，為什麼加漢明窗

    為什麼要加漢明窗？什麼叫加窗？  在訊號處理中，可以說加窗處理是一個必經的過程，因為我們的計算機只能處理有限長度的訊號，因此原始訊號X(t)要以T（取樣時間）截斷，即有限化，成為XT(t)後再進一步處理，這個過程式就是加窗處理，但什麼時候用什麼窗呢？這時我們就要對所需用到

    從通知裡啟動應用的activity，返回時返回應用的主介面

    其實這個開發主要是一種開發思路：我的思路大致是這樣的。 1. 首先在啟動這個具體的activity之前，判斷當前應用是否在棧頂，如果在，就不啟動主Activity了，如果不在則啟動主Activity；

    一個人開發一個產品，小程式從0到1，第3章 應用檔案

    一個小程式專案，在根目錄下會有3個應用檔案，一個是全域性業務邏輯檔案app.js，一個是公共配置檔案app.json，還有一個是公共樣式表文件app.wxss。在這3個檔案中，app.js和app.json是不可刪除，是必須有的檔案。 3.1 app.js 開啟檔案的那一瞬間，我才知道：人生遇到的人很多，但真

    多執行緒，高併發的情況下操作redis當中的資料，如何加鎖？

    多個執行緒同時去操作Redis當中的資料，假如不加鎖的情況下，會出現資料重複的問題。假如需要每次都只有一條執行緒去操作Redis當中的資料，需要給操作加上鎖。     但是去網上一搜，網上給Redis加鎖的機制都是利用Redis的setnx自身的方法去加鎖，但是這樣

    iOS惡意應用欺騙使用者，將虛假的應用內購作為合法功能推送

    發現蘋果iOS應用程式商店的兩款應用程式顯示惡意行為，目的是欺騙使用者在不知不覺中為隱藏在看似合法的應用程式功能背後的應用程式內購買支付。 據Reddit上的一篇文章稱，這兩款應用分別名為 "Calories Tracker app" 和 "Fitness Balance app,"它們

    高併發之——從原始碼角度分析建立執行緒池究竟有哪些方式

    前言 在Java的高併發領域，執行緒池一直是一個繞不開的話題。有些童鞋一直在使用執行緒池，但是，對於如何建立執行緒池僅僅停留在使用Executors工具類的方式，那麼，建立執行緒池究竟存在哪幾種方式呢？就讓我們一起從建立執行緒池的原始碼來深入分析究竟有哪些方式可以建立執行緒池。 使用Executors工具類建

    Java內存模型之從JMM角度分析DCL

    span 利用 eight first 多人 能夠 的人 ref upload DCL，即Double Check Lock，中衛雙重檢查鎖定。其實DCL很多人在單例模式中用過，LZ面試人的時候也要他們寫過，但是有很多人都會寫錯。他們為什麽會寫錯呢？其錯誤根源在哪裏？有什麽

    Glide原始碼分析（二）——從用法來看之load&into方法

    上一篇，我們分析了with方法，文章連結： https://blog.csdn.net/qq_36391075/article/details/82833260 在with方法中，進行了Glide的初始化，建立了RequesManger，並且綁定了生命週期，最終返回了一個Reques

    Glide原始碼分析（一）從用法來看之with方法

    繼續啃原始碼，用過Glide的人，肯定都覺得它好好用，我們一般只需要幾行程式碼，就可以達到我們想要的效果，可以在這個背後是什麼呢？就需要我們來看了。 我一般看原始碼，我喜歡先從用法來看，然後一步一步的再細扣，所以就先從用法來看Glide的整體流程。 用過Glide的人，用下面這段

    java併發之原子操作類(AtomicLong原始碼分析)和非阻塞演算法

      背景 近年來，在併發演算法領域的大多數研究都側重於非阻塞演算法，這種演算法用底層的原子機器指令（例如比較併發交換指令）代替鎖來確保資料在併發訪問中的一致性。非阻塞演算法被廣泛的用於在作業系統和JVM中實現執行緒/程序排程機制、垃圾回收機制以及鎖和其他併發資料結構。 與基於鎖

    Bigemap--ArcGIS教程之DEM應用——水文分析

    DEM之坡度坡向分析 Arcgis下DEM水文分析（二）  第一步：需要的工具       1. BIGEMPA地圖下載器       2. Global Mapper 14

    Bigemap教程之ArcGISDEM應用——水文分析

    相關教程：   第一步：需要的工具       1. BIGEMPA地圖下載器（全能版已授權）         2. Global Mapper 14.&

    大資料之storm（一） --- storm簡介，核心元件，工作流程，安裝和部署，電話通訊案例分析，叢集執行，單詞統計案例分析，調整併發度

    一、storm簡介 --------------------------------------------------------- 1.開源，分散式，實時計算 2.實時可靠的處理無限資料流，可以使用任何語言開發 3.適用於實時分析，線上機器學習

    Android 效能分析之TraceView使用(應用耗時分析)

    文章概覽： TraceView概述 trace檔案的3種生成方式 Android studio 直接生成（推薦） 嵌入程式碼程式碼生成 使用DDMS來生成 TraceView介面及引數介紹 使用TraceView分析，定位問題 相關資料 Trace

    java多執行緒之併發集合（CopyOnWriteArrayList）

    CopyOnWriteArrayList:CopyOnWriteArrayList這是一個ArrayList的執行緒安全的變體，其原理大概可以通俗的理解為:初始化的時候只有一個容器，很常一段時間，這個容器資料、數量等沒有發生變化的時候，大家(多個執行緒)，都是讀取(假設這段時

    Oracle官方併發教程之併發集合

    原文地址 譯文地址  譯者：李任  校對：方騰飛 java.util.concurrent包囊括了Java集合框架的一些附加類。它們也最容易按照集合類所提供的介面來進行分類： BlockingQueue定義了一個先進先出的資料結構，當你嘗試往滿佇列中新增元素，或者從空佇列中獲取元素時，將會阻

    Java設計模式之從[Dota地圖]分析享元(Flyweight)模式

    　　在Dota遊戲的地圖中有幾百棵樹，現在假設這些樹木無非是這兩種：白楊、楓樹，數量一共為400棵，那麼，在裝載這個地圖場景的時候，我們是不是應該給這400課樹一一建立物件呢？（如：MapItem tree1 = new MapItem("白楊");MapItem tree