orcaman/concurrent-map
Concurrent Map
Concurrent-map is a lock-striped hash map and sharded concurrent cache for Go, designed as a high-performance key-value store that enables thread-safe parallel reads and writes with minimal blocking. It replaces a single global mutex with per-shard locking, using hash-based key distribution to assign entries to independent segments, allowing multiple goroutines to operate simultaneously without race conditions.
The library achieves its performance through fine-grained locking and a lock-free read path, where each shard operates independently with its own lock, enabling parallel reads and writes across different shards without interference. It supports snapshot-based iteration, allowing safe traversal of all entries while concurrent modifications occur, and provides standard key-value operations including insertion, retrieval, deletion, existence checks, counting, and clearing all entries in a thread-safe manner.
As a sharded in-memory cache, concurrent-map partitions data into independent segments to reduce lock contention and maximize throughput for concurrent access patterns. The project is distributed as a Go package with a straightforward API for storing and retrieving key-value pairs across multiple goroutines.
Features
- Concurrent Map Implementations - Provides a high-performance concurrent map implementation optimized for parallel reads and writes.
- Sharded Read-Write Operations - Divides a map into shards each with its own lock so multiple goroutines can read and write simultaneously.
- Thread-Safe Sharded Caches - Provides a thread-safe in-memory cache supporting parallel reads and writes without race conditions.
- Concurrent Store-and-Retrieve Operations - Stores and retrieves key-value pairs across multiple shards so goroutines can read and write without blocking.
- Key-Value Pair Managers - Provides concurrent-safe insertion and update of key-value pairs in a sharded map.
- Key-Value Stores - Delivers a high-performance key-value store optimized for concurrent access across many goroutines.
- Concurrent - Stores and retrieves values by key across multiple goroutines without data races or corruption.
- Map Key Removals - Provides concurrent-safe deletion of key-value pairs from a sharded map structure.
- Safe Key Accessors - Implements safe key-value retrieval with existence checks for concurrent read access.
- Concurrent Data Structures - Implements a thread-safe concurrent map data structure for multi-goroutine environments.
- Concurrent Shared-Map Access - Partitions the map into shards each with its own lock so multiple goroutines can read and write with minimal contention.
- Fine-Grained Locking - Implements per-shard locking to enable parallel reads and writes across independent map segments.
- Hash-Based Data Distribution - Uses a hash function to distribute keys across shards for balanced load and deterministic placement.
- Lock-Striped Sharding - Divides the map into independent segments each with its own lock to reduce contention during concurrent access.
- Lock-Striped Hash Maps - Implements a lock-striped hash map that reduces contention through fine-grained per-shard locking.
- Sharded Key-Value Stores - Partitions data into independent shards with per-shard locks for high-throughput concurrent access.
- Snapshot Iterations - Supports snapshot-based iteration allowing safe traversal of all entries while concurrent modifications occur.
- Key-Value Store Iterators - Walks through all key-value pairs in the map using a callback function while maintaining thread safety.
- Concurrent Map Iterators - Walks every key-value pair in the map while other goroutines continue to modify it using a snapshot or lock-per-shard strategy.
- Parallel Shard Reads and Writes - Enables simultaneous reads and writes across different map shards to avoid global lock contention.
- Lock-Free Read Paths - Provides a lock-free read path that allows concurrent reads without blocking other shard operations.
- Sharded Maps - Shards a map into segments with independent locks to reduce contention and boost concurrent throughput.
- Development Utilities - Concurrent-safe map implementation.
