Fifo queue with concurrency control
Async batched concurrent queue
Multifunctional Asynchronous Concurrent Queue
concurrent queue
Concurrent queue pattern implementation for resilience4ts.
concurrent queue
retry, concurrent, queue
"ConcurrentQueue" organizes promises execution
Promise based asynchronous concurrent queue with the rate limiting
concurrent queue
Tiny queue data structure
Useful TypeScript utilities.
fast, tiny `queueMicrotask` shim for modern engines
Better Queue for NodeJS
An efficient queue capable of managing thousands of concurrent animations.
utilities for observable asynchronous control flow
asynchronous function queue with adjustable concurrency
Better Stack JavaScript logging tools (formerly Logtail)
A shim for the setImmediate efficient script yielding API
Promise queue with concurrency control
The smallest and simplest JavaScript priority queue
A simple, dependency-free library for concurrent promise-based queues. Comes with with concurrency and timeout control.
A simple tool to keep requests to be executed in order.
"ConcurrentQueue" organizes promises execution
Concurrent multi-producer multi-consumer queue
ShardedQueue is currently the fastest concurrent collection which can be used under highest concurrency and load
Lock-free unbounded MPMC queue backed by a linked ring of fixed-size blocks.
Modular HTTP server library, threaded handlers and async performance
Backend library for the Applin™ Server-Driven UI framework
This library was renamed to Servlin.
A lock-free multi-producer multi-consumer unbounded queue.
A tool to check crates are up to date.
A small and fast async runtime
This crate provides a concurrent queue which you can key on like a HashMap.
A high performance and convenient thread safe queue that can concurrently grow and shrink with push, extend, pop and pull capabilities.
Listen to multiple queues concurrently and return the value of the first queue to have an item pushed to it.
A lightweight, zero-dependency, thread-safe in-process async job queue with configurable concurrency for Ruby applications.
Quiq is a distributed task queue backed by Redis to process jobs in background. It relies on asynchronous IOs to process multiple jobs simultaneously. The event loop is provided by the Async library and many other gems of the Socketry family.
Thread-safe queue and stack data structures with configurable capacity limits, blocking enqueue/dequeue with timeouts, and peek operations. Uses Mutex and ConditionVariable for safe concurrent access.
A locking mechanism. Builds queue of concurrent code blocks using Redis.
DispatchQueueRb is a pure ruby implementation of Grand Central Dispatch concurrency primitives. It implements serial and concurrent queues, with synchronous, asynchronous, barrier and delayed dispatch methods. All queues dispatch methods support an optional dispatch groups to synchronize on completion of a group of tasks. It also provides a thread pool based concurrent queue, scaled to the number of available cpu cores, and used by default to schedule the actual work.
Thimble is a ruby gem for parallelism and concurrency. It allows you to decide if you want to use separate processes, or if you want to use threads in ruby. It allows you to create stages with a thread safe queue, and break apart large chunks of work.
A production-ready Sidekiq gem that provides both queue-level concurrency limits and job-level throttling capabilities, combining the best of sidekiq-limit_fetch and sidekiq-throttled.
a lightweight background processor
This is the official Ruby client for the Zizq job queue server. Zizq is a simple, single binary, zero dependency, language agnostic job queue. Features: - Enqueue and process jobs across programming languages - Persistent/journalled - Multi-thread and/or multi-fiber - Scheduled jobs - Prioritized queues - Optional ActiveJob integration - Unique jobs - Cron scheduling (recurring jobs) - Job introspection and management, including `jq` filters This client supports multi-threaded and/or multi-fiber concurrency and is very fast. The Zizq server provides everything needed. There are no separate external storage dependencies to configure such as Redis or a RDBMS. See https://zizq.io for full details and documentation.
A lightweight async message bus built on the async gem with fiber-only concurrency. Provides typed pub/sub channels with explicit acknowledgment, dead letter queues, bounded backpressure, delivery timeout tracking, and per-channel statistics.
ALPHA Alert -- just uploaded initial release. Linux inotify is a means to receive events describing file system activity (create, modify, delete, close, etc). Sinotify was derived from aredridel's package (http://raa.ruby-lang.org/project/ruby-inotify/), with the addition of Paul Boon's tweak for making the event_check thread more polite (see http://www.mindbucket.com/2009/02/24/ruby-daemons-verifying-good-behavior/) In sinotify, the classes Sinotify::PrimNotifier and Sinotify::PrimEvent provide a low level wrapper to inotify, with the ability to establish 'watches' and then listen for inotify events using one of inotify's synchronous event loops, and providing access to the events' masks (see 'man inotify' for details). Sinotify::PrimEvent class adds a little semantic sugar to the event in to the form of 'etypes', which are just ruby symbols that describe the event mask. If the event has a raw mask of (DELETE_SELF & IS_DIR), then the etypes array would be [:delete_self, :is_dir]. In addition to the 'straight' wrapper in inotify, sinotify provides an asynchronous implementation of the 'observer pattern' for notification. In other words, Sinotify::Notifier listens in the background for inotify events, adapting them into instances of Sinotify::Event as they come in and immediately placing them in a concurrent queue, from which they are 'announced' to 'subscribers' of the event. [Sinotify uses the 'cosell' implementation of the Announcements event notification framework, hence the terminology 'subscribe' and 'announce' rather then 'listen' and 'trigger' used in the standard event observer pattern. See the 'cosell' package on github for details.] A variety of 'knobs' are provided for controlling the behavior of the notifier: whether a watch should apply to a single directory or should recurse into subdirectores, how fast it should broadcast queued events, etc (see Sinotify::Notifier, and the example in the synopsis section below). An event 'spy' can also be setup to log all Sinotify::PrimEvents and Sinotify::Events. Sinotify::Event simplifies inotify's muddled event model, sending events only for those files/directories that have changed. That's not to say you can't setup a notifier that recurses into subdirectories, just that any individual event will apply to a single file, and not to its children. Also, event types are identified using words (in the form of ruby :symbols) instead of inotify's event masks. See Sinotify::Event for more explanation. The README for inotify: http://www.kernel.org/pub/linux/kernel/people/rml/inotify/README Selected quotes from the README for inotify: * "Rumor is that the 'd' in 'dnotify' does not stand for 'directory' but for 'suck.'" * "The 'i' in inotify does not stand for 'suck' but for 'inode' -- the logical choice since inotify is inode-based." (The 's' in 'sinotify' does in fact stand for 'suck.')
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.