Java之HashMap、Hashtable对比测试

Java 8

---

编写程序测试 HashMap、Hashtable 的一些功能，并对二者进行对比。来自博客园

截取 参考文档1 的相关内容：

JDK源码：初始容量、loadFactor是两个重要概念，影响到 扩容时的性能。来自博客园

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    // 构造函数 4个
    public HashMap() {...}
    public HashMap(int initialCapacity) {...} // 最高频
    public HashMap(int initialCapacity, float loadFactor) {...}
    public HashMap(Map<? extends K, ? extends V> m) {...}
}

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {
    // 构造函数 4个
    public Hashtable() {...}
    public Hashtable(int initialCapacity) {...} // 最高频
    public Hashtable(int initialCapacity, float loadFactor) {...}
    public Hashtable(Map<? extends K, ? extends V> t) {...}
}

测试程序：来自博客园

package aug;

import java.time.Duration;
import java.time.Instant;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Consumer;

public class Test80201 {

	// 输出信息使用
	private static Consumer<Object> cs = System.out::println;
	
	public static void main(String[] args) {
		test1();
		
		cs.accept("
---------------
");
		
		test2();
	}
	
	public static void test1() {
		// 1、插入null值
		cs.accept("1、插入null值");
		Map<String, Integer> map = new HashMap<>(8);
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", null);
		map.put(null, null);
		cs.accept("map=" + map);
		cs.accept("ma.null=" + map.get(null));
		map.put(null, 999);
		cs.accept("map=" + map);
		cs.accept("map.null=" + map.get(null));
		cs.accept("");
		
		Hashtable<String, Integer> table = new Hashtable<String, Integer>(8);
		table.put("a", 111);
		table.put("b", 222);
		// 不能插入null
//		table.put("c", null);
		// 不能插入null
//		table.put(null, 333);
		cs.accept("table=" + table);
		cs.accept("");
		
		// 2、迭代器
		cs.accept("2、迭代器");
		Iterator<Entry<String, Integer>> iter = map.entrySet().iterator();
		cs.accept("输出iter：");
		while(iter.hasNext()) {
			Entry<String, Integer> ent = iter.next();
			cs.accept(ent);
			
			// fail-fast
			// java.util.ConcurrentModificationException
//			map.remove(ent.getKey());
		}
		
		Set<Entry<String, Integer>> tset = table.entrySet();
		Iterator<Entry<String, Integer>> iter2 = tset.iterator();
		cs.accept("输出iter2：");
		while(iter2.hasNext()) {
			Entry<String, Integer> ent = iter2.next();
			cs.accept(ent);
			
			// fail-fast
			// java.util.ConcurrentModificationException
//			table.remove(ent.getKey());
		}
		
		cs.accept("");
		
		cs.accept("map=" + map);
		cs.accept("table=" + table);
		
		cs.accept("");
		cs.accept("talbe.keys:");
		Enumeration<String> keys = table.keys();
		while(keys.hasMoreElements()) {
			String key = keys.nextElement();
			cs.accept(key + "=" + table.get(key));
			
			// 未发生异常，删除成功
			// 若发生在其它线程呢？
			table.remove(key);
		}
		
		cs.accept("");
		
		cs.accept("map=" + map);
		cs.accept("table=" + table);
	}
	
	/**
	 * 多线程测试
	 * @author ben
	 * @date 2021-08-02 10:31:25 CST
	 */
	public static void test2() {
		ExecutorService es1 = Executors.newFixedThreadPool(4);
		
		// 关注点：
		// 写入数据的最终数量是否符合预期；写入数据的效率；
		
		final int size = 4096;
		
		cs.accept("3、两个线线程往HashMap中写数据");
		final Map<String, Integer> map = new HashMap<>(size);
		es1.submit(()->{
			int end = size/2;
			Instant inst1 = Instant.now();
			for (int i=0; i<end; i++) {
				map.put("a"+i, i);
			}
			Instant inst2 = Instant.now();
			cs.accept("HashMap插入" + end + "个元素，耗时：" + Duration.between(inst1, inst2).toNanos() + "纳秒");
		});
		es1.submit(()->{
			int end = size/2;
			for (int i=0; i<end; i++) {
				map.put("b"+i, i);
			}
		});
		
		try {
			// 睡眠5秒
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			// nothing
		}
		
		// 每次执行可能不同，测试的插入数量越多，误差越大
		cs.accept("map.size=" + map.size());
		
		cs.accept("4、两个线线程往Hashtable中写数据");
		final Hashtable<String, Integer> table = new Hashtable<>(size);
		es1.submit(()->{
			int end = size/2;
			Instant inst1 = Instant.now();
			for (int i=0; i<end; i++) {
				table.put("c"+i, i);
			}
			Instant inst2 = Instant.now();
			cs.accept("Hashtable插入" + end + "个元素，耗时：" + Duration.between(inst1, inst2).toNanos() + "纳秒");
		});
		es1.submit(()->{
			int end = size/2;
			for (int i=0; i<end; i++) {
				table.put("d"+i, i);
			}
		});
		
		try {
			// 睡眠5秒
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			// nothing
		}
		
		cs.accept("table.size=" + table.size());
		
		es1.shutdown();
	}

}

执行结果：

1、插入null值
map={null=null, a=1, b=2, c=null}
ma.null=null
map={null=999, a=1, b=2, c=null}
map.null=999

table={b=222, a=111}

2、迭代器
输出iter：
null=999
a=1
b=2
c=null
输出iter2：
b=222
a=111

map={null=999, a=1, b=2, c=null}
table={b=222, a=111}

talbe.keys:
b=222
a=111

map={null=999, a=1, b=2, c=null}
table={}

---------------

3、两个线线程往HashMap中写数据
HashMap插入2048个元素，耗时：2990900纳秒
map.size=3935
4、两个线线程往Hashtable中写数据
Hashtable插入2048个元素，耗时：13965500纳秒
table.size=4096

同步Map 1：更改map为 Collections.synchronizedMap(new HashMap<>(size)); 

只执行 test2() 的测试结果：

---------------

3、两个线线程往HashMap中写数据
HashMap插入2048个元素，耗时：4987100纳秒
map.size=4096
4、两个线线程往Hashtable中写数据
Hashtable插入2048个元素，耗时：10967600纳秒
table.size=4096

结果分析：

map也写入了符合预期的数据，性能 比 Hashtable 好很多。

同步Map 2：更改map为 new ConcurrentHashMap<String, Integer>(size);

只执行 test2() 的测试结果：

---------------

3、两个线线程往HashMap中写数据
HashMap插入2048个元素，耗时：1996600纳秒
map.size=4096
4、两个线线程往Hashtable中写数据
Hashtable插入2048个元素，耗时：8028700纳秒
table.size=4096

结果分析：

map也写入了符合预期的数据，性能 比 Hashtable 好很多。

参考文档

1、Java面试基础

2、