What is concurrent-map?

orcaman/concurrent-map — explained in plain English

Analysis updated 2026-06-26

★ 4,529GoAudience · developerComplexity · 2/5LicenseSetup · easy

Mindmap

mindmap
  root((concurrent-map))
    What it does
      Thread-safe map
      Concurrent access
      Sharded storage
    Tech Stack
      Go
    Use Cases
      In-memory cache
      Concurrent services
      High-write stores
    API
      Set values
      Get values
      Remove entries

mindmap root((concurrent-map)) What it does Thread-safe map Concurrent access Sharded storage Tech Stack Go Use Cases In-memory cache Concurrent services High-write stores API Set values Get values Remove entries

Click or tap to explore — scroll the page freely

What do people build with it?

USE CASE 1

Replace Go's built-in map in any service that handles concurrent reads and writes from multiple goroutines

USE CASE 2

Build a high-throughput in-memory cache where many requests update the same data store simultaneously

USE CASE 3

Use as a better alternative to sync.Map when your app constantly updates and removes entries rather than just adding new ones

What is it built with?

How does it compare?

	orcaman/concurrent-map	faiface/pixel	beclab/olares
Stars	4,529	4,529	4,533
Language	Go	Go	Go
Setup difficulty	easy	moderate	hard
Complexity	2/5	2/5	4/5
Audience	developer	developer	ops devops

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · easy Time to first run · 5min

Use, modify, and distribute freely for any purpose including commercial use, as long as you keep the copyright notice.

So what is it?

When a program runs multiple tasks at the same time (called concurrency), those tasks sometimes try to read from and write to the same data structure simultaneously. Go's built-in map type, which is a basic key-value store, is not safe for this kind of simultaneous access. If two tasks try to modify it at the same time, the program can crash or produce wrong results. This repository provides a replacement map that is safe for concurrent use. It achieves good performance by splitting the data across multiple internal shards, so different tasks can often work on different shards at the same time without waiting on each other. This reduces the time tasks spend blocking, compared to a single lock that would stop all activity. Go's standard library added its own concurrent map type called sync.Map in version 1.9, but that version is designed mainly for scenarios where you mostly add new keys and rarely update existing ones. If your program behaves more like a small in-memory database, constantly updating and removing entries, this library is a better fit. The API is straightforward and closely mirrors what Go developers already know from using regular maps. You create a new map, call Set to store a value, Get to retrieve it, and Remove to delete it. The package is imported under the name cmap, and you install it with the standard Go toolchain command. The project is MIT-licensed and accepts contributions. The maintainers ask that contributors open an issue first to describe the change, include tests with any new code, and keep the library as simple and close to the native map behavior as possible.

Copy-paste prompts

Prompt 1

Show me how to use concurrent-map in Go to safely share a key-value store between multiple goroutines with Set, Get, and Remove

Prompt 2

I have a Go web server where multiple request handlers write to the same map, show me how to switch to concurrent-map (cmap)

Prompt 3

What is the difference between concurrent-map and Go's sync.Map, and when should I choose one over the other?

Prompt 4

Give me a Go example using cmap that stores user session data and handles concurrent reads and deletes safely

Frequently asked questions