Programming: Concurrency Patterns

Resources

Wikipedia: Concurrency Patterns

https://en.wikipedia.org/wiki/Concurrency_pattern

Monitor Object

Safely share an object between multiple threads,
automatically wait in caller until a perform is done.
The caller does not need to know about the perform-lock, it will simply block until the monitor is able to process a new task.

Say we only ever want to perform IO from one thread.
We create a WriterMonitor, which might have methods read/write

• in thread-1, we call read(), which blocks while in the background creates and performs a thread
• in thread-2, we call write(), it will automatically block until thread-1's read() call is finished, then it will take lock and write()

https://www.youtube.com/watch?v=_p-TM1x48zk

Active Object

Safely share an object between threads,
each method call on a proxy-object triggers an execution in a separate thread.
Hides the lock/queue logic from the caller.

ex. update a progressbar in the UI thread from a background thread

• Background thread instantiates a proxy object
• On a method call, the proxy returns a Future/Promise (a request is enqueued to UI thread)
• The UI thread eventually performs the task
• You may wait/join on the Future/Promise to wait for it to return it's results

https://www.youtube.com/watch?v=U9Tf7h-etl0

Producer/Consumer

Safely parallelized task enqueueing/execution.

• A producer adds data to a synchronized queue
• A variable number of consumers process data from a synchronized queue in a loop
• When producer is finished, send a poison pill for each worker, informing it to break/exit the loop gracefully
• Join on worker threads (wait to close)