Asynchrony refers to the occurrence [and handling] of events independent of the main program flow. These may be outside events such as the arrival of signals, or [non-blocking] actions instigated by a program that take place concurrently with program execution.
In which we put some fears about thread-safety to the test, and to rest.
In this episode, we'll move logging into a dedicated, low-priority thread.
In previous episodes, we got the Tapas::Queue class under test, using a couple of different thread-testing techniques. Now that it has tests, it's time to refactor. The steps of this …
Today's episode introduces the concept of thread-local variables, and shows how they can be put to use in an ActiveRecord-like library.
In this episode we'll explore a novel technique for testing multithreaded code. The lockstep library can be found here: https://github.com/avdi/lockstep
Working with threads is hard enough, but getting them under test is even trickier. In this episode we start to look at techniques for verifying the logic of multithreaded code.
Continuing with the general theme of threads and concurrency, today we look at another pattern for splitting up work in parallel.
In this episode we finally discover why the Timeout module is unsafe, and a facility new in Ruby 2.0 that makes dealing with thread interruptions much less error-prone.
We continue to evolve our thread-safe queue implementation. Today, we add the ability to set a bound on the queue size.