首页 > > 程序设计 > Java技术 >

深入理解HashMap+ConcurrentHashMap的扩容策略

2018-09-18 06:32:03来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

前言 

理解HashMap和ConcurrentHashMap的重点在于： 

（1）理解HashMap的数据结构的设计和实现思路 

（2）在（1）的基础上，理解ConcurrentHashMap的并发安全的设计和实现思路 

前面的文章已经介绍过Map结构的底层实现，这里我们重点放在其扩容方法， 
这里分别对JDK7和JDK8版本的HashMap+ConcurrentHashMap来分析： 

JDK7的HashMap扩容 



这个版本的HashMap数据结构还是数组+链表的方式，扩容方法如下： 

Java代码  收藏代码
  1. ```  
  2. void transfer(Entry[] newTable) {    
  3.     Entry[] src = table;                   //src引用了旧的Entry数组    
  4.     int newCapacity = newTable.length;    
  5.     for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组    
  6.         Entry<K, V> e = src[j];             //取得旧Entry数组的每个元素    
  7.         if (e != null) {    
  8.             src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）    
  9.             do {    
  10.                 Entry<K, V> next = e.next;    
  11.                 int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置    
  12.                 e.next = newTable[i]; //标记[1]    
  13.                 newTable[i] = e;      //将元素放在数组上    
  14.                 e = next;             //访问下一个Entry链上的元素    
  15.             } while (e != null);    
  16.         }    
  17.     }    
  18. }  
  19. ```  



上面的这段代码不并不难理解，对于扩容操作，底层实现都需要新生成一个数组，然后拷贝旧数组里面的每一个Node链表到新数组里面，这个方法在单线程下执行是没有任何问题的，但是在多线程下面却有很大问题，主要的问题在于基于头插法的数据迁移，会有几率造成链表倒置，从而引发链表闭链，导致程序死循环，并吃满CPU。据说已经有人给原来的SUN公司提过bug，但sun公司认为，这是开发者使用不当造成的，因为这个类本就不是线程安全的，你还偏在多线程下使用，这下好了吧，出了问题这能怪我咯？仔细想想，还有点道理。 


JDK7的ConcurrentHashMap扩容

HashMap是线程不安全的，我们来看下线程安全的ConcurrentHashMap，在JDK7的时候，这种安全策略采用的是分段锁的机制，ConcurrentHashMap维护了一个Segment数组，Segment这个类继承了重入锁ReentrantLock，并且该类里面维护了一个 HashEntry<K,V>[] table数组，在写操作put，remove，扩容的时候，会对Segment加锁，所以仅仅影响这个Segment，不同的Segment还是可以并发的，所以解决了线程的安全问题，同时又采用了分段锁也提升了并发的效率。 ![image](http://pic.yupoo.com/goldendoc/Ba4GCFe1/nuEZ0.png) 下面看下其扩容的源码： 

Java代码  收藏代码
  1. ```  
  2. // 方法参数上的 node 是这次扩容后，需要添加到新的数组中的数据。  
  3. private void rehash(HashEntry<K,V> node) {  
  4.     HashEntry<K,V>[] oldTable = table;  
  5.     int oldCapacity = oldTable.length;  
  6.     // 2 倍  
  7.     int newCapacity = oldCapacity << 1;  
  8.     threshold = (int)(newCapacity * loadFactor);  
  9.     // 创建新数组  
  10.     HashEntry<K,V>[] newTable =  
  11.         (HashEntry<K,V>[]) new HashEntry[newCapacity];  
  12.     // 新的掩码，如从 16 扩容到 32，那么 sizeMask 为 31，对应二进制 ‘000...00011111’  
  13.     int sizeMask = newCapacity - 1;  
  14.   
  15.     // 遍历原数组，老套路，将原数组位置 i 处的链表拆分到 新数组位置 i 和 i+oldCap 两个位置  
  16.     for (int i = 0; i < oldCapacity ; i++) {  
  17.         // e 是链表的第一个元素  
  18.         HashEntry<K,V> e = oldTable[i];  
  19.         if (e != null) {  
  20.             HashEntry<K,V> next = e.next;  
  21.             // 计算应该放置在新数组中的位置，  
  22.             // 假设原数组长度为 16，e 在 oldTable[3] 处，那么 idx 只可能是 3 或者是 3 + 16 = 19  
  23.             int idx = e.hash & sizeMask;  
  24.             if (next == null)   // 该位置处只有一个元素，那比较好办  
  25.                 newTable[idx] = e;  
  26.             else { // Reuse consecutive sequence at same slot  
  27.                 // e 是链表表头  
  28.                 HashEntry<K,V> lastRun = e;  
  29.                 // idx 是当前链表的头结点 e 的新位置  
  30.                 int lastIdx = idx;  
  31.   
  32.                 // 下面这个 for 循环会找到一个 lastRun 节点，这个节点之后的所有元素是将要放到一起的  
  33.                 for (HashEntry<K,V> last = next;  
  34.                      last != null;  
  35.                      last = last.next) {  
  36.                     int k = last.hash & sizeMask;  
  37.                     if (k != lastIdx) {  
  38.                         lastIdx = k;  
  39.                         lastRun = last;  
  40.                     }  
  41.                 }  
  42.                 // 将 lastRun 及其之后的所有节点组成的这个链表放到 lastIdx 这个位置  
  43.                 newTable[lastIdx] = lastRun;  
  44.                 // 下面的操作是处理 lastRun 之前的节点，  
  45.                 //    这些节点可能分配在另一个链表中，也可能分配到上面的那个链表中  
  46.                 for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {  
  47.                     V v = p.value;  
  48.                     int h = p.hash;  
  49.                     int k = h & sizeMask;  
  50.                     HashEntry<K,V> n = newTable[k];  
  51.                     newTable[k] = new HashEntry<K,V>(h, p.key, v, n);  
  52.                 }  
  53.             }  
  54.         }  
  55.     }  
  56.     // 将新来的 node 放到新数组中刚刚的 两个链表之一 的 头部  
  57.     int nodeIndex = node.hash & sizeMask; // add the new node  
  58.     node.setNext(newTable[nodeIndex]);  
  59.     newTable[nodeIndex] = node;  
  60.     table = newTable;  
  61. }  
  62. ```  


注意这里面的代码，外部已经加锁，所以这里面是安全的，我们看下具体的实现方式：先对数组的长度增加一倍，然后遍历原来的旧的table数组，把每一个数组元素也就是Node链表迁移到新的数组里面，最后迁移完毕之后，把新数组的引用直接替换旧的。此外这里这有一个小的细节优化，在迁移链表时用了两个for循环，第一个for的目的是为了，判断是否有迁移位置一样的元素并且位置还是相邻，根据HashMap的设计策略，首先table的大小必须是2的n次方，我们知道扩容后的每个链表的元素的位置，要么不变，要么是原table索引位置+原table的容量大小，举个例子假如现在有三个元素（3,5,7）要放入map里面，table的的容量是2，简单的假设元素位置=元素的值 % 2，得到如下结构： 

Java代码  收藏代码
  1. ```  
  2. [0]=null  
  3. [1]=3->5->7  
  4. ```  



现在将table的大小扩容成4，分布如下： 

Java代码  收藏代码
  1. ```  
  2. [0]=null  
  3. [1]=5->7  
  4. [2]=null  
  5. [3]=3  
  6. ```  


因为扩容必须是2的n次方，所以HashMap在put和get元素的时候直接取key的hashCode然后经过再次均衡后直接采用&位运算就能达到取模效果，这个不再细说，上面这个例子的目的是为了说明扩容后的数据分布策略，要么保留在原位置，要么会被均衡在旧的table位置，这里是1加上旧的table容量这是是2，所以是3。基于这个特点，第一个for循环，作的优化如下，假设我们现在用0表示原位置，1表示迁移到index+oldCap的位置，来代表元素： 

Java代码  收藏代码
  1. ```  
  2. [0]=null  
  3. [1]=0->1->1->0->0->0->0  
  4. ```  


第一个for循环的会记录lastRun，比如要迁移[1]的数据，经过这个循环之后，lastRun的位置会记录第三个0的位置，因为后面的数据都是0，代表他们要迁移到新的数组中同一个位置中，所以就可以把这个中间节点，直接插入到新的数组位置而后面附带的一串元素其实都不需要动。 

接着第二个循环里面在此从第一个0的位置开始遍历到lastRun也就是第三个元素的位置就可以了，只循环处理前面的数据即可，这个循环里面根据位置0和1做不同的链表追加，后面的数据已经被优化的迁移走了，但最坏情况下可能后面一个也没优化，比如下面的结构： 

Java代码  收藏代码
  1. ```  
  2. [0]=null  
  3. [1]=1->1->0->0->0->0->1->0  
  4. ```  



这种情况，第一个for循环没多大作用，需要通过第二个for循环从头开始遍历到尾部，按0和1分发迁移，这里面使用的是还是头插法的方式迁移，新迁移的数据是追加在链表的头部，但这里是线程安全的所以不会出现循环链表，导致死循环问题。迁移完成之后直接将最新的元素加入，最后将新的table替换旧的table即可。 


JDK8的HashMap扩容 


在JDK8里面，HashMap的底层数据结构已经变为数组+链表+红黑树的结构了，因为在hash冲突严重的情况下，链表的查询效率是O(n），所以JDK8做了优化对于单个链表的个数大于8的链表，会直接转为红黑树结构算是以空间换时间，这样以来查询的效率就变为O(logN)，图示如下： 



我们看下其扩容代码： 

Java代码  收藏代码
  1. ```  
  2.     final Node<K,V>[] resize() {  
  3.         Node<K,V>[] oldTab = table;  
  4.         int oldCap = (oldTab == null) ? 0 : oldTab.length;  
  5.         int oldThr = threshold;  
  6.         int newCap, newThr = 0;  
  7.         if (oldCap > 0) {  
  8.             if (oldCap >= MAXIMUM_CAPACITY) {  
  9.                 threshold = Integer.MAX_VALUE;  
  10.                 return oldTab;  
  11.             }  
  12.             else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&  
  13.                      oldCap >= DEFAULT_INITIAL_CAPACITY)  
  14.                 newThr = oldThr << 1; // double threshold  
  15.         }  
  16.         else if (oldThr > 0) // initial capacity was placed in threshold  
  17.             newCap = oldThr;  
  18.         else {               // zero initial threshold signifies using defaults  
  19.             newCap = DEFAULT_INITIAL_CAPACITY;  
  20.             newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);  
  21.         }  
  22.         if (newThr == 0) {  
  23.             float ft = (float)newCap * loadFactor;  
  24.             newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?  
  25.                       (int)ft : Integer.MAX_VALUE);  
  26.         }  
  27.         threshold = newThr;  
  28.         @SuppressWarnings({"rawtypes","unchecked"})  
  29.             Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];  
  30.         table = newTab;  
  31.         if (oldTab != null) {  
  32.             for (int j = 0; j < oldCap; ++j) {  
  33.                 Node<K,V> e;  
  34.                 if ((e = oldTab[j]) != null) {  
  35.                     oldTab[j] = null;  
  36.                     if (e.next == null)  
  37.                         newTab[e.hash & (newCap - 1)] = e;  
  38.                     else if (e instanceof TreeNode)  
  39.                         ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);  
  40.                     else {   
  41.                         //重点关注区域  
  42.                         // preserve order  
  43.                         Node<K,V> loHead = null, loTail = null;  
  44.                         Node<K,V> hiHead = null, hiTail = null;  
  45.                         Node<K,V> next;  
  46.                         do {  
  47.                             next = e.next;  
  48.                             if ((e.hash & oldCap) == 0) {  
  49.                                 if (loTail == null)  
  50.                                     loHead = e;  
  51.                                 else  
  52.                                     loTail.next = e;  
  53.                                 loTail = e;  
  54.                             }  
  55.                             else {  
  56.                                 if (hiTail == null)  
  57.                                     hiHead = e;  
  58.                                 else  
  59.                                     hiTail.next = e;  
  60.                                 hiTail = e;  
  61.                             }  
  62.                         } while ((e = next) != null);  
  63.                         if (loTail != null) {  
  64.                             loTail.next = null;  
  65.                             newTab[j] = loHead;  
  66.                         }  
  67.                         if (hiTail != null) {  
  68.                             hiTail.next = null;  
  69.                             newTab[j + oldCap] = hiHead;  
  70.                         }  
  71.                     }  
  72.                 }  
  73.             }  
  74.         }  
  75.         return newTab;  
  76.     }  
  77.   
  78. ```  


在JDK8中，单纯的HashMap数据结构增加了红黑树是一个大的优化，此外根据上面的迁移扩容策略，我们发现JDK8里面HashMap没有采用头插法转移链表数据，而是保留了元素的顺序位置，新的代码里面采用： 

Java代码  收藏代码
  1. ```  
  2.                         //按原始链表顺序，过滤出来扩容后位置不变的元素（低位=0），放在一起  
  3.                         Node<K,V> loHead = null, loTail = null;  
  4.                         //按原始链表顺序，过滤出来扩容后位置改变到（index+oldCap）的元素（高位=0），放在一起  
  5.                         Node<K,V> hiHead = null, hiTail = null;  
  6. ```  


把要迁移的元素分类之后，最后在分别放到新数组对应的位置上： 

Java代码  收藏代码
  1. ```  
  2.                         //位置不变      
  3.                         if (loTail != null) {  
  4.                             loTail.next = null;  
  5.                             newTab[j] = loHead;  
  6.                         }  
  7.                         //位置迁移(index+oldCap)  
  8.                         if (hiTail != null) {  
  9.                             hiTail.next = null;  
  10.                             newTab[j + oldCap] = hiHead;  
  11.                         }  
  12. ```  


JDK7里面是先判断table的存储元素的数量是否超过当前的threshold=table.length*loadFactor（默认0.75），如果超过就先扩容，在JDK8里面是先插入数据，插入之后在判断下一次++size的大小是否会超过当前的阈值，如果超过就扩容。 



 

JDK8的ConcurrentHashMap扩容 



在JDK8中彻底抛弃了JDK7的分段锁的机制，新的版本主要使用了Unsafe类的CAS自旋赋值+synchronized同步+LockSupport阻塞等手段实现的高效并发，代码可读性稍差。 

ConcurrentHashMap的JDK8与JDK7版本的并发实现相比，最大的区别在于JDK8的锁粒度更细，理想情况下talbe数组元素的大小就是其支持并发的最大个数，在JDK7里面最大并发个数就是Segment的个数，默认值是16，可以通过构造函数改变一经创建不可更改，这个值就是并发的粒度，每一个segment下面管理一个table数组，加锁的时候其实锁住的是整个segment，这样设计的好处在于数组的扩容是不会影响其他的segment的，简化了并发设计，不足之处在于并发的粒度稍粗，所以在JDK8里面，去掉了分段锁，将锁的级别控制在了更细粒度的table元素级别，也就是说只需要锁住这个链表的head节点，并不会影响其他的table元素的读写，好处在于并发的粒度更细，影响更小，从而并发效率更好，但不足之处在于并发扩容的时候，由于操作的table都是同一个，不像JDK7中分段控制，所以这里需要等扩容完之后，所有的读写操作才能进行，所以扩容的效率就成为了整个并发的一个瓶颈点，好在Doug lea大神对扩容做了优化，本来在一个线程扩容的时候，如果影响了其他线程的数据，那么其他的线程的读写操作都应该阻塞，但Doug lea说你们闲着也是闲着，不如来一起参与扩容任务，这样人多力量大，办完事你们该干啥干啥，别浪费时间，于是在JDK8的源码里面就引入了一个ForwardingNode类，在一个线程发起扩容的时候，就会改变sizeCtl这个值，其含义如下： 

Java代码  收藏代码
  1. ```  
  2. sizeCtl ：默认为0，用来控制table的初始化和扩容操作，具体应用在后续会体现出来。  
  3. -1 代表table正在初始化  
  4. -N 表示有N-1个线程正在进行扩容操作  
  5. 其余情况：  
  6. 1、如果table未初始化，表示table需要初始化的大小。  
  7. 2、如果table初始化完成，表示table的容量，默认是table大小的0.75倍  
  8. ```  


扩容时候会判断这个值，如果超过阈值就要扩容，首先根据运算得到需要遍历的次数i，然后利用tabAt方法获得i位置的元素f，初始化一个forwardNode实例fwd，如果f == null，则在table中的i位置放入fwd，否则采用头插法的方式把当前旧table数组的指定任务范围的数据给迁移到新的数组中，然后 
给旧table原位置赋值fwd。直到遍历过所有的节点以后就完成了复制工作，把table指向nextTable，并更新sizeCtl为新数组大小的0.75倍 ，扩容完成。在此期间如果其他线程的有读写操作都会判断head节点是否为forwardNode节点，如果是就帮助扩容。 

扩容源码如下： 

Java代码  收藏代码
  1. ```  
  2.     private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {  
  3.         int n = tab.length, stride;  
  4.         if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)  
  5.             stride = MIN_TRANSFER_STRIDE; // subdivide range  
  6.         if (nextTab == null) {            // initiating  
  7.             try {  
  8.                 @SuppressWarnings("unchecked")  
  9.                 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];  
  10.                 nextTab = nt;  
  11.             } catch (Throwable ex) {      // try to cope with OOME  
  12.                 sizeCtl = Integer.MAX_VALUE;  
  13.                 return;  
  14.             }  
  15.             nextTable = nextTab;  
  16.             transferIndex = n;  
  17.         }  
  18.         int nextn = nextTab.length;  
  19.         ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);  
  20.         boolean advance = true;  
  21.         boolean finishing = false; // to ensure sweep before committing nextTab  
  22.         for (int i = 0, bound = 0;;) {  
  23.             Node<K,V> f; int fh;  
  24.             while (advance) {  
  25.                 int nextIndex, nextBound;  
  26.                 if (--i >= bound || finishing)  
  27.                     advance = false;  
  28.                 else if ((nextIndex = transferIndex) <= 0) {  
  29.                     i = -1;  
  30.                     advance = false;  
  31.                 }  
  32.                 else if (U.compareAndSwapInt  
  33.                          (this, TRANSFERINDEX, nextIndex,  
  34.                           nextBound = (nextIndex > stride ?  
  35.                                        nextIndex - stride : 0))) {  
  36.                     bound = nextBound;  
  37.                     i = nextIndex - 1;  
  38.                     advance = false;  
  39.                 }  
  40.             }  
  41.             if (i < 0 || i >= n || i + n >= nextn) {  
  42.                 int sc;  
  43.                 if (finishing) {  
  44.                     nextTable = null;  
  45.                     table = nextTab;  
  46.                     sizeCtl = (n << 1) - (n >>> 1);  
  47.                     return;  
  48.                 }  
  49.                 if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {  
  50.                     if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)  
  51.                         return;  
  52.                     finishing = advance = true;  
  53.                     i = n; // recheck before commit  
  54.                 }  
  55.             }  
  56.             else if ((f = tabAt(tab, i)) == null)  
  57.                 advance = casTabAt(tab, i, null, fwd);  
  58.             else if ((fh = f.hash) == MOVED)  
  59.                 advance = true; // already processed  
  60.             else {  
  61.                 synchronized (f) {  
  62.                     if (tabAt(tab, i) == f) {  
  63.                         Node<K,V> ln, hn;  
  64.                         if (fh >= 0) {  
  65.                             int runBit = fh & n;  
  66.                             Node<K,V> lastRun = f;  
  67.                             for (Node<K,V> p = f.next; p != null; p = p.next) {  
  68.                                 int b = p.hash & n;  
  69.                                 if (b != runBit) {  
  70.                                     runBit = b;  
  71.                                     lastRun = p;  
  72.                                 }  
  73.                             }  
  74.                             if (runBit == 0) {  
  75.                                 ln = lastRun;  
  76.                                 hn = null;  
  77.                             }  
  78.                             else {  
  79.                                 hn = lastRun;  
  80.                                 ln = null;  
  81.                             }  
  82.                             for (Node<K,V> p = f; p != lastRun; p = p.next) {  
  83.                                 int ph = p.hash; K pk = p.key; V pv = p.val;  
  84.                                 if ((ph & n) == 0)  
  85.                                     ln = new Node<K,V>(ph, pk, pv, ln);  
  86.                                 else  
  87.                                     hn = new Node<K,V>(ph, pk, pv, hn);  
  88.                             }  
  89.                             setTabAt(nextTab, i, ln);  
  90.                             setTabAt(nextTab, i + n, hn);  
  91.                             setTabAt(tab, i, fwd);  
  92.                             advance = true;  
  93.                         }  
  94.                         else if (f instanceof TreeBin) {  
  95.                             TreeBin<K,V> t = (TreeBin<K,V>)f;  
  96.                             TreeNode<K,V> lo = null, loTail = null;  
  97.                             TreeNode<K,V> hi = null, hiTail = null;  
  98.                             int lc = 0, hc = 0;  
  99.                             for (Node<K,V> e = t.first; e != null; e = e.next) {  
  100.                                 int h = e.hash;  
  101.                                 TreeNode<K,V> p = new TreeNode<K,V>  
  102.                                     (h, e.key, e.val, null, null);  
  103.                                 if ((h & n) == 0) {  
  104.                                     if ((p.prev = loTail) == null)  
  105.                                         lo = p;  
  106.                                     else  
  107.                                         loTail.next = p;  
  108.                                     loTail = p;  
  109.                                     ++lc;  
  110.                                 }  
  111.                                 else {  
  112.                                     if ((p.prev = hiTail) == null)  
  113.                                         hi = p;  
  114.                                     else  
  115.                                         hiTail.next = p;  
  116.                                     hiTail = p;  
  117.                                     ++hc;  
  118.                                 }  
  119.                             }  
  120.                             ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :  
  121.                                 (hc != 0) ? new TreeBin<K,V>(lo) : t;  
  122.                             hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :  
  123.                                 (lc != 0) ? new TreeBin<K,V>(hi) : t;  
  124.                             setTabAt(nextTab, i, ln);  
  125.                             setTabAt(nextTab, i + n, hn);  
  126.                             setTabAt(tab, i, fwd);  
  127.                             advance = true;  
  128.                         }  
  129.                     }  
  130.                 }  
  131.             }  
  132.         }  
  133.     }  
  134. ```  



在扩容时读写操作如何进行



(1)对于get读操作，如果当前节点有数据，还没迁移完成，此时不影响读，能够正常进行。 

如果当前链表已经迁移完成，那么头节点会被设置成fwd节点，此时get线程会帮助扩容。 


(2)对于put/remove写操作，如果当前链表已经迁移完成，那么头节点会被设置成fwd节点，此时写线程会帮助扩容，如果扩容没有完成，当前链表的头节点会被锁住，所以写线程会被阻塞，直到扩容完成。 


对于size和迭代器是弱一致性



volatile修饰的数组引用是强可见的，但是其元素却不一定，所以，这导致size的根据sumCount的方法并不准确。 

同理Iteritor的迭代器也一样，并不能准确反映最新的实际情况 

总结 


本文主要了介绍了HashMap+ConcurrentHashMap的扩容策略，扩容的原理是新生成大于原来1倍大小的数组，然后拷贝旧数组数据到新的数组里面，在多线程情况下，这里面如果注意线程安全问题，在解决安全问题的同时，我们也要关注其效率，这才是并发容器类的最出色的地方。 

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Netty 系列八（基于 WebSocket 的简单聊天室）.

下一篇：The pit of an if statement in Java

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签