ConcurrentHashMap相比hashtable--极端情况性能提高

测试极端情况下百万次修改性能情况

• 开启了16个线程，初始化ConcurrentHashMap分为16个字段
• 同时修改ConcurrentHashMap 和HashTable

import java.util.Hashtable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author WuYe
 * @vesion 1.0 2019/11/4
 * /
 * /**
 * @program: conCurrentProject
 * @description: conCurrentHashMap  比hsahtable有8-9倍的效率提高分段锁原理
 * @author: WuYe
 * @create: 2019-11-04 21:02
 **/
public class syncMap {
      private  static ConcurrentHashMap<Integer,Integer> map1=new ConcurrentHashMap(16,0.9f,16);
      private  static Hashtable<Integer,Integer> map2= new Hashtable<Integer, Integer>(16,0.9f);
   private static Object object = new Object();
    public static void main(String[] args) {
        

        int a=0;
        while (a<16){
            new myThread(a+" of hashTable",a,map2).start();
            a++;
        }
        a=0;
        while (a<16){
            new myThread(a+" of ConcurrentMap",a,map1).start();
            a++;
        }
    }
    static class myThread extends Thread{
        private  int i;
        private  Map map;
        ThreadLocal<Integer> lid=new ThreadLocal(){
            @Override
            public Integer initialValue(){
                return i;
            }
        };
        public myThread(String name,int i,Map map){
            super(name);
            this.i=i;
            this.map=map;
        }
        @Override
        public void run(){
            int i = 0;
                    System.out.println(Thread.currentThread().getName()+"---start--put-->"+lid.get());
                    Long timeStart=System.currentTimeMillis();
            while ( i<100000000 ) {
                           map.put(lid.get(),lid.get());
                           i++;
            }
                    Long timeEnd=System.currentTimeMillis();
                    System.out.println("thread---"+Thread.currentThread().getName()+"over--put-->"+lid.get()+
                            "useTime---"+(timeEnd-timeStart));
        }
    }
}

时间检测

• hashmapTime—2484868000—hashTable-4385328600—beishu—1.7648135031719996`
• 在java并发编程–》用了闭锁来确认线程一起开始，最后一个线程结束时停止计时

package com.ihep.wuye;

import java.util.concurrent.CountDownLatch;

/**
 * @author WuYe
 * @vesion 1.0 2019/11/5
 * /
 * /**
 * @program: conCurrentProject
 * @description:
 * @author: WuYe
 * @create: 2019-11-05 22:06
 **/
public class runTime {

        public static long timeTasks(int nThreads, final Runnable task) throws InterruptedException
        {
            final CountDownLatch startGate = new CountDownLatch(1);
            final CountDownLatch endGate = new CountDownLatch(nThreads);
            for (int i = 0; i < nThreads; i++)
            {
                Thread t = new Thread()
                {
                        @Override
                        public void run()
                    {
                        try{
                                startGate.await();
                                try {
                                    task.run();
                                }
                                finally {
                                    endGate.countDown();
                                }
                            }
                    catch(InterruptedException ignored) {}
                    }
                };
                t.start();
            }
            long start = System.nanoTime();
            startGate.countDown();
            endGate.await();
            long end = System.nanoTime();
            return end - start;
        }
    }