【手写并发容器】C语言实现 Concurrent HashMap

已于 2022-08-14 19:05:15 修改
阅读量824 收藏 1
点赞数
分类专栏： C语言手写并发容器 文章标签： c语言 开发语言
于 2022-08-14 00:36:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GreyKa/article/details/126326602
版权
基本原理介绍
  1. 扩容：当 hash 桶超过 4 / 5 中有内容时候，重新开辟两倍大小的桶空间，并且把元素移动到新的空间中
  2. 分段加锁：将整个哈希表划分成多个子表，对每个子表进行加锁，保证子表之间访问互不干扰，进行两段式哈希，第一次定位到子表，第二次定位到所在子表的桶中。
update1

实测随机数据下面进行桶排序的速度是 C++ STL unordered_map 的四倍，但是在完全无哈希冲突的数据下面速度会慢不少，推测是因为扩容的逻辑比较耗时。后续可以改进扩容逻辑。

update2

扩容逻辑优化，实测下来随机情况下效率提升10%，完全无哈希冲突时效率提升250%。保持了各种情况下面效率为 C++ STL unordered_map 效率的三倍以上。接下来的任务是研究上锁，做成线程安全的。

update3

对串行 hashmap 加锁， 外层包装一个 分段加锁的 hashmap， 完成了类似 JDK 1.7 之前的 Concurrent HashMap 机制的分段式加锁 并发哈希表。

C++ STL unordered_map 和 con_segmap 效率对比 （执行代码见最下方）

在这里插入图片描述

hash_entry.h

#pragma once
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
#define INIT_SIZE 4

typedef struct entry {
    void* key;
    void* val;
    struct entry* next;
}entry;

entry* create_entry(void* key, void* val, entry* next) {
    entry* ret = malloc(sizeof(entry));
    ret->key = key;
    ret->val = val;
    ret->next = next;
    return ret;
}

entry* create_entries(int n) {
    return calloc(n, sizeof(entry));
}

void lput(entry* head, entry* item, bool (*equals)(void* a, void* b)) {
    while(head->next != NULL) {
        entry* now = head->next;
        if((*equals)(now->key, item->key)) {
            now->val = item->val;
            return;
        }
        head = head->next;
    }
    head->next = item;
    item->next = NULL;
}

void* lget(entry* head, void* key, bool (*equals)(void* a, void* b)) {
    void* ret = NULL;
    while(head->next != NULL) {
        entry* now = head->next;
        if((*equals)(now->key, key)) {
            ret = now->val;
            break;
        }
        head = head->next;
    }
    return ret;
}

void* ldel(entry* head, void* key, bool (*equals)(void* a, void* b)) {
    while(head->next != NULL) {
        entry* now = head->next;
        if((*equals)(now->key, key)) {
            head->next = now->next;
            return now;
        }
        head = head->next;
    }
    return NULL;
}

con_hashmap.h

#pragma once
#include "hash_entry.h"
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
#define INIT_SIZE 4


typedef struct con_hashmap {
    size_t cap;
    size_t load;
    size_t size;
    entry** data;
    size_t hash_offset;
    uint32_t (*hash_func)(void* v);
    bool (*equals)(void* a, void* b);
    pthread_spinlock_t lock;
}con_hashmap;

con_hashmap* create_hashmap(uint32_t (*hash_func)(void* v), bool (*equals)(void* a, void* b)) {
    con_hashmap* ret = malloc(sizeof(con_hashmap));
    ret->cap = (1 << INIT_SIZE);
    ret->load = ret->size = ret->hash_offset = 0;
    ret->data = malloc(sizeof(entry*) * (1 << INIT_SIZE));
    entry* heads = create_entries(1 << INIT_SIZE);
    for(int i = 0; i < (1 << INIT_SIZE); i ++) {
        ret->data[i] = &heads[i];
    }
    ret->hash_func = hash_func;
    ret->equals = equals;
    pthread_spin_init(&ret->lock, PTHREAD_PROCESS_PRIVATE);
    return ret;
}

uint32_t _hv(con_hashmap* s, void* key) {
    return ((*s->hash_func)(key)) >> s->hash_offset;
}

void* _get_bucket(con_hashmap* s, uint32_t hv) {
    uint32_t bucket_id = hv & (s->cap - 1);
    return s->data[bucket_id];
}

void* _get_bucket_raw(entry** data, size_t cap, uint32_t hv) {
    uint32_t bucket_id = hv & (cap - 1);
    return data[bucket_id];
}

void _resize(con_hashmap* s) {
    size_t new_cap = s->cap << 1;
    size_t new_load = 0;
    entry* heads = create_entries(new_cap);
    entry** new_data = malloc(sizeof(entry*) * new_cap);
    for(int i = 0; i < new_cap; i ++) {
        new_data[i] = &heads[i];
    }

    for(int i = 0; i < s->cap; i ++) {
        entry* h = s->data[i];
        while(h->next != NULL) {
            entry* now = h->next;
            h->next = now->next;
            entry* bucket = _get_bucket_raw(new_data, new_cap, _hv(s, now->key));
            if(bucket->next == NULL){
                new_load ++;
            }
            lput(bucket, now, s->equals);
        }
    }

    entry* old_heads = s->data[0];
    entry** old_data = s->data;
    s->data = new_data;
    s->cap = new_cap;
    s->load = new_load;

    free(old_heads);
    free(old_data);
}

void* _get(con_hashmap* s, uint32_t hv, void* key) {
    entry* bucket = _get_bucket(s, hv);
    return lget(bucket, key, s->equals);
}

void* get(con_hashmap* s, void* key) {
    pthread_spin_lock(&s->lock);
    void* ret = _get(s, _hv(s, key), key);
    pthread_spin_unlock(&s->lock);
    return ret;
}

void _put(con_hashmap*s, uint32_t hv, void* key, void* val) {
    entry* bucket = _get_bucket(s, hv);
    if(bucket->next == NULL) {
        s->load ++;
    }
    if(s->cap * 4 <= s->load * 5) {
        _resize(s);
        bucket = _get_bucket(s, hv);
        if(bucket->next == NULL) {
            s->load ++;
        }
    }
    entry* item = create_entry(key, val, NULL);
    lput(bucket, item, s->equals);
    s->size ++;
}

void put(con_hashmap* s, void* key, void* val) {
    pthread_spin_lock(&s->lock);
    _put(s, _hv(s, key), key, val);
    pthread_spin_unlock(&s->lock);
}

void* _del(con_hashmap* s, uint32_t hv, void* key) {
    entry* bucket = _get_bucket(s, hv);
    void* ret = ldel(bucket, key, s->equals);
    if(bucket->next == NULL) {
        s->load --;
    }
    s->size --;
    return ret;
}

void* del(con_hashmap* s, void* key) {
    pthread_spin_lock(&s->lock);
    void* ret = _del(s, _hv(s, key), key);
    pthread_spin_unlock(&s->lock);
    return ret;
}

size_t size(con_hashmap* s) {
    return s->size;
}

con_segmap.h

#pragma once
#include "con_hashmap.h"
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
#define INIT_SIZE 4


typedef struct con_segmap {
    con_hashmap** submaps;
    uint32_t (*hash_func)(void* v);
    size_t con_level;
}con_segmap;

con_segmap* create_segmap(uint32_t (*hash_func)(void* v), bool (*equals)(void* a, void* b), size_t con_level) {
    con_segmap* ret = malloc(sizeof(con_segmap));
    ret->con_level = con_level;
    ret->hash_func = hash_func;
    ret->submaps = malloc(sizeof(con_hashmap*) * (1 << con_level));
    for(int i = 0; i < (1 << con_level); i ++) {
        ret->submaps[i] = create_hashmap(hash_func, equals);
        ret->submaps[i]->hash_offset = con_level;
    }
    return ret;
}

uint32_t __hv(con_segmap* s, void* x) {
    return (*s->hash_func)(x);
}

void sput(con_segmap* s, void* key, void* val) {
    uint32_t hv = __hv(s, key);
    uint32_t sub_id = hv & ((1 << s->con_level) - 1);
    pthread_spin_lock(&s->submaps[sub_id]->lock);
    _put(s->submaps[sub_id], hv >> s->con_level, key, val);
    pthread_spin_unlock(&s->submaps[sub_id]->lock);
}

void* sget(con_segmap* s, void* key) {
    uint32_t hv = __hv(s, key);
    uint32_t sub_id = hv & ((1 << s->con_level) - 1);
    pthread_spin_lock(&s->submaps[sub_id]->lock);
    void* ret = _get(s->submaps[sub_id], hv >> s->con_level, key);
    pthread_spin_unlock(&s->submaps[sub_id]->lock);
    return ret;
}

void* sdel(con_segmap* s, void* key) {
    uint32_t hv = __hv(s, key);
    uint32_t sub_id = hv & ((1 << s->con_level) - 1);
    pthread_spin_lock(&s->submaps[sub_id]->lock);
    void* ret = _del(s->submaps[sub_id], hv >> s->con_level, key);
    pthread_spin_unlock(&s->submaps[sub_id]->lock);
    return ret;
}

size_t ssize(con_segmap* s) {
    size_t ret = 0;
    for(int i = 0; i < (1 << s->con_level); i ++) {
        ret += s->submaps[i]->size;
    }
    return ret;
}

test.c

#include "con_segmap.h"
#define MAXN 10000000
int c[MAXN];
int v[MAXN];
int a[MAXN];
int ptr, p;
uint32_t hash_func(void* x) {
    return *(int*)x;
}
bool equals(void* a, void* b) {
    return *(int*)a == *(int*)b;
}
int main()
{
    con_segmap* map = create_segmap(hash_func, equals, 4);
    for(int i = 0; i < MAXN; i ++) {
        v[i] = rand()%MAXN;
        int* cnt = sget(map, &v[i]);
        if (cnt == NULL) {
            c[ptr++] = 1;
            sput(map, &v[i], &c[ptr - 1]);
        } else {
            *cnt += 1;
        }
    }
    for(int i = 0; i < MAXN; i ++) {
        int* cnt = sget(map, &i);
        if(cnt == NULL) {
            continue;
        } else {
            while((*cnt) --) {
                a[p++] = i;
            }
        }
    }
}

test.cpp

#include <bits/stdc++.h>
#include <stdio.h>
#define MAXN 10000000
using namespace std;
int c[MAXN];
int v[MAXN];
int a[MAXN];
int ptr, p;
int main()
{
    unordered_map<int, int> um;
    for(int i = 0; i < MAXN; i ++) {
        v[i] = i;
        um[v[i]] ++;
    }
    for(int i = 0; i < MAXN; i ++) {
        int cnt = um[i];
        while((cnt) --) {
            a[p++] = i;
        }
    }
}
GreyKa
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++】模拟实现STL容器：list
学了就忘是正常现象
12-06 1619
list的普通迭代器通过类进行封装+运算符重载实现。 list的const通过类模板实现。 operator*返回节点的数据。 operator->返回节点数据的指针。
ConcurrentHashMap的实现原理
wdq892157341的专栏
08-18 595
实现原理    锁分离 (Lock Stripping)   ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术。它使用了多个锁来控制对hash表的不同部分进行的修改。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不
C语言实现Hash Map(1)：Map基础知识入门
主要分享硬件、嵌入式软件部分知识
05-21 1755
Map是一种关联容器，它存储键值对（），通过键（key）来快速查找对应的值（value插入（Insert）：将一个键值对插入Map。查找（Find）：根据键查找对应的值。删除（Delete）：从Map中删除一个键值对。在本篇博客中，介绍了Map的基本概念和两种主要实现方式：Hash Map和红黑树Map。我们还简要介绍了C++标准库中的std::map和。在下一篇博客中，我将深入探讨如何在C语言中实现一个简单的Hash Map。
206. 反转链表
波风水门的博客
12-31 245
第一次尝试   反转一个单链表。链表为无头结点、单向、不循环。（由于涉及到结构体，所以写不了完整的测试代码，下面展示的代码为 LeetCode 中写的代码）(LeetCode链接) 本题我写了三种解题方法 三种方法之外的方法：动态申请能装下链表数据的空间，然后将链表数据存放到数组中，在数组中将数据逆转，再存放到链表中，不过这种方法太麻烦了，浪费时间空间，不推荐 方法一：头插法，再创建一个链表 _head，然后从头遍历原链表 head，再将 head 中的数据以头插法插入到 _head 链表中，这样就完成了
C++ tbb::concurrent_hash_map怎么用
软件工程小施同学 的专栏
10-19 1194
Intel TBB 提供高并发的容器类，Windows或者Linux线程能使用这些容器类或者和基于task编程相结合(TBB)。 concurrent_hash_map<Key,T,HashCompare>是一个hash表，允许并行访问，表是一个从Key到类型T的映射，类型HashCompare定义怎样hash一个Key和怎样比较2个Key。 concurrent_hash_mapis a class template for an unordered associative co...
c语言map的用法总结
qq_63108111的博客
04-06 6563
map是STL的一个关联容器，它提供一对一的hash。第一个可以称为关键字(key)，每个关键字只能在map中出现一次；第二个可能称为该关键字的值(value)所有元素会根据键值来自动排序。
c++ map修改value_Map 综述—彻头彻尾理解ConcurrentHashMap
weixin_39828331的博客
11-28 552
写在前面本文所有关于 ConcurrentHashMap 的源码都是基于 JDK 1.6的，不同 JDK 版本之间会有些许差异，但不影响我们对 ConcurrentHashMap 的数据结构、原理等整体的把握和了解ConcurrentHashMap是J.U.C(java.util.concurrent包)的重要成员，它是HashMap的一个线程安全的、支持高效并发的版本ConcurrentHash...
concurrentHashMap
qq_29747683的博客
10-01 278
并发环境使用HashMap在并发场景中，使用HashMap,没有保持足够的同步，可能在执行HashMap.get时进入死循环，将CPU消耗到100%. HashMap采用的是链表解决Hash冲突，容易形成闭合的链路，这样在循环时候，只要有线程对这个HashMap进行get操作就会产生死循环，应该用ConcurrentHashMap.
Java并发：同步容器&并发容器
12-22
而并发容器，特别是`concurrent`包中的类，通过创新的锁策略和数据结构设计，提高了并发性能，降低了锁冲突的可能性，从而更适合高并发的场景。在设计并发程序时，开发者应根据具体需求选择适当的容器类型，以实现...
【面试系列】并发容器之ConcurrentHashMap
01-20
微信公众号：放开我我还能学 ...这就导致了所有并发操作都要竞争同一把锁，一个线程在进行同步操作时，其他线程只能等待，大大降低了并发操作的效率。 Collections#SynchronizedMap 同步包装器 SynchronizedMap
并发容器的原理，7大并发容器详解、及使用场景
11-15
并发容器位于 `java.util.concurrent` 包下，其中包含多种专门为多线程环境设计的容器。这些容器通常使用更精细的锁策略，如分段锁（Segment）、CAS（Compare and Swap）算法，以及 volatile 关键字，以提高并发性并...
Java从同步容器到并发容器的操作过程
08-26
除了`CopyOnWrite`系列容器，`java.util.concurrent`包还包含其他并发容器，如`ConcurrentHashMap`，它使用分段锁技术，允许并发读写，相比于`HashTable`有更高的并发性能。`ConcurrentLinkedQueue`是一个无界的线程...
Java多线程编程中的两种常用并发容器讲解
09-03
ConcurrentHashMap是Java并发包`java.util.concurrent`中的一个线程安全的哈希映射容器，它在并发性能上远优于传统的`synchronized HashMap`或`Collections.synchronizedMap()`包装的HashMap。ConcurrentHashMap采用...
C语言-手写Map(数组+链表+红黑树)(全功能)
weixin_45203607的博客
09-01 1601
C语言-手写Map(数组+链表+红黑树)(全功能)
c语言map的实现-使用内核红黑树
热门推荐
staticnetwind的专栏
09-27 2万+
一、前言 内核数据结构中，上次讲了一次内核链表的使用《c语言双向循环链表实现-使用内核链表》，这次再接着讲一下内核中常用的&lt;key,value&gt;结构，红黑树（rbtree）。 二、相关知识 2.1 红黑树特点 红黑树为自平衡二叉查找树，具备了以下几种特征[1]： 节点是红色或黑色。 根是黑色。 所有叶子都是黑色（叶子是NIL节点）。 每个红色节点必须有两个黑色的子节点...
ConcurrentHashMap 的工作原理及代码实现
SayBlog
06-02 1442
ConcurrentHashMap采用了非常精妙的"分段锁"策略，ConcurrentHashMap的主干是个Segment数组。Segment继承了ReentrantLock，所以它就是一种可重入锁（ReentrantLock)。在ConcurrentHashMap，一个Segment就是一个子哈希表，Segment里维护了一个HashEntry数组，并发环境下，对于不同Segment的数据进行操作是不用考虑锁竞争的。 ...
ConcurrentHashMap实现原理及源码分析
Jak的博客
08-29 1309
一、ConcurrentHashMap跟HashMap，HashTable的对比 1. HashMap不是线程安全： 在并发环境下，可能会形成环状链表（扩容时可能造成，具体原因自行百度google或查看源码分析），导致get操作时，cpu空转，所以，在并发环境中使用HashMap是非常危险的 2. HashTable是线程安全的： HashTable和HashMap的实现原理几乎一样， 差别： 1.HashTable不允许key和value为null； 2.HashTable是线程安全的。
翻了ConcurrentHashMap1.7 和1.8的源码，我总结了它们的主要区别。
m0_73311735的博客
09-29 721
Java7 中 ConcurrentHashMap 使用的分段锁，也就是每一个 Segment 上同时只有一个线程可以操作，每一个 Segment 都是一个类似 HashMap 数组的结构，它可以扩容，它的冲突会转化为链表。但是 Segment 的个数一但初始化就不能改变。Java8 中的 ConcurrentHashMap 使用的 Synchronized 锁加 CAS 的机制。结构也由 Java7 中的Segment 数组 + HashEntry 数组 + 链表进化成了。
C语言 灵活数组成员
最新发布
C or CPP
07-19 851
在C99及C++标准中，引入了灵活数组成员（flexible array member）的概念。这个特性允许在结构体中定义一个数组，其大小在编译时未知，实际大小在运行时确定。通常，灵活数组成员的定义方式是int data[]，这表明数组的大小是动态的。占位符用途对齐和布局：使用是一个常见的技巧，用于确保结构体在内存中的对齐和布局符合要求。这种方法让编译器在计算结构体的总大小时考虑到数组的开始位置，方便动态分配实际需要的内存。占位符：在结构体中使用。
HashMap 和Concurrent HashMap 区别
07-28
HashMap 和 ConcurrentHashMap 是 Java 中两种常用的 Map 实现。它们的主要区别在于线程安全性和性能方面。 1. 线程安全性： - HashMap：HashMap 是非线程安全的，如果多个线程同时访问 HashMap，可能会导致数据不一致或抛出 ConcurrentModificationException 异常。 - ConcurrentHashMap：ConcurrentHashMap 是线程安全的，它通过使用分段锁（Segment）来实现并发访问。不同的 Segment 可以由不同的线程同时访问，提高了并发性能。 2. 写操作和读操作： - HashMap：在写操作时，需要加锁来保证线程安全，因此在高并发环境下，性能会受到影响。在读操作时，不需要加锁，因此性能较高。 - ConcurrentHashMap：ConcurrentHashMap 使用了分段锁，在写操作时只锁定对应的分段，不影响其他分段的并发读操作，因此在高并发环境下性能较好。 3. 迭代器： - HashMap：在使用迭代器遍历 HashMap 时，如果期间有其他线程修改了 HashMap，可能会抛出 ConcurrentModificationException 异常。 - ConcurrentHashMap：ConcurrentHashMap 的迭代器是弱一致性的，它不会抛出 ConcurrentModificationException 异常。迭代器可以反映出在创建迭代器之前的状态，并且可能会反映出其他线程对 ConcurrentHashMap 进行的最近修改。 综上所述，如果需要在多线程环境中使用 Map，推荐使用 ConcurrentHashMap，它提供了更好的并发性能和线程安全性。而在单线程环境下，HashMap 的性能可能会更好一些。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值