Programming: Concurrency Patterns

Resources

Wikipedia: Concurrency Patterns

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

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)

Monitor Object

Safely share an object between multiple threads,
wait in any caller until the original perform is done (ensuring only one task is ever performed with this object ata time).
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 one thread performing IO on a file at any given time
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

# thread-1 #    # worker-thread #  # thread-2 #
proxy.call() >--------+
                   (start)
                      |   +-------< proxy.call()
                      | (wait)
    (result) <--------+   |
                        (start)
                          |
                          +-------> (result)

Active Object

Safely share an object between threads,
each method call on a proxy-object enqueues an execution in a separate thread.
Unlike Monitor Object, method can be enqueued several times (does not block on perform)
Also unlike Monitor Object, you may choose to perform tasks in a different order than they were enqueued.
Hides the lock/queue logic from the caller.

examples:

• update a progressbar in the UI thread from a background thread
• Qt's signals/slots are an expansion of this pattern

Overview:

• 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

# bg-thread
class Proxy           # (ActiveObject) methods that will run in sep thread
class Future          # waitable object, will obtain result when performed

# ui-thread
class Queue           # holds method requests
class Scheduler       # (EventLoop) chooses next method request to run

Reactor Pattern

The reactor pattern is similar to ActiveObject,
except it lets you add and define handlers to each event type.

examples:

• logging frameworks that send logs to various outputs
• Qt's signals/slots are a variation of this pattern

# The reactor is your eventloop.
# It handles emitted events
#
# This should be a singleton
class Reactor:
    def __init__(self):
        self._queue = queue.Queue()

    def send_event(self, event):
        self._queue.put(event)

    def register(self, handler):
        self._handlers.append(handler)

    def handle_events(self):
        while True:
            event = self._queue.get(timeout=0)
            if event is not None:
                self._dispatch(event)

    def _dispatch(self, event):
        for handler in self._handlers:
            handler.handle(event)

# Events are things that happen
class Event:
class MouseclickEvent(Event):
class KeypressEvent(Event):

# EventHandlers decide if they will handle an event
class EventHandler:
    def handle(self, event):
        pass
class KeypressHandler(EventHandler):
class MouseclickHandler(EventHandler):

Sample Usage

# thread-1
reactor = Reactor()
reactor.register(KeypressHandler())
reactor.register(MouseclickHandler())
reactor.handle_events()

# thread-2
reactor = Reactor()
reactor.send_event(KeypressEvent("a"))

# thread-1 handles the event

http://www.dre.vanderbilt.edu/~schmidt/PDF/reactor-siemens.pdf

Scheduler

See https://en.wikipedia.org/wiki/Scheduling_(computing)