Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more. Inspired by Erlang, Clojure, Go, JavaScript, actors, and classic concurrency patterns.

A collection of data structures and utilities to make thread-safe programming in Ruby easier

Puma is a simple, fast, multi-threaded, and highly parallel HTTP 1.1 server for Ruby/Rack applications. Puma is intended for use in both development and production environments. It's great for highly parallel Ruby implementations such as JRuby and TruffleRuby as well as as providing process worker support to support CRuby well.

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.

Manages persistent connections using Net::HTTP including a thread pool for connecting to multiple hosts. Using persistent HTTP connections can dramatically increase the speed of HTTP. Creating a new HTTP connection for every request involves an extra TCP round-trip and causes TCP congestion avoidance negotiation to start over. Net::HTTP supports persistent connections with some API methods but does not make setting up a single persistent connection or managing multiple connections easy. Net::HTTP::Persistent wraps Net::HTTP and allows you to focus on how to make HTTP requests.

You probably meant `gem install thread_safe`.

Efficient, immutable, thread-safe collection classes for Ruby

Ruby bindings to RE2, "a fast, safe, thread-friendly alternative to backtracking regular expression engines like those used in PCRE, Perl, and Python".

A simple, fast, memory-efficient and threadsafe implementation of GetText

Shoryuken is a super efficient AWS SQS thread based message processor

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.

Setup signal handler which dumps backtrace of running threads and number of allocated objects per class. Require 'sigdump/setup', send SIGCONT, and see /tmp/sigdump-<pid>.log.

Thread-safety checks via static analysis. A plugin for the RuboCop code style enforcing & linting tool.

Polymorphic threaded comments Rails gem for Rails 4+

Efficient and thread-safe LRU cache

Memoize attributes in a thread-safe way. This ruby gem adds a `#attr_memoized` class method, that provides a lazy-loading mechanism for initializing "heavy" attributes, but in a thread-safe way. Instances thus created can be shared among threads.

Implements a thread based worker pattern on top of JRuby-Rack. Useful if you'd like to run background workers within your (deployed) web-application, concurrently in 'native' threads, instead of using separate daemon processes. Provides (thread-safe) implementations for popular worker libraries such as Resque and Delayed::Job, but one can easily write their own 'daemon' work processing loop as well.

Emulates Python threading API paradigm. Creating threads by giving some block to constructor is sometime slightly unpractical way of running threads. This library allows encapsulating threads to classes, so class can define itself as thread which can be run by plain method call.

LazyData provides data types featuring thread-safe lazy computation. These objects are constructed with a block that can be called to compute the final value, but it is not actually called until the value is requested. Once requested, the computation takes place only once, in the first thread that requested the value. Future requests will return a cached value. Furthermore, any other threads that request the value during the initial computation will block until the first thread has completed the computation. This implementation also provides retry and expiration features. The code was extracted from the google-cloud-env gem that originally used it.

Threadsafety overrides attr_accessor and attr_writer to generate thread-safe setters. It also provides a helper method to add threadsafety anywhere, even outside classes.