awesome-repositories.com
Blog
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoAcerca deCómo clasificamosPrensaServidor MCP
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
cameron314 avatar

cameron314/readerwriterqueue

0
View on GitHub↗
4,576 estrellas·731 forks·C++·2 vistas

Readerwriterqueue

Este proyecto es una cola concurrente de productor único y consumidor único para C++ diseñada para el intercambio de datos sin bloqueos (lock-free) entre hilos. Proporciona un mecanismo seguro para hilos (thread-safe) para transferir datos sin el uso de mutexes o bloqueos.

La cola está implementada como un buffer circular contiguo que admite un crecimiento dinámico de capacidad para evitar la pérdida de datos cuando la cola alcanza su límite. Utiliza sincronización atómica y gestión de índices sin espera (wait-free) para coordinar el acceso a los datos entre los hilos de escritura y lectura.

La librería cubre la comunicación entre hilos y la gestión de buffers, ofreciendo operaciones de extracción (dequeue) tanto bloqueantes como no bloqueantes para gestionar cómo los hilos consumidores esperan nuevos datos.

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.

Historial de estrellas

Gráfico del historial de estrellas de cameron314/readerwriterqueueGráfico del historial de estrellas de cameron314/readerwriterqueue

Búsqueda con IA

Explora más repositorios increíbles

Describe lo que necesitas en lenguaje sencillo: la IA clasifica miles de proyectos open-source curados por relevancia.

Start searching with AI

Preguntas frecuentes

¿Qué hace cameron314/readerwriterqueue?

Este proyecto es una cola concurrente de productor único y consumidor único para C++ diseñada para el intercambio de datos sin bloqueos (lock-free) entre hilos. Proporciona un mecanismo seguro para hilos (thread-safe) para transferir datos sin el uso de mutexes o bloqueos.

¿Cuáles son las características principales de cameron314/readerwriterqueue?

Las características principales de cameron314/readerwriterqueue son: 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.

¿Qué alternativas de código abierto existen para cameron314/readerwriterqueue?

Las alternativas de código abierto para cameron314/readerwriterqueue incluyen: 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…

Alternativas open-source a Readerwriterqueue

Proyectos open-source similares, clasificados según cuántas características comparten con Readerwriterqueue.
  • cameron314/concurrentqueueAvatar de cameron314

    cameron314/concurrentqueue

    12,070Ver en 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++
    Ver en GitHub↗12,070
  • workiva/go-datastructuresAvatar de Workiva

    Workiva/go-datastructures

    7,901Ver en 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
    Ver en GitHub↗7,901
  • ruby-concurrency/concurrent-rubyAvatar de ruby-concurrency

    ruby-concurrency/concurrent-ruby

    5,830Ver en 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
    Ver en GitHub↗5,830
  • jctools/jctoolsAvatar de JCTools

    JCTools/JCTools

    3,851Ver en 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
    Ver en GitHub↗3,851
  • Ver las 30 alternativas a Readerwriterqueue→