Concurrency

Problem

printNumber(7) prints 7 to the console. You are given an instance of the ZeroEvenOdd class with 3 functions: zero outputs 0s, even outputs even numbers, and odd outputs odd numbers. The same ZeroEvenOdd instance is passed to three different threads, where thread A calls zero(), thread B calls even(), and thread C calls odd(). Modify ZeroEvenOdd such that given n=6, it outputs 010203040506.

Solution

Use a Condition to pass the baton between zero, even, and odd. I had trouble setting up the correct loop-exit conditions. Debugging deadlocks takes some getting used to!

Problem Statement

You’re given the FooBar class:

class FooBar:
  def __init__(self, n):
    self.n = n

  def foo(self, printFoo: "Callable[[], None]") -> None:
    for _ in range(self.n):
      printFoo()

  def bar(self, printBar: "Callable[[], None]") -> None:
    for _ in range(self.n):
      printBar()

… and the same instance of FooBar will be passed to two different threads. Thread A will call foo() while thread B will call bar(). Modify the program to output foobar n times.

Solution

Two Events

We can use two Events to communicate whose turn it is to print.

from threading import Event
from typing import Callable


class FooBar:
    def __init__(self, n):
        self.n = n
        self.foos_turn = Event()
        self.bars_turn = Event()
        self.foos_turn.set()

    def foo(self, printFoo: "Callable[[], None]") -> None:
        for _ in range(self.n):
            self.foos_turn.wait()
            printFoo()
            self.foos_turn.clear()
            self.bars_turn.set()

    def bar(self, printBar: "Callable[[], None]") -> None:
        for _ in range(self.n):
            self.bars_turn.wait()
            printBar()
            self.bars_turn.clear()
            self.foos_turn.set()

Suppose we have a class:

public class Foo {
  public void first() { print("first"); }
  public void second() { print("second"); }
  public void third() { print("third"); }
}

… and the same instance of Foo is passed to three different threads. Thread A will call first(), thread B will call second() and thread C will call third(). Design Foo such that second() is executed after first(), and third() is executed after second().

See Thread-Based Parallelism - Python for a quick primer on Python’s synchronization primitives.