{"id":119645,"date":"2026-10-30T03:32:37","date_gmt":"2026-10-29T19:32:37","guid":{"rendered":"https:\/\/www.wsisp.com\/helps\/119645.html"},"modified":"2026-10-30T03:32:37","modified_gmt":"2026-10-29T19:32:37","slug":"java-%e5%b9%b6%e5%8f%91%e9%9b%86%e5%90%88%ef%bc%9a%e9%94%81%e7%9a%84%e4%bc%97%e7%94%9f%e7%9b%b8","status":"publish","type":"post","link":"https:\/\/www.wsisp.com\/helps\/119645.html","title":{"rendered":"Java \u5e76\u53d1\u96c6\u5408\uff1a\u9501\u7684\u4f17\u751f\u76f8"},"content":{"rendered":"

Java \u96c6\u5408\u7c7b\u91cc，\u5927\u90e8\u5206\u65e5\u5e38\u7528\u7684（ArrayList\u3001HashMap\u3001HashSet）\u90fd\u662f\u65e0\u9501\u7684，\u591a\u7ebf\u7a0b\u76f4\u63a5\u5171\u4eab\u5b83\u4eec\u7b49\u4e8e\u81ea\u627e\u9ebb\u70e6\u3002\u771f\u6b63"\u4e0a\u4e86\u9501"\u7684\u7ebf\u7a0b\u5b89\u5168\u96c6\u5408，\u5176\u5b9e\u662f\u4e00\u5c0f\u64ae\u3002<\/p>\n

\u672c\u6587\u6309\u9501\u7684\u7c7b\u578b\u628a\u5b83\u4eec\u5206\u95e8\u522b\u7c7b，\u4e00\u4e2a\u4e00\u4e2a\u8fc7\u539f\u7406\u3001\u770b\u4ee3\u7801\u3002<\/p>\n

\n

\u4e00\u3001synchronized \u6d3e：\u8001\u724c\u9009\u624b，\u6574\u8868\u4e00\u628a\u9501<\/h3>\n

1. Vector \u2014\u2014 \u6570\u7ec4\u5217\u8868\u7684"\u521d\u4ee3\u5b89\u5168\u7248"<\/h4>\n

\u6982\u5ff5：Vector \u5c31\u662f ArrayList \u7684\u540c\u6b65\u7956\u5148\u3002\u5b83\u7684\u5b9e\u73b0\u65b9\u5f0f\u548c ArrayList \u51e0\u4e4e\u4e00\u6837，\u533a\u522b\u53ea\u6709\u4e00\u4e2a：\u6240\u6709\u65b9\u6cd5\u90fd\u7528 synchronized \u4fee\u9970\u3002<\/p>\n

public<\/span> class<\/span> Vector<\/span><<\/span>E<\/span>><\/span><\/span> extends<\/span> AbstractList<\/span><<\/span>E<\/span>><\/span><\/span>
\n implements<\/span> List<\/span><<\/span>E<\/span>><\/span><\/span>,<\/span> RandomAccess<\/span>,<\/span> Cloneable<\/span>,<\/span> java.<\/span>io.<\/span><\/span>Serializable<\/span> {<\/span><\/p>\n

\/\/ \u6269\u5bb9\u65b9\u6cd5：\u6574\u4e2a\u65b9\u6cd5\u52a0\u9501<\/span>
\n protected<\/span> synchronized<\/span> void<\/span> grow<\/span>(<\/span>int<\/span> minCapacity)<\/span> {<\/span>
\n int<\/span> oldCapacity =<\/span> elementData.<\/span>length;<\/span>
\n \/\/ \u9ed8\u8ba4\u6269\u5bb9\u4e3a\u539f\u6765\u7684 2 \u500d（ArrayList \u662f 1.5 \u500d）<\/span>
\n int<\/span> newCapacity =<\/span> oldCapacity +<\/span> (<\/span>(<\/span>capacityIncrement ><\/span> 0<\/span>)<\/span> ?<\/span>
\n capacityIncrement :<\/span> oldCapacity)<\/span>;<\/span>
\n elementData =<\/span> Arrays<\/span>.<\/span>copyOf<\/span>(<\/span>elementData,<\/span> newCapacity)<\/span>;<\/span>
\n }<\/span><\/p>\n

public<\/span> synchronized<\/span> boolean<\/span> add<\/span>(<\/span>E<\/span> e)<\/span> {<\/span>
\n ensureCapacityHelper<\/span>(<\/span>elementCount +<\/span> 1<\/span>)<\/span>;<\/span>
\n elementData[<\/span>elementCount++<\/span>]<\/span> =<\/span> e;<\/span>
\n return<\/span> true<\/span>;<\/span>
\n }<\/span><\/p>\n

public<\/span> synchronized<\/span> E<\/span> get<\/span>(<\/span>int<\/span> index)<\/span> {<\/span>
\n \/\/ \u68c0\u67e5\u8d8a\u754c\u540e\u76f4\u63a5\u53d6，\u52a0\u9501\u4fdd\u8bc1\u8bfb\u5230\u5b8c\u6574\u6570\u636e<\/span>
\n if<\/span> (<\/span>index >=<\/span> elementCount)<\/span> throw<\/span> new<\/span> ArrayIndexOutOfBoundsException<\/span>(<\/span>index)<\/span>;<\/span>
\n return<\/span> elementData<\/span>(<\/span>index)<\/span>;<\/span>
\n }<\/span>
\n}<\/span><\/p>\n

\u539f\u7406\u8bb2\u89e3：get\u3001add \u8fd9\u79cd\u6700\u7b80\u5355\u7684\u64cd\u4f5c\u4e5f\u52a0\u9501，\u610f\u5473\u7740\u8bfb\u8bfb\u4e4b\u95f4\u4e5f\u8981\u4e92\u65a5\u2014\u2014\u4e24\u4e2a\u7ebf\u7a0b\u53ea\u662f\u5404\u81ea\u8bfb\u5143\u7d20，\u5374\u4e92\u76f8\u963b\u585e\u3002\u8fd9\u5c31\u662f"\u6574\u8868\u4e00\u628a\u9501"\u7684\u4ee3\u4ef7\u3002<\/p>\n

2. Hashtable \u2014\u2014 \u53e4\u8001\u7684\u54c8\u5e0c\u8868<\/h4>\n

\u6982\u5ff5：Hashtable \u4e4b\u4e8e HashMap，\u6b63\u5982 Vector \u4e4b\u4e8e ArrayList\u3002\u5b83\u7684\u6240\u6709\u65b9\u6cd5\u4e5f\u90fd\u662f synchronized，\u4e14\u4e0d\u5141\u8bb8 null \u952e\u503c\u3002<\/p>\n

public<\/span> class<\/span> Hashtable<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span> extends<\/span> Dictionary<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span>
\n implements<\/span> Map<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span>,<\/span> Cloneable<\/span>,<\/span> java.<\/span>io.<\/span><\/span>Serializable<\/span> {<\/span><\/p>\n

public<\/span> synchronized<\/span> V<\/span> put<\/span>(<\/span>K<\/span> key,<\/span> V<\/span> value)<\/span> {<\/span>
\n \/\/ \u4e0d\u5141\u8bb8 null，\u8fd9\u662f\u548c HashMap \u7684\u4e00\u4e2a\u5dee\u5f02\u70b9<\/span>
\n if<\/span> (<\/span>value ==<\/span> null<\/span>)<\/span> throw<\/span> new<\/span> NullPointerException<\/span>(<\/span>)<\/span>;<\/span><\/p>\n

int<\/span> hash =<\/span> key.<\/span>hashCode<\/span>(<\/span>)<\/span>;<\/span>
\n int<\/span> index =<\/span> (<\/span>hash &<\/span> 0x7FFFFFFF<\/span>)<\/span> %<\/span> table.<\/span>length;<\/span><\/p>\n

\/\/ \u904d\u5386\u62c9\u94fe\u4e0a\u7684\u8282\u70b9<\/span>
\n for<\/span> (<\/span>Entry<\/span><<\/span>?<\/span>,<\/span>?<\/span>><\/span><\/span> e =<\/span> table[<\/span>index]<\/span>;<\/span> e !=<\/span> null<\/span> ;<\/span> e =<\/span> e.<\/span>next)<\/span> {<\/span>
\n if<\/span> (<\/span>e.<\/span>hash ==<\/span> hash &&<\/span> e.<\/span>key.<\/span>equals<\/span>(<\/span>key)<\/span>)<\/span> {<\/span>
\n V<\/span> old =<\/span> (<\/span>V<\/span>)<\/span>e.<\/span>value;<\/span>
\n e.<\/span>value =<\/span> value;<\/span>
\n return<\/span> old;<\/span>
\n }<\/span>
\n }<\/span>
\n addEntry<\/span>(<\/span>hash,<\/span> key,<\/span> value,<\/span> index)<\/span>;<\/span>
\n return<\/span> null<\/span>;<\/span>
\n }<\/span><\/p>\n

public<\/span> synchronized<\/span> V<\/span> get<\/span>(<\/span>Object<\/span> key)<\/span> {<\/span>
\n int<\/span> hash =<\/span> key.<\/span>hashCode<\/span>(<\/span>)<\/span>;<\/span>
\n int<\/span> index =<\/span> (<\/span>hash &<\/span> 0x7FFFFFFF<\/span>)<\/span> %<\/span> table.<\/span>length;<\/span>
\n for<\/span> (<\/span>Entry<\/span><<\/span>?<\/span>,<\/span>?<\/span>><\/span><\/span> e =<\/span> table[<\/span>index]<\/span>;<\/span> e !=<\/span> null<\/span> ;<\/span> e =<\/span> e.<\/span>next)<\/span> {<\/span>
\n if<\/span> (<\/span>e.<\/span>hash ==<\/span> hash &&<\/span> e.<\/span>key.<\/span>equals<\/span>(<\/span>key)<\/span>)<\/span> return<\/span> (<\/span>V<\/span>)<\/span>e.<\/span>value;<\/span>
\n }<\/span>
\n return<\/span> null<\/span>;<\/span>
\n }<\/span>
\n}<\/span><\/p>\n

\u539f\u7406\u8bb2\u89e3：put \u548c get \u52a0\u540c\u4e00\u628a\u5bf9\u8c61\u9501（\u5373 Hashtable \u5b9e\u4f8b\u672c\u8eab），\u6240\u4ee5\u4efb\u4f55\u4e00\u4e2a\u7ebf\u7a0b\u7684\u5199，\u90fd\u4f1a\u963b\u585e\u6240\u6709\u7ebf\u7a0b\u7684\u8bfb\u5199\u3002\u5e76\u53d1\u5ea6\u518d\u9ad8，\u4e5f\u53ea\u6709\u4e00\u4e2a\u7ebf\u7a0b\u80fd\u78b0\u5230\u8fd9\u5f20\u8868\u3002<\/p>\n

3. Stack \u2014\u2014 \u968f Vector \u4e00\u8d77\u966a\u846c\u7684\u6808<\/h4>\n

\u6982\u5ff5：Stack \u7ee7\u627f\u81ea Vector，\u6240\u6709\u65b9\u6cd5\u90fd\u662f synchronized\u3002\u6808\u8bed\u4e49\u53ea\u6709 push\u3001pop\u3001peek \u51e0\u4e2a\u64cd\u4f5c，\u5b8c\u5168\u53ef\u4ee5\u7528 ArrayDeque（\u65e0\u9501）\u66ff\u4ee3\u3002<\/p>\n

public<\/span> class<\/span> Stack<\/span><<\/span>E<\/span>><\/span><\/span> extends<\/span> Vector<\/span><<\/span>E<\/span>><\/span><\/span> {<\/span><\/p>\n

public<\/span> synchronized<\/span> E<\/span> push<\/span>(<\/span>E<\/span> item)<\/span> {<\/span>
\n addElement<\/span>(<\/span>item)<\/span>;<\/span> \/\/ \u5e95\u5c42\u5c31\u662f Vector \u7684\u52a0\u9501 addElement<\/span>
\n return<\/span> item;<\/span>
\n }<\/span><\/p>\n

public<\/span> synchronized<\/span> E<\/span> pop<\/span>(<\/span>)<\/span> {<\/span>
\n E<\/span> obj =<\/span> peek<\/span>(<\/span>)<\/span>;<\/span> \/\/ peek \u5185\u90e8\u4e5f\u52a0\u9501，\u53ef\u91cd\u5165\u9501\u5141\u8bb8\u8fd9\u4e48\u5199<\/span>
\n int<\/span> len =<\/span> size<\/span>(<\/span>)<\/span>;<\/span>
\n removeElementAt<\/span>(<\/span>len –<\/span> 1<\/span>)<\/span>;<\/span> \/\/ Vector \u7684\u52a0\u9501\u5220\u9664<\/span>
\n return<\/span> obj;<\/span>
\n }<\/span><\/p>\n

public<\/span> synchronized<\/span> E<\/span> peek<\/span>(<\/span>)<\/span> {<\/span>
\n int<\/span> len =<\/span> size<\/span>(<\/span>)<\/span>;<\/span>
\n if<\/span> (<\/span>len ==<\/span> 0<\/span>)<\/span> throw<\/span> new<\/span> EmptyStackException<\/span>(<\/span>)<\/span>;<\/span>
\n return<\/span> elementAt<\/span>(<\/span>len –<\/span> 1<\/span>)<\/span>;<\/span>
\n }<\/span>
\n}<\/span><\/p>\n

\u539f\u7406\u8bb2\u89e3：synchronized \u662f\u53ef\u91cd\u5165\u9501\u2014\u2014pop \u91cc\u8c03\u7528 peek，\u9501\u5df2\u7ecf\u88ab\u672c\u7ebf\u7a0b\u6301\u6709，\u53ef\u4ee5\u76f4\u63a5\u8fdb\u6765，\u4e0d\u4f1a\u81ea\u5df1\u9501\u6b7b\u81ea\u5df1\u3002\u4e0d\u8fc7 Stack \u73b0\u5728\u57fa\u672c\u53ea\u51fa\u73b0\u5728\u9762\u8bd5\u9898\u548c\u6559\u79d1\u4e66\u91cc\u4e86\u3002<\/p>\n

4. Collections.synchronizedXxx \u2014\u2014 \u6362\u76ae\u7684\u540c\u6b65\u5305\u88c5<\/h4>\n

\u6982\u5ff5：Collections \u63d0\u4f9b\u4e00\u7ec4\u9759\u6001\u5de5\u5382，\u628a\u4efb\u4f55\u666e\u901a\u96c6\u5408\u5305\u88c5\u6210\u7ebf\u7a0b\u5b89\u5168\u7684\u3002\u539f\u7406\u548c Vector \u7c7b\u4f3c：\u6bcf\u4e2a\u65b9\u6cd5\u5916\u5305\u4e00\u5c42 synchronized\u3002<\/p>\n

List<\/span><<\/span>String<\/span>><\/span><\/span> list =<\/span> Collections<\/span>.<\/span>synchronizedList<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>)<\/span>;<\/span><\/p>\n

\/\/ \u5b9e\u9645\u8fd4\u56de\u7684\u662f\u5185\u90e8\u7c7b SynchronizedList<\/span>
\nstatic<\/span> class<\/span> SynchronizedList<\/span><<\/span>E<\/span>><\/span><\/span> extends<\/span> SynchronizedCollection<\/span><<\/span>E<\/span>><\/span><\/span> implements<\/span> List<\/span><<\/span>E<\/span>><\/span><\/span> {<\/span>
\n final<\/span> List<\/span><<\/span>E<\/span>><\/span><\/span> list;<\/span><\/p>\n

public<\/span> void<\/span> add<\/span>(<\/span>int<\/span> index,<\/span> E<\/span> element)<\/span> {<\/span>
\n synchronized<\/span> (<\/span>mutex)<\/span> {<\/span> \/\/ \u5bf9 mutex \u52a0\u9501，\u800c\u4e0d\u662f\u5bf9 list \u672c\u8eab<\/span>
\n list.<\/span>add<\/span>(<\/span>index,<\/span> element)<\/span>;<\/span>
\n }<\/span>
\n }<\/span><\/p>\n

public<\/span> E<\/span> get<\/span>(<\/span>int<\/span> index)<\/span> {<\/span>
\n synchronized<\/span> (<\/span>mutex)<\/span> {<\/span>
\n return<\/span> list.<\/span>get<\/span>(<\/span>index)<\/span>;<\/span>
\n }<\/span>
\n }<\/span>
\n}<\/span><\/p>\n

\u539f\u7406\u8bb2\u89e3：mutex \u9ed8\u8ba4\u5c31\u662f\u5305\u88c5\u7c7b\u81ea\u8eab\u3002\u4f46\u8fd9\u5c42\u5305\u88c5\u6709\u4e2a\u8457\u540d\u9677\u9631\u2014\u2014\u590d\u5408\u64cd\u4f5c\u8981\u81ea\u5df1\u52a0\u9501：<\/p>\n

synchronized<\/span> (<\/span>list)<\/span> {<\/span> \/\/ \u5fc5\u987b\u624b\u52a8\u540c\u6b65，\u5426\u5219\u4e0b\u9762\u7684\u590d\u5408\u64cd\u4f5c\u662f\u4e24\u6b21\u8c03\u7528<\/span>
\n if<\/span> (<\/span>!<\/span>list.<\/span>contains<\/span>(<\/span>x)<\/span>)<\/span> {<\/span> \/\/ \u7b2c\u4e00\u6b21\u8c03\u7528<\/span>
\n list.<\/span>add<\/span>(<\/span>x)<\/span>;<\/span> \/\/ \u7b2c\u4e8c\u6b21\u8c03\u7528<\/span>
\n }<\/span>
\n}<\/span><\/p>\n

contains \u548c add \u5404\u81ea\u52a0\u9501\u3001\u5404\u81ea\u8fd4\u56de，\u4e4b\u95f4\u53ef\u80fd\u63d2\u8fdb\u522b\u7684\u7ebf\u7a0b\u3002\u8fd9\u70b9\u5373\u4f7f\u4e0d\u7528 synchronizedXxx，\u5728\u9762\u8bd5\u4e2d\u4e5f\u7ecf\u5e38\u88ab\u8ffd\u95ee\u3002<\/p>\n

\n

\u4e8c\u3001ReentrantLock \u6d3e：\u7cbe\u7ec6\u5316\u9501\u63a7<\/h3>\n

5. CopyOnWriteArrayList \u2014\u2014 \u5199\u65f6\u590d\u5236，\u8bfb\u6c38\u8fdc\u4e0d\u9501<\/h4>\n

\u6982\u5ff5：\u5199\u64cd\u4f5c\u52a0\u9501（ReentrantLock），\u590d\u5236\u51fa\u65b0\u6570\u7ec4\u518d\u4fee\u6539；\u8bfb\u64cd\u4f5c\u5b8c\u5168\u65e0\u9501，\u8bfb\u7684\u662f\u4fee\u6539\u524d\u7684\u65e7\u5feb\u7167\u3002\u9002\u5408\u8bfb\u6781\u591a\u3001\u5199\u6781\u5c11\u7684\u573a\u666f\u3002<\/p>\n

public<\/span> class<\/span> CopyOnWriteArrayList<\/span><<\/span>E<\/span>><\/span><\/span> implements<\/span> List<\/span><<\/span>E<\/span>><\/span><\/span> {<\/span>
\n private<\/span> final<\/span> transient<\/span> ReentrantLock<\/span> lock =<\/span> new<\/span> ReentrantLock<\/span>(<\/span>)<\/span>;<\/span>
\n private<\/span> volatile<\/span> Object<\/span>[<\/span>]<\/span> array;<\/span> \/\/ \u7528 volatile \u4fdd\u8bc1\u66ff\u6362\u540e\u8bfb\u7ebf\u7a0b\u7acb\u5373\u53ef\u89c1<\/span><\/p>\n

public<\/span> boolean<\/span> add<\/span>(<\/span>E<\/span> e)<\/span> {<\/span>
\n final<\/span> ReentrantLock<\/span> lock =<\/span> this<\/span>.<\/span>lock;<\/span>
\n lock.<\/span>lock<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u53ea\u6709\u5199\u624d\u52a0\u9501<\/span>
\n try<\/span> {<\/span>
\n Object<\/span>[<\/span>]<\/span> elements =<\/span> array;<\/span>
\n Object<\/span>[<\/span>]<\/span> newElements =<\/span> Arrays<\/span>.<\/span>copyOf<\/span>(<\/span>elements,<\/span> elements.<\/span>length +<\/span> 1<\/span>)<\/span>;<\/span> \/\/ \u590d\u5236\u65b0\u6570\u7ec4<\/span>
\n newElements[<\/span>elements.<\/span>length]<\/span> =<\/span> e;<\/span>
\n array =<\/span> newElements;<\/span> \/\/ \u4e00\u6b21\u6027\u66ff\u6362\u5f15\u7528<\/span>
\n return<\/span> true<\/span>;<\/span>
\n }<\/span> finally<\/span> {<\/span>
\n lock.<\/span>unlock<\/span>(<\/span>)<\/span>;<\/span>
\n }<\/span>
\n }<\/span><\/p>\n

public<\/span> E<\/span> get<\/span>(<\/span>int<\/span> index)<\/span> {<\/span>
\n return<\/span> elementAt<\/span>(<\/span>array,<\/span> index)<\/span>;<\/span> \/\/ \u65e0\u9501\u8bfb，\u8fd4\u56de\u6b64\u523b\u7684\u5feb\u7167\u5185\u5bb9<\/span>
\n }<\/span>
\n}<\/span><\/p>\n

\u539f\u7406\u8bb2\u89e3：\u5199\u4e00\u6b21\u5c31\u590d\u5236\u6574\u4e2a\u6570\u7ec4，\u6570\u636e\u91cf\u5927\u4e86\u4ee3\u4ef7\u5f88\u9ad8；\u4f46\u8bfb\u7ebf\u7a0b\u62ff\u5230\u7684\u6570\u7ec4\u5f15\u7528\u662f\u6c38\u8fdc\u4e0d\u53d8\u7684，\u6240\u4ee5 get \u65e0\u9700\u4efb\u4f55\u540c\u6b65\u3002volatile \u4fdd\u8bc1\u6570\u7ec4\u5f15\u7528\u66ff\u6362\u540e，\u8bfb\u7ebf\u7a0b\u4e0b\u4e00\u6b21 get \u80fd\u770b\u5230\u65b0\u5f15\u7528\u3002\u8fd9\u6b63\u662f"\u8bfb\u591a\u5199\u5c11"\u8bbe\u8ba1\u54f2\u5b66\u7684\u6781\u81f4\u4f53\u73b0\u3002<\/p>\n

6. ArrayBlockingQueue \u2014\u2014 \u6709\u754c\u961f\u5217：\u4e00\u628a\u9501，\u4e24\u4e2a\u54e8\u5175<\/h4>\n

\u6982\u5ff5：\u4e00\u4e2a\u6709\u56fa\u5b9a\u5bb9\u91cf\u7684\u961f\u5217，\u4e00\u628a ReentrantLock \u7ba1\u8bfb\u5199，\u914d\u4e24\u4e2a Condition：notEmpty（\u7a7a\u65f6\u8ba9\u6d88\u8d39\u8005\u7b49\u5f85）\u3001notFull（\u6ee1\u65f6\u8ba9\u751f\u4ea7\u8005\u7b49\u5f85）\u3002<\/p>\n

public<\/span> class<\/span> ArrayBlockingQueue<\/span><<\/span>E<\/span>><\/span><\/span> extends<\/span> AbstractQueue<\/span><<\/span>E<\/span>><\/span><\/span> implements<\/span> BlockingQueue<\/span><<\/span>E<\/span>><\/span><\/span> {<\/span>
\n private<\/span> final<\/span> ReentrantLock<\/span> lock;<\/span>
\n private<\/span> final<\/span> Condition<\/span> notEmpty;<\/span>
\n private<\/span> final<\/span> Condition<\/span> notFull;<\/span><\/p>\n

public<\/span> boolean<\/span> offer<\/span>(<\/span>E<\/span> e)<\/span> {<\/span>
\n final<\/span> ReentrantLock<\/span> lock =<\/span> this<\/span>.<\/span>lock;<\/span>
\n lock.<\/span>lock<\/span>(<\/span>)<\/span>;<\/span>
\n try<\/span> {<\/span>
\n if<\/span> (<\/span>count ==<\/span> items.<\/span>length)<\/span> return<\/span> false<\/span>;<\/span> \/\/ \u961f\u5217\u6ee1，\u76f4\u63a5\u5931\u8d25<\/span>
\n enqueue<\/span>(<\/span>e)<\/span>;<\/span>
\n return<\/span> true<\/span>;<\/span>
\n }<\/span> finally<\/span> {<\/span>
\n lock.<\/span>unlock<\/span>(<\/span>)<\/span>;<\/span>
\n }<\/span>
\n }<\/span><\/p>\n

private<\/span> void<\/span> enqueue<\/span>(<\/span>E<\/span> x)<\/span> {<\/span>
\n items[<\/span>putIndex]<\/span> =<\/span> x;<\/span>
\n putIndex++<\/span>;<\/span>
\n count++<\/span>;<\/span>
\n notEmpty.<\/span>signal<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u5524\u9192\u4e00\u4e2a\u7b49\u5f85\u53d6\u6570\u636e\u7684\u6d88\u8d39\u8005<\/span>
\n }<\/span><\/p>\n

public<\/span> E<\/span> take<\/span>(<\/span>)<\/span> throws<\/span> InterruptedException<\/span> {<\/span>
\n final<\/span> ReentrantLock<\/span> lock =<\/span> this<\/span>.<\/span>lock;<\/span>
\n lock.<\/span>lockInterruptibly<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u53ef\u54cd\u5e94\u4e2d\u65ad\u5730\u52a0\u9501<\/span>
\n try<\/span> {<\/span>
\n while<\/span> (<\/span>count ==<\/span> 0<\/span>)<\/span> notEmpty.<\/span>await<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u961f\u5217\u7a7a\u5219\u7b49\u5f85<\/span>
\n return<\/span> dequeue<\/span>(<\/span>)<\/span>;<\/span>
\n }<\/span> finally<\/span> {<\/span>
\n lock.<\/span>unlock<\/span>(<\/span>)<\/span>;<\/span>
\n }<\/span>
\n }<\/span><\/p>\n

private<\/span> E<\/span> dequeue<\/span>(<\/span>)<\/span> {<\/span>
\n E<\/span> x =<\/span> items[<\/span>takeIndex]<\/span>;<\/span>
\n items[<\/span>takeIndex]<\/span> =<\/span> null<\/span>;<\/span>
\n takeIndex++<\/span>;<\/span>
\n count—<\/span>;<\/span>
\n notFull.<\/span>signal<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u817e\u51fa\u4e00\u4e2a\u4f4d\u7f6e，\u5524\u9192\u4e00\u4e2a\u751f\u4ea7\u8005<\/span>
\n return<\/span> x;<\/span>
\n }<\/span>
\n}<\/span><\/p>\n

\u539f\u7406\u8bb2\u89e3：\u6838\u5fc3\u662f Condition \u7684\u7b49\u5f85\/\u5524\u9192\u673a\u5236\u3002await() \u4f1a\u91ca\u653e\u9501\u8fdb\u5165\u7b49\u5f85，signal() \u5524\u9192\u4e00\u4e2a\u7b49\u5f85\u7ebf\u7a0b\u540e\u518d\u7ade\u4e89\u9501\u3002\u8fd9\u5c31\u662f\u4e3a\u4ec0\u4e48\u961f\u5217\u53ef\u4ee5\u540c\u65f6\u5b9e\u73b0"\u6ee1\u65f6\u963b\u585e\u3001\u7a7a\u65f6\u963b\u585e"，\u800c\u4e0d\u7528\u8c03\u7528\u8005\u81ea\u5df1\u5199 wait\/notify\u3002<\/p>\n

7. LinkedBlockingQueue \u2014\u2014 \u65e0\u754c\u961f\u5217：\u8bfb\u5199\u5206\u9501<\/h4>\n

\u6982\u5ff5：\u548c ArrayBlockingQueue \u7c7b\u4f3c，\u4f46\u5185\u90e8\u662f\u94fe\u8868\u3002\u5b83\u628a\u8bfb\u9501\u548c\u5199\u9501\u5206\u5f00\u4e86：putLock \u53ea\u7ba1\u5165\u961f，takeLock \u53ea\u7ba1\u51fa\u961f，\u4e24\u4e2a\u6761\u4ef6\u53d8\u91cf notFull \u548c notEmpty \u5404\u5f52\u5404\u7ba1\u3002<\/p>\n

public<\/span> class<\/span> LinkedBlockingQueue<\/span><<\/span>E<\/span>><\/span><\/span> extends<\/span> AbstractQueue<\/span><<\/span>E<\/span>><\/span><\/span> implements<\/span> BlockingQueue<\/span><<\/span>E<\/span>><\/span><\/span> {<\/span>
\n private<\/span> final<\/span> ReentrantLock<\/span> takeLock =<\/span> new<\/span> ReentrantLock<\/span>(<\/span>)<\/span>;<\/span>
\n private<\/span> final<\/span> Condition<\/span> notEmpty =<\/span> takeLock.<\/span>newCondition<\/span>(<\/span>)<\/span>;<\/span>
\n private<\/span> final<\/span> ReentrantLock<\/span> putLock =<\/span> new<\/span> ReentrantLock<\/span>(<\/span>)<\/span>;<\/span>
\n private<\/span> final<\/span> Condition<\/span> notFull =<\/span> putLock.<\/span>newCondition<\/span>(<\/span>)<\/span>;<\/span>
\n private<\/span> final<\/span> AtomicInteger<\/span> count =<\/span> new<\/span> AtomicInteger<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u8ba1\u6570\u7528\u539f\u5b50\u7c7b，\u8de8\u4e24\u628a\u9501<\/span><\/p>\n

public<\/span> void<\/span> put<\/span>(<\/span>E<\/span> e)<\/span> throws<\/span> InterruptedException<\/span> {<\/span>
\n int<\/span> c =<\/span> –<\/span>1<\/span>;<\/span>
\n Node<\/span><<\/span>E<\/span>><\/span><\/span> node =<\/span> new<\/span> Node<\/span><<\/span>><\/span><\/span>(<\/span>e)<\/span>;<\/span>
\n final<\/span> ReentrantLock<\/span> putLock =<\/span> this<\/span>.<\/span>putLock;<\/span>
\n final<\/span> AtomicInteger<\/span> count =<\/span> this<\/span>.<\/span>count;<\/span>
\n putLock.<\/span>lockInterruptibly<\/span>(<\/span>)<\/span>;<\/span>
\n try<\/span> {<\/span>
\n while<\/span> (<\/span>count.<\/span>get<\/span>(<\/span>)<\/span> ==<\/span> capacity)<\/span> notFull.<\/span>await<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u6ee1\u5219\u7b49\u5f85<\/span>
\n enqueue<\/span>(<\/span>node)<\/span>;<\/span>
\n c =<\/span> count.<\/span>getAndIncrement<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u5148\u81ea\u589e\u524d\u8ba1\u6570\u52a01<\/span>
\n if<\/span> (<\/span>c +<\/span> 1<\/span> <<\/span> capacity)<\/span> notFull.<\/span>signal<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u8fd8\u6709\u7a7a\u4f4d，\u5524\u9192\u4e0b\u4e00\u4e2a\u751f\u4ea7\u8005<\/span>
\n }<\/span> finally<\/span> {<\/span>
\n putLock.<\/span>unlock<\/span>(<\/span>)<\/span>;<\/span>
\n }<\/span>
\n if<\/span> (<\/span>c ==<\/span> 0<\/span>)<\/span> signalNotEmpty<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u961f\u5217\u4ece\u7a7a\u53d8\u975e\u7a7a，\u5524\u9192\u7b49\u5f85\u7684\u6d88\u8d39\u8005<\/span>
\n }<\/span><\/p>\n

public<\/span> E<\/span> take<\/span>(<\/span>)<\/span> throws<\/span> InterruptedException<\/span> {<\/span>
\n E<\/span> x;<\/span>
\n int<\/span> c =<\/span> –<\/span>1<\/span>;<\/span>
\n final<\/span> AtomicInteger<\/span> count =<\/span> this<\/span>.<\/span>count;<\/span>
\n final<\/span> ReentrantLock<\/span> takeLock =<\/span> this<\/span>.<\/span>takeLock;<\/span>
\n takeLock.<\/span>lockInterruptibly<\/span>(<\/span>)<\/span>;<\/span>
\n try<\/span> {<\/span>
\n while<\/span> (<\/span>count.<\/span>get<\/span>(<\/span>)<\/span> ==<\/span> 0<\/span>)<\/span> notEmpty.<\/span>await<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u7a7a\u5219\u7b49\u5f85<\/span>
\n x =<\/span> dequeue<\/span>(<\/span>)<\/span>;<\/span>
\n c =<\/span> count.<\/span>getAndDecrement<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u5148\u81ea\u589e\u540e\u8ba1\u6570\u51cf1<\/span>
\n if<\/span> (<\/span>c ><\/span> 1<\/span>)<\/span> notEmpty.<\/span>signal<\/span>(<\/span>)<\/span>;<\/span>
\n }<\/span> finally<\/span> {<\/span>
\n takeLock.<\/span>unlock<\/span>(<\/span>)<\/span>;<\/span>
\n }<\/span>
\n if<\/span> (<\/span>c ==<\/span> capacity)<\/span> signalNotFull<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u961f\u5217\u4ece\u6ee1\u53d8\u4e0d\u6ee1，\u5524\u9192\u7b49\u5f85\u7684\u751f\u4ea7\u8005<\/span>
\n return<\/span> x;<\/span>
\n }<\/span>
\n}<\/span><\/p>\n

\u539f\u7406\u8bb2\u89e3：\u8bfb\u8bfb\u3001\u5199\u5199\u3001\u8bfb\u5199\u7684\u9501\u7ade\u4e89\u90fd\u5927\u5e45\u51cf\u5c0f\u2014\u2014\u5165\u961f\u53ea\u548c\u5165\u961f\u8005\u62a2\u9501，\u51fa\u961f\u53ea\u548c\u51fa\u961f\u8005\u62a2\u9501\u3002\u4ee3\u4ef7\u662f count \u5f97\u7528 AtomicInteger \u6765\u8de8\u4e24\u628a\u9501\u8ba1\u6570，\u56e0\u4e3a\u4e24\u628a\u9501\u6ca1\u6cd5\u5b89\u5168\u5730\u5171\u4eab\u4e00\u4e2a\u666e\u901a int\u3002<\/p>\n

8. PriorityBlockingQueue \u2014\u2014 \u4f18\u5148\u7ea7\u961f\u5217：\u4e00\u628a\u9501\u52a0\u65e0\u9501\u6269\u5bb9<\/h4>\n

\u6982\u5ff5：\u4e00\u4e2a\u57fa\u4e8e\u6570\u7ec4\u5806\u7ed3\u6784\u7684\u4f18\u5148\u7ea7\u963b\u585e\u961f\u5217，\u53ea\u6709\u4e00\u628a ReentrantLock，\u5185\u90e8\u8fd8\u505a\u4e86\u4e00\u4e2a"\u6269\u5bb9\u65f6\u5148\u91ca\u653e\u9501\u3001\u6269\u5b8c\u518d\u9501"\u7684\u4f18\u5316\u3002<\/p>\n

public<\/span> class<\/span> PriorityBlockingQueue<\/span><<\/span>E<\/span>><\/span><\/span> extends<\/span> AbstractQueue<\/span><<\/span>E<\/span>><\/span><\/span> implements<\/span> BlockingQueue<\/span><<\/span>E<\/span>><\/span><\/span> {<\/span>
\n private<\/span> final<\/span> ReentrantLock<\/span> lock;<\/span>
\n private<\/span> final<\/span> Condition<\/span> notEmpty;<\/span><\/p>\n

public<\/span> boolean<\/span> offer<\/span>(<\/span>E<\/span> e)<\/span> {<\/span>
\n if<\/span> (<\/span>e ==<\/span> null<\/span>)<\/span> throw<\/span> new<\/span> NullPointerException<\/span>(<\/span>)<\/span>;<\/span>
\n final<\/span> ReentrantLock<\/span> lock =<\/span> this<\/span>.<\/span>lock;<\/span>
\n lock.<\/span>lock<\/span>(<\/span>)<\/span>;<\/span>
\n int<\/span> n,<\/span> cap;<\/span>
\n Object<\/span>[<\/span>]<\/span> array;<\/span>
\n while<\/span> (<\/span>(<\/span>n =<\/span> size)<\/span> >=<\/span> (<\/span>cap =<\/span> (<\/span>array =<\/span> queue)<\/span>.<\/span>length)<\/span>)<\/span> {<\/span>
\n \/\/ \u961f\u5217\u5df2\u6ee1：\u6269\u5bb9\u9700\u8981\u8f83\u957f\u65f6\u95f4，\u5148\u91ca\u653e\u9501\u518d\u6269<\/span>
\n tryGrow<\/span>(<\/span>array,<\/span> cap)<\/span>;<\/span>
\n }<\/span>
\n try<\/span> {<\/span>
\n siftUp<\/span>(<\/span>n,<\/span> e,<\/span> array)<\/span>;<\/span> \/\/ \u5806\u4e0a\u6d6e\u64cd\u4f5c<\/span>
\n size =<\/span> n +<\/span> 1<\/span>;<\/span>
\n notEmpty.<\/span>signal<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u5524\u9192\u7b49\u5f85\u7684\u6d88\u8d39\u8005<\/span>
\n }<\/span> finally<\/span> {<\/span>
\n lock.<\/span>unlock<\/span>(<\/span>)<\/span>;<\/span>
\n }<\/span>
\n return<\/span> true<\/span>;<\/span>
\n }<\/span><\/p>\n

private<\/span> void<\/span> tryGrow<\/span>(<\/span>Object<\/span>[<\/span>]<\/span> array,<\/span> int<\/span> oldCap)<\/span> {<\/span>
\n lock.<\/span>unlock<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u91ca\u653e\u9501\u518d\u6269\u5bb9，\u8ba9\u5176\u4ed6\u7ebf\u7a0b\u7ee7\u7eed\u5e72\u6d3b<\/span>
\n try<\/span> {<\/span>
\n int<\/span> newCap =<\/span> oldCap +<\/span> (<\/span>(<\/span>oldCap <<\/span> 64<\/span>)<\/span> ?<\/span> (<\/span>oldCap +<\/span> 2<\/span>)<\/span> :<\/span> (<\/span>oldCap >><\/span> 1<\/span>)<\/span>)<\/span>;<\/span>
\n queue =<\/span> Arrays<\/span>.<\/span>copyOf<\/span>(<\/span>array,<\/span> newCap)<\/span>;<\/span>
\n }<\/span> finally<\/span> {<\/span>
\n lock.<\/span>lock<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u6269\u5b8c\u91cd\u65b0\u52a0\u9501<\/span>
\n }<\/span>
\n }<\/span>
\n}<\/span><\/p>\n

\u539f\u7406\u8bb2\u89e3：\u6269\u5bb9\u662f\u4e2a\u7eaf\u5206\u914d\u5185\u5b58\u7684\u64cd\u4f5c，\u4e0d\u5f71\u54cd\u6570\u636e\u672c\u8eab，\u6240\u4ee5\u6682\u65f6\u653e\u6389\u9501\u8ba9\u522b\u7684\u7ebf\u7a0b\u7ee7\u7eed\u5b58\u53d6，\u6269\u5b8c\u518d\u56de\u6765\u3002\u8fd9\u662f"\u628a\u957f\u8017\u65f6\u64cd\u4f5c\u6392\u9664\u5728\u4e34\u754c\u533a\u4e4b\u5916"\u7684\u7ecf\u5178\u793a\u8303\u3002\u6ce8\u610f PriorityBlockingQueue \u662f\u65e0\u754c\u7684，\u6240\u4ee5\u53ea\u6709 notEmpty \u4e00\u4e2a Condition\u3002<\/p>\n

\n

\u4e09\u3001synchronized + CAS \u6d3e：\u5e76\u53d1 HashMap \u7684\u6df7\u642d<\/h3>\n

9. ConcurrentHashMap \u2014\u2014 \u9501\u6876\u5934，\u8bfb\u65e0\u9501<\/h4>\n

\u6982\u5ff5：JDK 1.8 \u7684 ConcurrentHashMap \u653e\u5f03\u4e86 1.7 \u7684 Segment \u5206\u6bb5\u9501，\u6539\u4e3a：\u6876\u4e3a\u7a7a\u65f6\u7528 CAS \u62a2\u69fd\u4f4d，\u6876\u975e\u7a7a\u65f6 synchronized \u9501\u4f4f\u6876\u7684\u5934\u8282\u70b9，\u8bfb\u64cd\u4f5c\u5168\u7a0b\u65e0\u9501\u3002<\/p>\n

final<\/span> V<\/span> putVal<\/span>(<\/span>K<\/span> key,<\/span> V<\/span> value,<\/span> boolean<\/span> onlyIfAbsent)<\/span> {<\/span>
\n int<\/span> hash =<\/span> spread<\/span>(<\/span>key.<\/span>hashCode<\/span>(<\/span>)<\/span>)<\/span>;<\/span>
\n for<\/span> (<\/span>Node<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span>[<\/span>]<\/span> tab =<\/span> table;<\/span>;<\/span>)<\/span> {<\/span>
\n Node<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span> f;<\/span> int<\/span> n,<\/span> i,<\/span> fh;<\/span>
\n if<\/span> (<\/span>tab ==<\/span> null<\/span> ||<\/span> (<\/span>n =<\/span> tab.<\/span>length)<\/span> ==<\/span> 0<\/span>)<\/span> {<\/span>
\n tab =<\/span> initTable<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u5ef6\u8fdf\u521d\u59cb\u5316：\u7b2c\u4e00\u6b21 put \u65f6\u624d\u5206\u914d\u6570\u7ec4<\/span>
\n }<\/span> else<\/span> if<\/span> (<\/span>(<\/span>f =<\/span> tabAt<\/span>(<\/span>tab,<\/span> i =<\/span> (<\/span>n –<\/span> 1<\/span>)<\/span> &<\/span> hash)<\/span>)<\/span> ==<\/span> null<\/span>)<\/span> {<\/span>
\n \/\/ \u69fd\u4f4d\u662f\u7a7a\u7684：CAS \u76f4\u63a5\u653e，\u6210\u529f\u5c31\u5b8c\u4e8b，\u4e0d\u52a0\u9501<\/span>
\n if<\/span> (<\/span>casTabAt<\/span>(<\/span>tab,<\/span> i,<\/span> null<\/span>,<\/span> new<\/span> Node<\/span><<\/span>><\/span><\/span>(<\/span>hash,<\/span> key,<\/span> value,<\/span> null<\/span>)<\/span>)<\/span>)<\/span>
\n break<\/span>;<\/span>
\n }<\/span> else<\/span> if<\/span> (<\/span>(<\/span>fh =<\/span> f.<\/span>hash)<\/span> ==<\/span> MOVED<\/span>)<\/span> {<\/span>
\n tab =<\/span> helpTransfer<\/span>(<\/span>tab,<\/span> f)<\/span>;<\/span> \/\/ \u9047\u5230\u6b63\u5728\u6269\u5bb9\u7684\u6876，\u5148\u5e2e\u5b83\u8fc1\u5b8c<\/span>
\n }<\/span> else<\/span> {<\/span>
\n V<\/span> oldVal =<\/span> null<\/span>;<\/span>
\n synchronized<\/span> (<\/span>f)<\/span> {<\/span> \/\/ \u69fd\u4f4d\u975e\u7a7a：\u53ea\u9501\u8fd9\u4e2a\u6876\u7684\u5934\u8282\u70b9<\/span>
\n if<\/span> (<\/span>tabAt<\/span>(<\/span>tab,<\/span> i)<\/span> ==<\/span> f)<\/span> {<\/span> \/\/ \u518d\u786e\u8ba4\u4e00\u6b21\u5934\u8282\u70b9\u6ca1\u53d8（\u9632\u6b62\u62ff\u5230\u8fc7\u65f6\u6570\u636e）<\/span>
\n if<\/span> (<\/span>fh >=<\/span> 0<\/span>)<\/span> {<\/span> \/\/ \u666e\u901a\u94fe\u8868\u8282\u70b9<\/span>
\n for<\/span> (<\/span>Node<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span> e =<\/span> f;<\/span>;<\/span>)<\/span> {<\/span>
\n if<\/span> (<\/span>e.<\/span>hash ==<\/span> hash &&<\/span> e.<\/span>key.<\/span>equals<\/span>(<\/span>key)<\/span>)<\/span> {<\/span>
\n oldVal =<\/span> e.<\/span>val;<\/span>
\n e.<\/span>val =<\/span> value;<\/span>
\n break<\/span>;<\/span>
\n }<\/span>
\n if<\/span> (<\/span>e.<\/span>next ==<\/span> null<\/span>)<\/span> {<\/span> e.<\/span>next =<\/span> new<\/span> Node<\/span><<\/span>><\/span><\/span>(<\/span>.<\/span>.<\/span>.<\/span>)<\/span>;<\/span> break<\/span>;<\/span> }<\/span>
\n e =<\/span> e.<\/span>next;<\/span>
\n }<\/span>
\n }<\/span> else<\/span> if<\/span> (<\/span>f instanceof<\/span> TreeBin<\/span>)<\/span> {<\/span>
\n oldVal =<\/span> (<\/span>(<\/span>TreeBin<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span>)<\/span>f)<\/span>.<\/span>putTreeVal<\/span>(<\/span>.<\/span>.<\/span>.<\/span>)<\/span>;<\/span> \/\/ \u7ea2\u9ed1\u6811\u5206\u652f<\/span>
\n }<\/span>
\n }<\/span>
\n }<\/span>
\n if<\/span> (<\/span>oldVal !=<\/span> null<\/span>)<\/span> return<\/span> oldVal;<\/span>
\n addCount<\/span>(<\/span>1L<\/span>,<\/span> binCount)<\/span>;<\/span> \/\/ \u8ba1\u6570，\u53ef\u80fd\u89e6\u53d1\u6269\u5bb9<\/span>
\n break<\/span>;<\/span>
\n }<\/span>
\n }<\/span>
\n return<\/span> null<\/span>;<\/span>
\n}<\/span><\/p>\n

static<\/span> final<\/span> <<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span> Node<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span> tabAt<\/span>(<\/span>Node<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span>[<\/span>]<\/span> tab,<\/span> int<\/span> i)<\/span> {<\/span>
\n \/\/ \u7528 Unsafe.getObjectVolatile \u4fdd\u8bc1\u8bfb\u53d6\u5230\u6700\u65b0\u503c<\/span>
\n return<\/span> (<\/span>Node<\/span><<\/span>K<\/span>,<\/span>V<\/span>><\/span><\/span>)<\/span> U<\/span>.<\/span>getObjectVolatile<\/span>(<\/span>tab,<\/span> (<\/span>(<\/span>long<\/span>)<\/span>i <<<\/span> ASHIFT<\/span>)<\/span> +<\/span> ABASE<\/span>)<\/span>;<\/span>
\n}<\/span><\/p>\n

\u539f\u7406\u8bb2\u89e3：<\/p>\n