hashmap的实现和扩展分析

hashmap的实现和扩展分析

• hashmap为什么并发不安全?
  
• 为什么String, Interger这样的wrapper类适合作为键？
  
• 自定义hashmap的实现?
  
• JUC并发安全的map实现对比测试?

• hashmap为什么并发不安全?

  1.多线程rehash,多个线程同时进行put()操作,进入transfer()环节.出现环形链表,在进行重新分配大小时,进入死循环.

  2.fail-fast,在使用迭代器的过程中有其他线程修改了map.抛出ConcurrentModificationException异常.

  为什么String, Interger这样的wrapper类适合作为键？

  String, Interger这样的wrapper类作为HashMap的键是再适合不过了，而且String最为常用。因为String是不可变的，也是final的，而且已经重写了equals()和hashCode()方法了。其他的wrapper类也有这个特点。不可变性是必要的，因为为了要计算hashCode()，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode的话，那么就不能从HashMap中找到你想要的对象。不可变性还有其他的优点如线程安全。如果你可以仅仅通过将某个field声明成final就能保证hashCode是不变的，那么请这么做吧。因为获取对象的时候要用到equals()和hashCode()方法，那么键对象正确的重写这两个方法是非常重要的。如果两个不相等的对象返回不同的hashcode的话，那么碰撞的几率就会小些，这样就能提高HashMap的性能。

  自定义hashmap的实现

  //一个很简单的实现
  public class MyLinkHashMap {
      /**
       * 自定义的hashmap,基本元素采用entry[],entry是链表结构. 基本方法: put(string,string)
       * get(string)
       * 
       * entry<string,string>
       * */
      private int length = 10;
      private Entry[] entries;
      private int index = 0;
  
      public MyLinkHashMap() {
          super();
          initinalize();
      }
  
      public void initinalize() {
          entries = new Entry[length];
      }
  
      public String put(String key, String value) {
          // 由于是链表存储,添加要加到链表头部,所以要获取头
          // 第一个问题,放到数组中哪个链表呢,这里通过索引计算法,输入因子是key,通过key一定可以获得value存储在哪个索引下
          int index = key.hashCode() % length;
          Entry privious = entries[index];
          // 第二个问题,如果存在的要覆盖,不存在的才加在头部
          for (Entry entry = entries[index]; entry != null; entry = entry.next) {
              if (entry.getKey().equals(key)) {
                  String oldvalue = entry.getValue();
                  entry.setValue(value);
                  return oldvalue;
              }
          }
          Entry entry = new Entry(key, value);
          entry.next = privious;
          entries[index] = entry;
          return null;
      }
  
      public String get(String key) {
          int index = key.hashCode() % length;
          for (Entry entry = entries[index]; entry != null; entry = entry.next) {
              if (entry.getKey().equals(key)) {
                  return entry.value;
              }
          }
          return null;
      }
  
      public class Entry {
          private String key;
          private String value;
          private Entry next;
  
          public Entry(String key, String value) {
              this.key = key;
              this.value = value;
          }
  
          public String getKey() {
              return key;
          }
  
          public void setKey(String key) {
              this.key = key;
          }
  
          public String getValue() {
              return value;
          }
  
          public void setValue(String value) {
              this.value = value;
          }
  
          public Entry getNext() {
              return next;
          }
  
          public void setNext(Entry next) {
              this.next = next;
          }
  
      }
  }
  

  下面的代码进行对比JUC下的并发性能,时间损耗对比

  
  public class MapCompareTest {
  
      public static Map<String, Integer> hashTable = null;
      public static Map<String, Integer> synchronizedMap = null;
      public static Map<String, Integer> concurrentHashMap = null;
  
      public static void main(String[] args) throws InterruptedException{
          // 构造一个hashtable
          hashTable = new Hashtable<>();
          performTest(hashTable);
          // 构造一个synchronizemap
          synchronizedMap = Collections
                  .synchronizedMap(new HashMap<String, Integer>());
          performTest(synchronizedMap);
          // 构造一个CHM
          concurrentHashMap = new ConcurrentHashMap<>();
          performTest(concurrentHashMap);
      }
  
      public static void performTest(final Map<String, Integer> map)
              throws InterruptedException {
          System.out.println("Test started for: " + map.getClass());
          long averageTime = 0;
          for (int i = 0; i < 5; i++) {
              long begintime = System.nanoTime();
              ExecutorService service = Executors.newFixedThreadPool(5);
              for (int j = 0; j < 5; j++) {
                  service.execute(new Runnable() {
                      @Override
                      public void run() {
                          Integer number = (int) Math.ceil(Math.random() * 550 * 1000);
                          Integer value = map.get(String.valueOf(number));
                          map.put(String.valueOf(number), number);
                      }
                  });
              }
              // 关闭线程池
              service.shutdown();
              // Blocks until all tasks have completed execution after a shutdown
              // request
              service.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
              long endtime = System.nanoTime();
              long totalTime = (endtime - begintime) / 100000L;
              averageTime += totalTime;
              System.out.println("2500K entried added/retrieved in " + totalTime
                      + " ms");
          }
          System.out.println("For " + map.getClass() + " the average time is "
                  + averageTime / 5 + " ms\n");
  
      }
  }
  

  通过对比分析,在高并发访问的情况下,concurrentHashmap是我们使用的首选.

  [参考文档]

  http://www.importnew.com/22011.html
  http://blog.csdn.net/qq_15771061/article/details/54098023