Skip to content

Concurrent collections and synchronization primitives for writing fast multithreaded and asynchronous code

License

Notifications You must be signed in to change notification settings

epeshk/ConcurrencyToolkit

Repository files navigation

ConcurrencyToolkit

Concurrent collections and synchronization primitives for writing fast multithreaded and asynchronous code. This library is experimental and provided without warranty, so use it carefully.

Features

  • lockless semaphores
  • priority semaphore
  • lockless object and array pools
  • memory compact single writer multiple readers hash map
  • memory compact thread safe (but locked) hash map
  • write optimized lock-free counter

Types

ConcurrencyToolkit.Synchronization

  • QueueSemaphore: uses ConcurrentQueue to order waiters
  • StackSemaphore: uses ConcurrentStack to order waiters
  • SimpleSegmentSemaphore: uses segment queue to order waiters (similar to the Semaphore from kotlinx.coroutines)
  • SegmentSemaphore: uses segment queue with support of early removal of cancelled waiters
  • PrioritySemaphore: lock-based semaphore (like SemaphoreSlim), but releases waiters in specified priority

ConcurrencyToolkit.Pooling

  • LocklessArrayPool<T>.Shared: similar to ArrayPool<T>.Shared but uses bounded concurrent queue instead of lock protected arrays to store pooled items.
  • IObjectPool<T>, ObjectPool<T>

ConcurrencyToolkit.Collections

  • SingleWriterDictionary<TKey, TValue, TComparer>: memory-compact hash map that supports single writer and multiple readers simultaneously. Writes are lock-free (except for resizes, which may trigger GC), but reads may be retried when a parallel update occurs.
  • StripedDictionary<TKey, TValue, TComparer>: memory-compact hash map, designed to avoid ConcurrentDictionary GC overhead. It is not general purpose ConcurrentDictionary replacement, and generally is slower, especially for reads.
  • DefaultComparer<TKey>: default comparer for ConcurrencyToolkit hash maps
  • ComparerWrapper<TKey>: struct wrapper over the reference type comparer

ConcurrencyToolkit.Metrics

  • ThreadSafeCounter64: scalable atomic counter that distributes writes across per-core variables

ConcurrencyToolkit.Threading

  • InterlockedFloatingPoint: methods for atomic floating point arithmetics
  • LowLatencySpinWait: SpinWait implementation that achieves low latency (~0.5ms) on sleeps instead of standard 15ms

About

Concurrent collections and synchronization primitives for writing fast multithreaded and asynchronous code

Resources

License

Stars

Watchers

Forks

Packages

No packages published

Languages