ConcurrentHashMap

#include "bits/stdc++.h"
using namespace std;

struct HashNode {
    int key;
    int value;
    HashNode(int k, int v):key(k),value(v){}
};

class HashMap {
    vector<list<HashNode>> v;
    vector<shared_mutex > mtxs;
    int capacity;
public:
    HashMap(int cap){
        capacity = cap;
        v.resize(capacity);
        vector<shared_mutex> tmp(capacity);
        mtxs.swap(tmp);
    }
    int hashFunction(int key){
        return key%capacity;
    }
    void insert(int key, int value){
        int hashIndex=hashFunction(key);
        unique_lock<shared_mutex> writeLock(mtxs[hashIndex]);
        auto &cur_list=v[hashIndex];
        for (auto it=cur_list.begin();it!=cur_list.end();++it){
            if (it->key==key){
                it->value=value;
                return;
            }
        }
        cur_list.emplace_back(key,value);
    }
    void erase(int key){
        int hashIndex=hashFunction(key);
        unique_lock<shared_mutex> writeLock(mtxs[hashIndex]);
        auto &cur_list=v[hashIndex];
        for (auto it=cur_list.begin();it!=cur_list.end();++it){
            if (it->key==key){
                cur_list.erase(it);
                return;
            }
        }
    }
    int at(int key){
        int hashIndex=hashFunction(key);
        shared_lock<shared_mutex> readLock(mtxs[hashIndex]);
        auto &cur_list=v[hashIndex];
        for (auto it=cur_list.begin();it!=cur_list.end();++it){
            if (it->key==key){
                return it->value;
            }
        }
        return INT_MIN; // not found
    }
    void display(){
        for (int i=0;i<capacity;++i){
            cout << i << ": ";
            for (auto x:v[i]) cout<<x.key<<‘ ‘;
            cout << endl;
        }
    }
};

int main() {
    HashMap hashmap(7);
    vector<int> to_insert{15,11,27,8};
    for (int x:to_insert) hashmap.insert(x,x);
    hashmap.display();
    cout<<hashmap.at(8);
    hashmap.erase(8);
    hashmap.display();
    cout<<hashmap.at(8);
    return 0;
}