Concurrency Patterns


This was once a dreaded paradigm, that only the experts used with extreme caution. Today, concurrency is an integral part of most applications. Naturally, everyone cannot (and should not) reinvent the wheel for implementing a concurrent system. Over the years, some common design patterns have emerged and these are borrowed by most designers. Here are some of the important concurrency patterns.

  • Active Object - Decouples method execution from method invocation that reside in their own thread of control. The goal is to introduce concurrency, by using asynchronous method invocation and a scheduler for handling requests.
  • Balking - Only execute an action on an object when the object is in a particular state.
  • Binding properties - Combining multiple observers to force properties in different objects to be synchronized or coordinated in some way.
  • Blockchain - Decentralized way to store data and agree on ways of processing it in a Merkle tree, optionally using digital signature for any individual contributions.
  • Compute kernel - The same calculation many times in parallel, differing by integer parameters used with non-branching pointer math into shared arrays, such as GPU-optimized Matrix multiplication or Convolutional neural network.
  • Event-based asynchronous - Addresses problems with the asynchronous pattern that occur in multithreaded programs.
  • Guarded suspension - Manages operations that require both a lock to be acquired and a precondition to be satisfied before the operation can be executed.
  • Join - Join-pattern provides a way to write concurrent, parallel and distributed programs by message passing. Compared to the use of threads and locks, this is a high-level programming model.
  • Lock - One thread puts a "lock" on a resource, preventing other threads from accessing or modifying it.
  • Messaging design pattern (MDP) - Allows the interchange of information (i.e. messages) between components and applications.
  • Monitor object - An object whose methods are subject to mutual exclusion, thus preventing multiple objects from erroneously trying to use it at the same time.
  • Reactor - A reactor object provides an asynchronous interface to resources that must be handled synchronously.
  • Read-write lock - Allows concurrent read access to an object, but requires exclusive access for write operations.
  • Scheduler - Explicitly control when threads may execute single-threaded code.
  • Thread pool - A number of threads are created to perform a number of tasks, which are usually organized in a queue. Typically, there are many more tasks than threads. Can be considered a special case of the object pool pattern.
  • Thread-specific storage - Static or "global" memory local to a thread.