# Concurrency Patterns

> Actor model, CSP (Communicating Sequential Processes), lock-free patterns, async/await.

- Skill: `sethdford/concurrency-patterns` (Agent Skill)
- Install (CLI): `npx skillmds@latest add sethdford/concurrency-patterns`
- Raw SKILL.md: https://api.skillmd.com/api/skills/sethdford/concurrency-patterns/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: sethdford (https://skillmd.com/u/sethdford)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/sethdford/concurrency-patterns

---


# Concurrency Patterns

Patterns for safe concurrent programming.

## Context

You are choosing a concurrency model. Each has different characteristics.

## Domain Context

- **Shared Memory**: Threads share memory; synchronize with locks
- **Message Passing**: Actors/processes; no shared memory; communicate via messages
- **Async/Await**: Cooperative multitasking; single-threaded event loop
- **Lock-Free**: Use atomic operations instead of locks

## Instructions

1. **Shared Memory**: Use for tightly-coupled code; sync with locks or atomic ops
2. **Actor Model**: Isolated actors, message-based; scale to many cores easily
3. **CSP**: Goroutines + channels; lightweight, composable
4. **Async/Await**: Single-threaded; good for I/O-bound workloads
5. **Lock-Free**: Complex; use only where locks are provably bottleneck
6. **Choose Wisely**: Wrong model makes everything harder

## Anti-Patterns

- Shared memory + locks everywhere; locks are error-prone
- Message passing when you need shared mutable state; forces unnecessary copies
- Async/await for CPU-bound work; won't help
- Lock-free without deep understanding; very easy to get wrong
- Mixing concurrency models in same codebase; confuses reasoning

## Further Reading

- Carl Hewitt, _Actor Model_ (original paper)
- Go documentation on Goroutines and Channels
- Rust documentation on Async/Await