Java多线程 -- Map容器性能比较
来源:互联网 发布:nba2k15mc捏脸数据 编辑:程序博客网 时间:2024/06/05 10:38
单线程
单线程环境下可以使用HashMap和TreeMap。TreeMap上遍历返回结果是按照Key排序的。
测试方法
记录写入Map中N条记录的时间,单位毫秒。
记录从N条记录的Map中读取10W条记录的时间,单位毫秒。
N=25W,50W,75W,100W
测试结果
N条记录中读10W数据25W 50W 75W 100WHashMap4555TreeMap38424747
结果分析
TreeMap采用红黑树来实现,查找是二分查找,时间复杂度是O(log(n)),最坏情况下的时间复杂度是O(n),而HashMap查找的时间复杂度是O(1)。
测试结果也看出,TreeMap的读写性能都比HashMap差了很多。
所以单线程环境下,如果不是遍历时需要按照Key的排序来返回结果,应该采用HashMap。
多线程
多线程环境下可以使用以下四种Map容器。
1)Collections.synchronizedMap(new HashMap());
2)ConcurrentHashMap
3)Collections.synchronizedSortedMap(new TreeMap())
4)ConcurrentSkipListMap
测试方法
先启动N个写线程,每个写线程写入Map中100W/N条记录。
之后启动N个读线程,每个读线程从100W条记录的Map中读取10W条记录。
记录每个线程的写入/读取时间,单位毫秒。
在一台8核的Intel CPU上执行测试。
测试结果
Read time:9Write time:135
Read time:10Write time:760
Read time:50Write time:1349
Read time:156线程数N=2Write time:168
Write time:169
Read time:20
Read time:24Write time:84
Write time:97
Read time:11
Read time:11Write time:819
Write time:873
Read time:125
Read time:124Write time:676
Write time:682
Read time:152
Read time:153线程数N=4Write time:175
Write time:187
Write time:188
Write time:189
Read time:49
Read time:52
Read time:53
Read time:60Write time:50
Write time:52
Write time:54
Write time:55
Read time:11
Read time:12
Read time:15
Read time:15Write time:890
Write time:917
Write time:928
Write time:944
Read time:271
Read time:277
Read time:280
Read time:283Write time:365
Write time:368
Write time:385
Write time:386
Read time:174
Read time:178
Read time:177
Read time:179线程数N=8Write time:174
Write time:174
Write time:175
Write time:178
Write time:178
Write time:179
Write time:178
Write time:178
Read time:112
Read time:114
Read time:116
Read time:117
Read time:118
Read time:175
Read time:176
Read time:176Write time:55
Write time:32
Write time:56
Write time:56
Write time:57
Write time:56
Write time:56
Write time:58
Read time:13
Read time:13
Read time:13
Read time:14
Read time:14
Read time:15
Read time:16
Read time:14Write time:807
Write time:821
Write time:869
Write time:904
Write time:914
Write time:933
Write time:938
Write time:941
Read time:565
Read time:584
Read time:594
Read time:614
Read time:615
Read time:619
Read time:679
Read time:686Write time:193
Write time:194
Write time:201
Write time:209
Write time:217
Write time:222
Write time:250
Write time:285
Read time:177
Read time:177
Read time:179
Read time:180
Read time:180
Read time:186
Read time:240
Read time:256
结果分析
Collections.synchronizedMap和Collections.synchronizedSortedMap实际上是对传入的Map对象作了个包装,每个方法都加上锁。
ConcurrentHashMap的实现使用了分段锁以及其他一些技术,多线程环境下读不用加锁,写也得到很大程度的优化。
ConcurrentSkipListMap的实现利用了跳表的数据结构,天生为了并发操作而生,同样多线程环境下可以无锁读取。
ConcurrentSkipListMap和TreeMap相同,查找是二分查找,遍历时需要按照Key的排序来返回结果。
单线程环境下,毫无疑问synchronizedHashMap 优于ConcurrentHashMap;synchronizedTreeMap 优于ConcurrentSkipListMap。
随着线程数增多,ConcurrentHashMap读写都优于synchronizedHashMap。
由于读不需要加锁,ConcurrentHashMap和ConcurrentSkipListMap读取时间都基本上不随线程数增加而增加,
而synchronizedHashMap和 synchronizedTreeMap, 因为读也要加锁,则随着线程数增加读取时间也增加。
特别是,8个线程下,ConcurrentSkipListMap的读写效率已经基本上接近synchronizedHashMap。如果线程数再增加,ConcurrentSkipListMap的性能应该会超过synchronizedHashMap。
所以多线程环境下,
如果不需要遍历时需要按照Key的排序来返回结果,首选ConcurrentHashMap;
如果需要遍历时需要按照Key的排序来返回结果,首选ConcurrentSkipListMap。
当然,ConcurrentxxxMap返回弱一致性的迭代器,如果在意这点,就只能选用synchronizedxxxMap了。
===========================================================================================
测试程序
- package learning.multithread.collection;
- import java.util.ArrayList;
- import java.util.Collections;
- import java.util.HashMap;
- import java.util.List;
- import java.util.Map;
- import java.util.TreeMap;
- import java.util.concurrent.ConcurrentHashMap;
- import java.util.concurrent.ConcurrentSkipListMap;
- /**
- * Set -Xms1024M to avoid JVM heap size increase during the test
- */
- public class ConcurrentMapTest {
- private static final int THREAD_NUM = 8;
- private static final int MAP_SIZE = 1000000;
- public static void main(String[] args) throws InterruptedException {
- List<Integer> list = new ArrayList<Integer>(MAP_SIZE);
- for (int i = 0; i < MAP_SIZE; i++) {
- list.add(Integer.valueOf(i));
- }
- Collections.shuffle(list);
- singleThreadMapTest(new HashMap<Integer, Integer>(), list);
- //singleThreadMapTest(new TreeMap<Integer, Integer>(), list);
- //concurrentMapTest(Collections.synchronizedMap(new HashMap<Integer, Integer>()), list);
- //concurrentMapTest(new ConcurrentHashMap<Integer, Integer>(), list);
- //concurrentMapTest(Collections.synchronizedSortedMap(new TreeMap<Integer, Integer>()), list);
- //concurrentMapTest(new ConcurrentSkipListMap<Integer, Integer>(), list);
- }
- private static void singleThreadMapTest(Map<Integer, Integer> map, List<Integer> l) {
- //first run to load all to memories and set map initial size
- mapReadWrite(map, l);
- mapReadWrite(map, l);
- map.clear();
- System.out.println("Now start test......");
- mapReadWrite(map, l.subList(0, (MAP_SIZE/4)));
- map.clear();
- mapReadWrite(map, l.subList(0, (MAP_SIZE/4)*2));
- map.clear();
- mapReadWrite(map, l.subList(0, (MAP_SIZE/4)*3));
- map.clear();
- mapReadWrite(map, l);
- }
- private static void mapReadWrite(Map<Integer, Integer> map, List<Integer> l) {
- MapWriter mwHash = new MapWriter(map, l);
- mwHash.run();
- MapReader mrHash = new MapReader(map, l.subList(0, (MAP_SIZE/10)));
- mrHash.run();
- System.out.println("Map Size = " + map.size());
- }
- private static void concurrentMapTest(Map<Integer, Integer> map, List<Integer> l) throws InterruptedException {
- //first run to load all to memories and set map initial size
- concurrentReadWrite(map, l);
- map.clear();
- concurrentReadWrite(map, l);
- map.clear();
- System.out.println("Now start test......");
- concurrentReadWrite(map, l);
- System.out.println("Map Size = " + map.size());
- }
- private static void concurrentReadWrite(Map<Integer, Integer> map, List<Integer> l)
- throws InterruptedException {
- Thread[] writerThreads = new Thread[THREAD_NUM];
- Thread[] readerThreads = new Thread[THREAD_NUM];
- int mapSize = MAP_SIZE/THREAD_NUM;
- for (int i = 0; i < THREAD_NUM; ++i) {
- writerThreads[i] = new Thread(new MapWriter(map, l.subList(mapSize*i, mapSize*(i+1))));
- }
- for (int i = 0; i < THREAD_NUM; ++i) {
- writerThreads[i].start();
- }
- for (Thread t : writerThreads) {
- t.join();
- }
- for (int i = 0; i < THREAD_NUM; ++i) {
- readerThreads[i] = new Thread(new MapReader(map, l.subList(mapSize*i, mapSize*i+MAP_SIZE/10)));
- }
- for (int i = 0; i < THREAD_NUM; ++i) {
- readerThreads[i].start();
- }
- for (Thread t : readerThreads) {
- t.join();
- }
- }
- private static class MapWriter implements Runnable {
- public MapWriter(Map<Integer, Integer> map, List<Integer> l) {
- this.map = map;
- this.l = l;
- }
- public void run() {
- long begin = System.currentTimeMillis();
- for(Integer i : l) {
- map.put(i, i);
- }
- long end = System.currentTimeMillis();
- System.out.println("Write time:" + (end - begin));
- }
- private final Map<Integer, Integer> map;
- private final List<Integer> l;
- }
- private static class MapReader implements Runnable {
- public MapReader(Map<Integer, Integer> map, List<Integer> l) {
- this.map = map;
- this.l = l;
- }
- public void run() {
- long begin = System.currentTimeMillis();
- for (Integer i : l) {
- map.get(i);
- }
- long end = System.currentTimeMillis();
- System.out.println("Read time:" + (end - begin));
- }
- private final Map<Integer, Integer> map;
- private final List<Integer> l;
- }
- }
- Java多线程 -- Map容器性能比较
- Java多线程 -- Map容器性能比较
- Java多线程 -- Map容器性能比较
- Java多线程 -- Map容器性能比较
- Java里多个Map的性能比较
- java 几个Map的性能比较
- java多线程ReentrantLock、sync、ReentrantReadWriteLock性能比较
- 顺序容器性能比较
- 比较Map的性能
- Map接口,容器比较选择
- vector set map 容器比较
- Java里多个Map的性能比较(TreeMap、HashMap、ConcurrentSkipListMap)
- Java里多个Map的性能比较(TreeMap、HashMap、ConcurrentSkipListMap)
- Java里多个Map的性能比较(TreeMap、HashMap、ConcurrentSkipListMap)
- Java Map遍历方式方式及性能比较
- Java里多个Map的性能比较(TreeMap、HashMap、ConcurrentSkipListMap)
- STL各个容器性能比较
- Java容器分析--Map
- 希尔排序
- day07
- 从 iBatis 到 MyBatis,你准备好了吗?
- WebDriver/StaleElementException
- day08
- Java多线程 -- Map容器性能比较
- 【转】Android 使用NineOldAndroids实现绚丽的ListView左右滑动删除Item效果
- 第一部分 OpenStack及其构成简介
- iOS开发UI篇—iOS开发中三种简单的动画设置
- day09
- Java中关于“=”和“==”的分析
- iOS9.0 网络请求错误解决
- 第二部分 OpenStack安装与配置
- day10