程序博客网 > 抄袭检测软件

Java 7之多线程并发容器

来源：互联网 发布：抄袭检测软件 编辑：程序博客网 时间：2024/05/22 11:34

与HashMap一样，ConcurrentHashMap也是一个基于散列的Map，但是它使用了锁分段的技术来提供更高的并发性和伸缩性。

锁分段就是进一步对一组独立的对象进行分解。例如，在ConcurrentHashMap的实现中使用了一个包含16个锁的数组，每个锁保护所有散列桶的1/16，其实第N个散列桶由第(N mod 16)个锁来保护。所以这个并发集合可以支持多达16个并发的写入器。

首先举个例子：

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. public class StripedMap {  
  2.     // Synchronization policy: buckets[n] guarded by locks[n%N_LOCKS]  
  3.     private static final int N_LOCKS = 16;  // 并发锁的数量  
  4.     private final Node[] buckets;           // 散列桶  
  5.     private final Object[] locks;           // 锁数组  
  6.   
  7.     private static class Node {             // 链表中的节点  
  8.         Node next;  
  9.         Object key;  
  10.         Object value;  
  11.     }  
  12.   
  13.     public StripedMap(int numBuckets) {    // 构造函数  
  14.         buckets = new Node[numBuckets];  
  15.         locks = new Object[N_LOCKS];  
  16.         for (int i = 0; i < N_LOCKS; i++)  
  17.             locks[i] = new Object();  
  18.     }  
  19.   
  20.     private final int hash(Object key) {    // 计算值的存储位置，相当于散列函数  
  21.         return Math.abs(key.hashCode() % buckets.length);  
  22.     }  
  23.   
  24.     public Object get(Object key) {  
  25.         int hash = hash(key);  
  26.         synchronized (locks[hash % N_LOCKS]) {                   // 计算出由哪个锁来保护这个散列桶  
  27.             for (Node m = buckets[hash]; m != null; m = m.next)  // 遍历这个散列桶，找到需要的值  
  28.                 if (m.key.equals(key))  
  29.                     return m.value;  
  30.         }  
  31.         return null;  
  32.     }  
  33.   
  34.     public void clear() {  
  35.         for (int i = 0; i < buckets.length; i++) {  
  36.             synchronized (locks[i % N_LOCKS]) {                 // 将锁分段中的值清空  
  37.                 buckets[i] = null;  
  38.             }  
  39.         }  
  40.     }  
  41. }  

如上使用了锁分段技术简单实现了一个Map并发容器，但是与采用单个锁来实现独占访问相比，要获取多个锁来实现独占访问将更加困难并且开销更高。例如有些方法需要跨段，如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。这里“按顺序”是很重要的，否则极有可能出现死锁，在ConcurrentHashMap内部，段数组是final的，并且其成员变量实际上也是final的，但是，仅仅是将数组声明为final的并不保证数组成员也是final的，这需要实现上的保证。这可以确保不会出现死锁，因为获得锁的顺序是固定的。不变性是多线程编程占有很重要的地位。

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. final Segment<K,V>[] segments;  // 段数组为final类型的  
实现代码如下：

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. static final class Segment<K,V> extends ReentrantLock implements Serializable {  
  2.     transient volatile HashEntry<K,V>[] table;  
  3.     // threshold阈，是哈希表在其容量自动增加之前可以达到多满的一种尺度。  
  4.     transient int threshold;  
  5.     // loadFactor是加载因子  
  6.     final float loadFactor;  
  7.   
  8.     Segment(float lf, int threshold, HashEntry<K,V>[] tab) {  
  9.         this.loadFactor = lf;  
  10.         this.threshold = threshold;  
  11.         this.table = tab;  
  12.     }  
  13.     // 省略部分代码  
  14. }  
在每个Segment中通过HashEntry来表示链结构，类似于前面例子中的Node节点，主要的代码如下：

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. static final class HashEntry<K,V> {  
  2.        final int hash;  
  3.        final K key;  
  4.        volatile V value;  
  5.        volatile HashEntry<K,V> next;  
  6.   
  7.        HashEntry(int hash, K key, V value, HashEntry<K,V> next) {  
  8.            this.hash = hash;  
  9.            this.key = key;  
  10.            this.value = value;  
  11.            this.next = next;  
  12.        }  
  13.        // 省略部分代码  
  14.    }  
可以看到除了value不是final的，其它值都是final的，这意味着不能从链表的中间或尾部添加或删除节点，因为这需要修改next 引用值，所有的节点的修改只能从头部开始。


首先来看一下ConcurrentHashMap中最主要的一个构造函数，如下：

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {  
  2.         // 参数有效性判断  
  3.         if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)  
  4.             throw new IllegalArgumentException();  
  5.         // concurrencyLevel是用来计算segments的容量  
  6.         if (concurrencyLevel > MAX_SEGMENTS)  
  7.             concurrencyLevel = MAX_SEGMENTS;  
  8.         int sshift = 0;  
  9.         int ssize = 1;  
  10.         // ssize是大于或等于concurrencyLevel的最小的2的N次方值  
  11.         while (ssize < concurrencyLevel) {  
  12.             ++sshift;  
  13.             ssize <<= 1;  
  14.         }  
  15.         // 初始化segmentShift和segmentMask  
  16.         this.segmentShift = 32 - sshift;  
  17.         this.segmentMask = ssize - 1;  
  18.         // 哈希表的初始容量  
  19.         if (initialCapacity > MAXIMUM_CAPACITY)  
  20.             initialCapacity = MAXIMUM_CAPACITY;  
  21.         int c = initialCapacity / ssize; // 计算哈希表的实际容量  
  22.         if (c * ssize < initialCapacity)  
  23.             ++c;  
  24.         int cap = MIN_SEGMENT_TABLE_CAPACITY; // segments中的HashEntry数组的长度  
  25.         while (cap < c)  
  26.             cap <<= 1;  
  27.         // segments  
  28.         Segment<K,V> s0 = new Segment<K,V>(loadFactor, (int)(cap * loadFactor),  
  29.                              (HashEntry<K,V>[])new HashEntry[cap]);  
  30.         Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];  
  31.         UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]  
  32.         this.segments = ss;  
  33.     }  


1、获取元素


[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. public V get(Object key) {  
  2.     Segment<K,V> s; // manually integrate access methods to reduce overhead  
  3.     HashEntry<K,V>[] tab;  
  4.     int h = hash(key.hashCode());  
  5.     long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;  
  6.     if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&(tab = s.table) != null) {  
  7.         for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);  e != null; e = e.next) {  
  8.             K k;  
  9.             if ((k = e.key) == key || (e.hash == h && key.equals(k)))  
  10.                 return e.value;  
  11.         }  
  12.     }  
  13.     return null;  
  14. }  
如上获取元素的操作是不带锁的，效率会提高。

2、添加元素


[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. public V put(K key, V value) {  
  2.        Segment<K,V> s;  
  3.        if (value == null)  
  4.            throw new NullPointerException();  
  5.        int hash = hash(key.hashCode());  
  6.        int j = (hash >>> segmentShift) & segmentMask;  
  7.        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck  
  8.             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment  
  9.            s = ensureSegment(j);  
  10.        return s.put(key, hash, value, false);  
  11.    }  
接着调用了Segment类中的put方法将元素添加到链表中，如下：

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. final V put(K key, int hash, V value, boolean onlyIfAbsent) {  
  2.            HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);  
  3.            V oldValue;  
  4.            try {  
  5.                HashEntry<K,V>[] tab = table;  
  6.                int index = (tab.length - 1) & hash;  
  7.                HashEntry<K,V> first = entryAt(tab, index);  
  8.                for (HashEntry<K,V> e = first;;) {  
  9.                    if (e != null) {  
  10.                        K k;  
  11.                        if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {  
  12.                            oldValue = e.value;  
  13.                            if (!onlyIfAbsent) {  
  14.                                e.value = value;  
  15.                                ++modCount;  
  16.                            }  
  17.                            break;  
  18.                        }  
  19.                        e = e.next;  
  20.                    }  
  21.                    else {  
  22.                        if (node != null)  
  23.                            node.setNext(first);  
  24.                        else  
  25.                            node = new HashEntry<K,V>(hash, key, value, first);  
  26.                        int c = count + 1;  
  27.                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)  
  28.                            rehash(node);  
  29.                        else  
  30.                            setEntryAt(tab, index, node);  
  31.                        ++modCount;  
  32.                        count = c;  
  33.                        oldValue = null;  
  34.                        break;  
  35.                    }  
  36.                }  
  37.            } finally {  
  38.                unlock();  
  39.            }  
  40.            return oldValue;  
  41.        }  


3、删除元素


[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. public V remove(Object key) {  
  2.     int hash = hash(key);  
  3.     // 根据hash值，找到key对应的Segment片段  
  4.     Segment<K,V> s = segmentForHash(hash);  
  5.     return s == null ? null : s.remove(key, hash, null);  
  6. }  

整个操作是先定位到段，然后委托给段的remove操作。当多个删除操作并发进行时，只要它们所在的段不相同，它们就可以同时进行。下面是Segment的remove方法实现：

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. final V remove(Object key, int hash, Object value) {  
  2.            if (!tryLock())  
  3.                scanAndLock(key, hash);  
  4.            V oldValue = null;  
  5.            try {  
  6.                HashEntry<K,V>[] tab = table;          //  volatile类型的table赋值给一个局部的变量  
  7.                int index = (tab.length - 1) & hash;  
  8.                HashEntry<K,V> e = entryAt(tab, index);// 获取tab中index索引处的链表  
  9.                HashEntry<K,V> pred = null;  
  10.                while (e != null) {  
  11.                    K k;  
  12.                    HashEntry<K,V> next = e.next;  
  13.                    if ((k = e.key) == key ||(e.hash == hash && key.equals(k))) {// 找到了对应的key  
  14.                        V v = e.value;  
  15.                        if (value == null || value == v || value.equals(v)) {  
  16.                            if (pred == null)  
  17.                                setEntryAt(tab, index, next);  
  18.                            else  
  19.                                pred.setNext(next);  
  20.                            ++modCount;     // 修改结构的次数加1  
  21.                            --count;        // 元素数量送去1  
  22.                            oldValue = v;   // 记录原始值  
  23.                        }  
  24.                        break;  
  25.                    }// end if  
  26.                    pred = e;  
  27.                    e = next;  
  28.                }  
  29.            } finally {  
  30.                unlock();  
  31.            }  
  32.            return oldValue;  
  33.        }  

整个remove实现并不复杂，但是需要注意如下几点。

第一，当要删除的结点存在时，删除的最后一步操作要将count的值减一。这必须是最后一步操作，否则读取操作可能看不到之前对段所做的结构性修改。

第二，remove执行的开始就将table赋给一个局部变量tab，这是因为table是 volatile变量，读写volatile变量的开销很大。编译器也不能对volatile变量的读写做任何优化，直接多次访问非volatile实例变量没有多大影响，编译器会做相应优化。


4、迭代元素






转载自http://blog.csdn.net/mazhimazh/


0 0
抄袭检测软件 抄袭检测软件
原创粉丝点击
热门IT博客
淘宝双色球淘宝双色球
曼朗网络曼朗网络
在线课程网络课程
暮色谷的新域名问题
mac打不开英雄联盟
矩阵分析视频百度云
济南网络系统集成商
免费出纳记账软件
machinarium for mac
android studio java
淘宝网店管理技巧
windows优化大师8.0
php 提示非法字符串
网络传真机 无座机
用plsql导入excel数据
mysql router 读写分离
淘宝客教程视频
2017年双十一菜鸟网络
逆波兰表达式c语言算法
淘宝卖家助手要钱吗?
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 套头帽子 套头围脖 毛衣套头 套头衬衫 毛衫套头 套头外套 女套头毛衫 套头丝巾 套头耳机 毛衣女套头 v领套头毛衣 套头改开衫 宾得套头 长款过膝套头毛衣 李宁套头无帽卫衣 圆领套头针织衫 耐克套头卫衣男 李宁套头连帽卫衣 长款套头毛衣怎么搭配 套头是什么意思 套头针织衫怎么搭配 套头羊毛衫女 女式套头毛衣 套头毛衣编织 套头针织衫女 中长款套头女毛衣 女士套头毛衫 套头围脖怎么围好看 套头围脖的各种围法 男士套头毛衣编织 男士套头毛衫 套头针织衫搭配衬衫 套头什么意思 儿童毛衣套头 套头卫衣怎么搭配 李宁套头卫衣 套头围脖的戴法图解 套头毛衣是什么 连帽卫衣女套头 短款套头女卫衣 套头毛衣改成开衫

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里