Threading

A high performance, thread-safe reservoir sampler with snapshot and percentile support.

Mailbox is a JRuby module that simplifies concurrency and is backed by JVM threads.

Thread Worker for SOAR architecture providing basic thread operations

A job scheduler which runs jobs each in their own thread in a persistent process.

CommandSet is a user interface framework. Its focus is a DSL for defining commands, much like Rake or RSpec. A default readline based terminal interpreter (complete with context sensitive tab completion, and the amenities of readline: history editing, etc) is included. It could very well be adapted to interact with CGI or a GUI - both are planned. CommandSet has a lot of very nice features. First is the domain-specific language for defining commands and sets of commands. Those sets can further be neatly composed into larger interfaces, so that useful or standard commands can be resued. Optional application modes, much like Cisco's IOS, with a little bit more flexibility. Arguments have their own sub-language, that allows them to provide interface hints (like tab completion) as well as input validation. On the output side of things, CommandSet has a very flexible output capturing mechanism, which generates a tree of data as it's generated, even capturing writes to multiple places at once (even from multiple threads) and keeping everything straight. Methods that normally write to stdout are interposed and fed into the tree, so you can hack in existing scripts with minimal adjustment. The final output can be presented to the user in a number of formats, including contextual coloring and indentation, or even progress hashes. XML is also provided, although it needs some work. Templates are on the way. While you're developing your application, you might find the record and playback utilities useful. cmdset-record will start up with your defaults for your command set, and spit out an interaction script. Then you can replay the script against the live set with cmdset-playback. Great for ad hoc testing, usability surveys and general demos.

open5(cmd, *option) #=> stdin, stdout, stderr, thread

Timeouter is advisory timeout helper without any background threads.

Thread-safe semanticaly-defined IoC/DI Container

promise_pool is a promise implementation backed by threads or threads pool.

Helps you creating and managing daemon threads with Ruby.

A simple lib for downloading pictures from web pages. It can get and parse page with different options and receive images from specified locations. It is possible to download images simultaneously in multiple threads or sequentially. In fact, it's picture downloader or picture grabber from web pages, which allows you to download photos (.jpg, .jpeg, .png, .gif, .ico, .svg, .bmp) and not only them.

Ruck uses continuations and a simple scheduler to ensure "shreds" (Ruck threads) are woken at precisely the right time according to its virtual clock. Schedulers can map virtual time to samples in a WAV file, real time, time in a MIDI file, or anything else by overriding "sim_to" in the Shreduler class. A small library of useful unit generators and plenty of examples are provided. See the README or the web page for details.

A Free Software, multi-threaded, non-blocking network application server designed for low _idle_ power consumption. It is primarily optimized for applications with occasional users which see little or no traffic. yahns currently hosts Rack/HTTP applications, but may eventually support other application types. Unlike some existing servers, yahns is extremely sensitive to fatal bugs in the applications it hosts.

Throttler rate-limits code execution across threads or processes.

slack-rtmapi is dumb: no EventMachine, no Celluloid, no Actor design pattern, no thread pool (thought, any of those would be trivial to add). It's a simple blocking loop on top of a SSL socket with a websocket decoder. Minimal dependency. Works out of the box. Hackable. Composable. Oh, by the way, it implements very well the Slack API.

Fiber-based generic connection pool for Ruby, allowing non-blocking IO behaviour on the same thread as provided by EventMachine or Celluloid.

ruby samba client, interactive smbclient commands session and multi-threaded smb transfer queued mode

Lightweight framework for functional testing. Supports threading, scenario parametrization, different test environments and much more.

Standard facebook-style messaging system. Not bound to any friendship structure. Integrates directly into your User model. Allows for users to comment on a thread, leave a thread, and be updated when a thread is commented on.

Simple thread pool with timeouts, default values, error handling, state tracking and unit tests.

ThreadParent facilitates spawning threads that maintain a reference to the thread that created them. The primary goal is to allow thread local variable lookup through the ancestor chain.

An in-memory implementation of RDF::Repository using an efficient, immutable, and thread-safe Hash.

Implemented for academic purpose, Gimuby is also suitable for teaching purpose. As far as we know this implementation of genetic algorithms is the most advanced available in Ruby for itintegrates an implementation of the island model, reusable patterns for user problem composition and optimal configuration genetic algorithm Gimuby contains the implementation of standard genetic algorithm (named population) and distributed genetic algorithm or island model (named archipelago). The presented archipelago are NOT distributed (nor with threads, processes, or physical machines). However they let the user benefits ofthe leverage they represent to obtain a better solution with the same amount of resources spent. Similar to: AI4R, gga4r and darwinning

A thread-safe rate-limited work queue, which allows for background and foreground operations.

Downloads BLAST databases from NCBI. Database files (volumes) are downloaded in parallel; number of threads to use is determined automatically. Database files are verified and extracted upon download.

A threadded web/app-server that focuses on threadding, shared ressources, speed and more.

Shamrock helps you to use stub services in your application by starting a rack service in a Thread

Threaded SNMP poll based network discovery. Devices are stored in SQL

Run a block of code in multiple threads. Similar to threach, but with the ability to deal with breaks/exceptions (MRI can't because of unreliable timeouts).

Execute multithreaded code while still using transactional fixtures by synchronizing db access to a single connection

The win32-semaphore library provides an interface to semaphore objects on MS Windows. A semaphore is a kernel object used for resource counting. This allows threads to query the number of resources available, and wait if there aren't any available.

v is for versioned. It's is currently only a threaded wrapper for the git commands or procedures. In the future it should provide a generic interface for diverse VCSs.

EventMachine implements a fast, single-threaded engine for arbitrary network communications. It's extremely easy to use in Ruby. EventMachine wraps all interactions with IP sockets, allowing programs to concentrate on the implementation of network protocols. It can be used to create both network servers and clients. To create a server or client, a Ruby program only needs to specify the IP address and port, and provide a Module that implements the communications protocol. Implementations of several standard network protocols are provided with the package, primarily to serve as examples. The real goal of EventMachine is to enable programs to easily interface with other programs using TCP/IP, especially if custom protocols are required.

Allows Thread to carry context from ancestors.

Provides an object or module to use safely by more than one thread

For tasks that can be started early and evaluated late. Typically one might want start multiple heavy tasks concurrent. This is already solvable with threads or the [reactor-pattern](http://rubyeventmachine.com/) but setting this up could be cumbersome or require direct interactions with threads ex. Dunder is a simple way of abstracting this: you simply pass a block to Dunder.load with the expected class as the argument

This gem is a Logstash plugin. It reads messages from Azure Service Bus Topics using multiple threads.

Tusk is a minimal pub / sub system with multiple observer strategies. Tusk builds upon the Observer API from stdlib in order to provide a mostly consistent API for building cross thread or process pub / sub systems. Currently, Tusk supports Redis and PostgreSQL as message bus back ends.

Wrap Ruby code with a minion so that it is run on a parallel thread

SSRF Proxy is a multi-threaded HTTP proxy server designed to tunnel client HTTP traffic through HTTP servers vulnerable to HTTP Server-Side Request Forgery (SSRF).

SamplingProf is a profiling tool that operates by sampling your running thread stacktrace. The result is statistical approximation, but it allows your code to run near full speed

A fast, thread-safe, simple, lightweight, batchable, sober interface to the bitcoind JSON-RPC api.

Threaded timer

Set a Timeout based on signals, which are more reliable than Timeout. Timeout is based on green threads.

Buildr extension to process bytecode using swung-weaver. Swung weaver is bytecode weaving of annotated UI classes to ensure all UI updates occur in the Event Dispatch Thread

Print TracePoint(:b_call, :b_return, :c_call, :c_return, :call, :return, :class, :end, :thread_begin, :thread_end) in tree view, to console or html

Grand Central Dispatch is natively implemented as a C API and runtime engine. This gem provides a MacRuby wrapper around that API and allows Ruby to very easily take advantage of GCD to run tasks in parrallel and do calculations asynchronously with queues automatically mapping to threads as needed.

RabbitMQ based single-thread worker

A mass mailing tool for real threads aficionados

Some tools to make concurrency in Ruby, like thread pools