map 与 hash_map 性能比较

由于工作需要，最近不得不关注 map 与 hash_map 的性能，于是花了两天的功夫验证了一下，下面把验证的结果贴出来，给大家看看，希望对大家有帮助。

我主要对 map 和 hash_map 的插入、查询、遍历、清除（也就是清空）作了对比。

先来看一下我的源程序（可以直接在Windows下编译）：

#include <stdio.h>
#include <hash_map>
#include <map>
#include <time.h>
#include <iostream>
#include <Windows.h>
#include <stdlib.h>
#include <winternl.h>

using namespace std;

#define PACKETS_COUNT 2000000

// Struct of response packet
typedef struct _PACKET_RESPONSE_
{
    int packetNum;                  // The num of current packet
    int count404;                   // The count of 404 Not Found
    clock_t clockTick;              // The clock tick of the packet that start at the process opened
}PACKET_RESPONSE;

typedef map<unsigned int, _PACKET_RESPONSE_*> RESPONSE_HASH_MAP;

PACKET_RESPONSE **response = {NULL};

// 插入
int insert(RESPONSE_HASH_MAP &responseHashMap)
{
	for (int i=0; i<PACKETS_COUNT; i++)
	{
		PACKET_RESPONSE *newPacketResponse = *(response+i);
        newPacketResponse->count404  = i;
		newPacketResponse->packetNum = i;
		newPacketResponse->clockTick = clock();

		responseHashMap.insert(RESPONSE_HASH_MAP::value_type(i, newPacketResponse));
	}

	cout << "OK!" << endl;
	return 0;
}

// 查找
int find(RESPONSE_HASH_MAP::iterator &iter, RESPONSE_HASH_MAP *responseHashMap, int key)
{
	iter = responseHashMap->find(key);
    if (responseHashMap->end() == iter)
    {
		cout << "not find!" << endl;
        return -1;
    }

	cout << "find OK !\nKey: " << key << "\ncount404: " <<  iter->second->count404 << "\npacketNum: " << iter->second->packetNum << "\nclockTick: " << iter->second->clockTick << endl;
}

// 遍历
int visit(RESPONSE_HASH_MAP &responseHashMap)
{
	int MaxPacketNum = 0;
	RESPONSE_HASH_MAP::iterator iter = responseHashMap.begin();
	while (responseHashMap.end() != iter)
	{
		if (MaxPacketNum < iter->second->packetNum)
		{
			MaxPacketNum = iter->second->packetNum;
		}
		++iter;
	}
	cout << "MaxPacketNum is: " << MaxPacketNum << endl;
	return 0;
}

// 清理
int clear(RESPONSE_HASH_MAP &responseHashMap)
{
	if (0 != responseHashMap.size())
	{
		responseHashMap.clear();
	}

	return 0;
}

DWORD getCpuUsage()
{  

    MEMORYSTATUS ms;
    ::GlobalMemoryStatus(&ms);

    return ms.dwMemoryLoad;
} 

int main()
{
	response = new PACKET_RESPONSE*[PACKETS_COUNT];
	clock_t t = clock();
	for (int i=0; i<PACKETS_COUNT; i++)
	{
		response[i] = new PACKET_RESPONSE;
	}
	cout << "======================> clock is:" << clock()-t << endl;

	RESPONSE_HASH_MAP responseHashMap;
	RESPONSE_HASH_MAP::iterator iter = responseHashMap.begin();
	DWORD dwStart = getCpuUsage();

	clock_t start = clock();
	insert(responseHashMap);
	cout << "====> insert clock is: " <<  clock()-start << " ms" << endl;
	DWORD dwInsert = getCpuUsage();
	cout << "insert 内存使用率为: " << dwInsert-dwStart << "%" << endl;

	RESPONSE_HASH_MAP::iterator it = responseHashMap.begin();
	clock_t eraseStart = clock();
	for (int i=0; i<1000; i++)
	{
		PACKET_RESPONSE *newNode = new PACKET_RESPONSE;
		newNode->packetNum = PACKETS_COUNT + i;
		newNode->count404  = PACKETS_COUNT + i;
		newNode->clockTick = clock();
		responseHashMap.insert(RESPONSE_HASH_MAP::value_type(PACKETS_COUNT + i, newNode));

		it = responseHashMap.erase(it);
	}
	cout << "=====> erase clock is: " << clock()-eraseStart << " ms" << endl;
	clock_t findStart = clock();
	find(iter, &responseHashMap, PACKETS_COUNT-1);
	cout << "====> find clock is: " << clock()-findStart << " ms" << endl;
	DWORD dwFind = getCpuUsage();
        cout << "find 内存使用率为: " << dwFind - dwInsert << "%" << endl;

	clock_t visitStart = clock();
	visit(responseHashMap);
	cout << "====> visit clock is: " << clock()-visitStart << " ms" << endl;
	DWORD dwVisit = getCpuUsage();
	cout << "visit 内存使用率为：" << dwVisit << "%" << endl;

	clock_t clearStart = clock();
	clear(responseHashMap);
	cout << "======> clear clock is: " << clock()-clearStart << " ms" << endl;
	DWORD dwClear = getCpuUsage();
	cout << "clear 内存使用率为：" << dwClear << "%" << endl;

	return 0;
}

    由于我是验证 map 与 hash_map 的性能，所以有些变量的命名是按照之前 hash_map 来命名的，不要觉得奇怪。

我把验证的结果贴出来。

<usigned int, PACKET_RESPONSE*>                  -- 自己管理内存。
插入 查询遍历
200条 4ms 2ms 1ms hash_map
            2ms2ms 1msmap


2000条 33ms 3ms 3ms hash_map
17ms 2ms3ms map


20000条 400ms 2ms 21ms hash_map
178ms 2ms27ms map


200000条 10s 3ms 185ms hash_map
2s 3ms250ms map


2000000条 8min 3ms 1.8s hash_map
22s 4ms2.6s map



<usigned int, PACKET_RESPONSE>-- 把内存交给 map 或者 hash_map
插入 查询遍历
200条 6ms 2ms 1ms hash_map
            2ms2ms 1msmap


2000条 33ms 3ms 3ms hash_map
17ms 2ms3ms map


20000条 400ms 3ms 21ms hash_map
178ms 2ms27ms map


200000条 10s 3ms 185ms hash_map
2s 3ms250ms map


2000000条 9min 3ms 1.7s hash_map
22s 3ms2.5s map




<usigned int, int> -- value 类型为内置类型
插入 查询遍历
200条 6ms 1ms 1ms hash_map
2ms 2ms1ms map


2000条 34ms 1ms 3ms hash_map
17ms 1ms3ms map


20000条 400ms 1ms 22ms hash_map
175ms 2ms27ms map


200000条 10s1ms 186mshash_map
2s 1ms249ms map


2000000条 9min 1ms 1.8s hash_map
22s 2ms2.5s map




<usigned int, PACKET_RESPONSE*>                --自己管理内存    批量申请内存
插入 查询遍历 清除
200条 4ms 2ms 1ms 1ms hash_map
2ms 2ms1ms 0msmap


2000条 31ms 2ms 3ms 34ms hash_map
15ms 3ms4ms 1msmap


20000条 400ms 3ms 21ms 1.3s hash_map
186ms 3ms35ms 10msmap


200000条 10s2ms 183ms74s hash_map
2.1s 4ms288ms 110msmap


2000000条 8min 2ms 1.7s 1h hash_map
22s 3ms2.5s 900msmap


我是根据 value 的类型不同而作的验证。从结果中可以看出，map 的插入、清除性能远比 hash_map 的要高，尤其是清除，大家看最后一个，清除 200W 条的记录时，map 只花了900ms，而 hash_map 却花了一个小时，我开始还以为程序有问题，后来我花了几个小时验证了好几遍，都是这样。而 hash_map 的遍历性能比 map 要高。如果你使用的时候频繁插入或者频繁清除的话，就选择 map，如果你频繁的遍历那就建议使用 hash_map。还有，这个跟 value 的类型没多少关系，我开始在网上看有些人说 map 对内置类型的处理性能比 hash_map 高，而对于自定义类型的处理 hash_map 要高，事实证明，不是这样的。

后来我怀疑是 new 操作影响了性能，所以我用了一个批量申请内存，但是从验证的结果来看，这个对性能没多大的影响。如果你要自己管理内存的话，我建议还是批量申请内存好。如果你不想自己管理内存，那就把内存管理交给 map 或者 hash_map，它们有着一套非常不错的内存管理机制，当它们释放完内存后，并不是交给 ISO，而是留着自己下次使用。这个就是我上面<usigned int, PACKET_RESPONSE>所列出的情况，是将自定义的结构体直接插入 map 或 hash_map中。

我上面的代码是使用了批量申请内存，然后自己管理内存的。如果大家想看看其它的情况的话，可以自己改下代码。

希望对大家有所帮助，还有如果有人觉得哪里不对的话可以告诉我，大家共同进步。

博主所有文章已转自私人博客Joe 的个人博客，谢谢关注！