awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
cameron314 avatar

cameron314/readerwriterqueue

0
View on GitHub↗

Readerwriterqueue

This project is a single-producer single-consumer concurrent queue for C++ designed for lock-free data exchange between threads. It provides a thread-safe mechanism to transfer data without the use of mutexes or locks.

The queue is implemented as a contiguous circular buffer that supports dynamic capacity growth to prevent data loss when the queue reaches its limit. It utilizes atomic synchronization and wait-free index management to coordinate data access between the writing and reading threads.

The library covers inter-thread communication and buffer management, offering both blocking and non-blocking dequeue operations to manage how consuming threads wait for new data.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Single-Producer Single-Consumer Queues - Implements a specialized single-producer single-consumer model to eliminate contention and minimize synchronization overhead.
  • Lock-Free Thread Communication - Provides high-performance primitives for transferring data between threads without the overhead of mutex locking.
  • Thread-Safe Communication Channels - Offers a high-performance C++ data structure for safe information passing between concurrent threads.
  • Circular Memory Buffers - Uses a ring-based memory layout to efficiently reuse space for data exchange between threads.
  • Contiguous Memory Buffers - Allocates elements in flat, contiguous memory blocks to optimize cache locality and reduce latency.
  • Lock-Free - Employs atomic primitives and memory barriers to ensure thread-safe data exchange without mutex locks.
  • Buffer Capacity Growth - Supports dynamic allocation of larger contiguous blocks when the queue reaches capacity to prevent data loss.
  • Wait-Free Synchronization - Manages head and tail indices using atomic integers to guarantee progress for both producer and consumer.
  • Dynamic Buffer Management - Manages queue elements by combining upfront memory reservation with dynamic capacity expansion.
  • Low Latency Messaging - Minimizes message delivery delay between threads by avoiding traditional mutex synchronization.
  • Inter-Thread Buffer Management - Handles data streams between threads using a contiguous memory buffer that grows as demand increases.
  • Blocking Synchronization - Implements mechanisms to suspend consumer threads until the producer adds new data to the queue.
  • Concurrency and Parallelism - Fast single-producer single-consumer lock-free queue.
4,576 stars·731 forks·C++·12 views

Star history

Star history chart for cameron314/readerwriterqueueStar history chart for cameron314/readerwriterqueue

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does cameron314/readerwriterqueue do?

This project is a single-producer single-consumer concurrent queue for C++ designed for lock-free data exchange between threads. It provides a thread-safe mechanism to transfer data without the use of mutexes or locks.

What are the main features of cameron314/readerwriterqueue?

The main features of cameron314/readerwriterqueue are: Single-Producer Single-Consumer Queues, Lock-Free Thread Communication, Thread-Safe Communication Channels, Circular Memory Buffers, Contiguous Memory Buffers, Lock-Free, Buffer Capacity Growth, Wait-Free Synchronization.

Which projects share features with cameron314/readerwriterqueue?

Projects with overlapping indexed features include: cameron314/concurrentqueue — ConcurrentQueue is a header-only C++ template library that provides a lock-free data structure for multi-producer… workiva/go-datastructures — go-datastructures is a collection of thread-safe and lock-free data structures designed for high-performance… ruby-concurrency/concurrent-ruby — Concurrent Ruby is a comprehensive concurrency toolkit for the Ruby language that provides thread-safe data… jctools/jctools — JCTools is a Java concurrency library providing a collection of lock-less and wait-free data structures. It serves as… coocood/freecache — freecache is a high-performance, concurrent in-memory key-value store library for Go applications. It functions as a… dpilger26/numcpp — NumCpp is a C++ framework and numerical computing library that provides a toolkit for multi-dimensional array…

Projects sharing features with Readerwriterqueue

These projects share indexed features with Readerwriterqueue. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • cameron314/concurrentqueuecameron314 avatar

    cameron314/concurrentqueue

    12,070View on GitHub↗

    ConcurrentQueue is a header-only C++ template library that provides a lock-free data structure for multi-producer multi-consumer thread communication. It functions as a synchronization primitive designed to coordinate data flow between concurrent execution units using atomic operations rather than traditional mutex locking. The library distinguishes itself through a design that minimizes contention and synchronization overhead. It utilizes sub-queue token mapping to distribute workloads across partitioned internal queues and supports bulk operations to transfer multiple data elements in singl

    C++
    View on GitHub↗12,070
  • workiva/go-datastructuresWorkiva avatar

    Workiva/go-datastructures

    7,901View on GitHub↗

    go-datastructures is a collection of thread-safe and lock-free data structures designed for high-performance concurrent applications in Go. It provides a modular library of specialized algorithmic toolsets, including a lock-free collection library and an immutable data structure library. The project distinguishes itself through a suite of persistent AVL trees and hash array mapped tries that use branch-copying to preserve previous versions. It also implements non-blocking hash maps, queues, and tries that enable linearizable snapshots and concurrent updates without the use of mutual exclusion

    Go
    View on GitHub↗7,901
  • ruby-concurrency/concurrent-rubyruby-concurrency avatar

    ruby-concurrency/concurrent-ruby

    5,830View on GitHub↗

    Concurrent Ruby is a comprehensive concurrency toolkit for the Ruby language that provides thread-safe data structures, synchronization primitives, and asynchronous execution patterns. It implements core concurrency abstractions including an actor model framework where isolated actors communicate through asynchronous message passing, a future and promise system for composing non-blocking operations, and thread pool executors that manage reusable worker threads for concurrent task execution. The library distinguishes itself through a broad set of coordination mechanisms that go beyond basic th

    Ruby
    View on GitHub↗5,830
  • jctools/jctoolsJCTools avatar

    JCTools/JCTools

    3,851View on GitHub↗

    JCTools is a Java concurrency library providing a collection of lock-less and wait-free data structures. It serves as a toolkit for managing thread-safe data exchange, specifically designed to optimize high-throughput messaging and producer-consumer patterns in multi-threaded applications. The library distinguishes itself by implementing specialized queue structures that minimize contention and maximize throughput. By utilizing techniques such as cache-line padding, memory-barrier-based synchronization, and relaxed-consistency memory ordering, it avoids the performance bottlenecks often assoc

    Javaawesomebenchmarksconcurrency
    View on GitHub↗3,851
    • Compare all 30 related projects→