• If the number is divisible by 3, output “fizz”.
• If the number is divisible by 5, output “buzz”.
• If the number is divisible by both 3 and 5, output “fizzbuzz”.

For example, for n = 15, we output: 1, 2, fizz, 4, buzz, fizz, 7, 8, fizz, buzz, 11, fizz, 13, 14, fizzbuzz.

Suppose you are given the following code:

class FizzBuzz {
  public FizzBuzz(int n) { ... }               // constructor
  public void fizz(printFizz) { ... }          // only output "fizz"
  public void buzz(printBuzz) { ... }          // only output "buzz"
  public void fizzbuzz(printFizzBuzz) { ... }  // only output "fizzbuzz"
  public void number(printNumber) { ... }      // only output the numbers
}

Implement a multithreaded version of FizzBuzz with four threads. The same instance of FizzBuzz will be passed to four different threads:

1. Thread A will call fizz() to check for divisibility of 3 and outputs fizz.
2. Thread B will call buzz() to check for divisibility of 5 and outputs buzz.
3. Thread C will call fizzbuzz() to check for divisibility of 3 and 5 and outputs fizzbuzz.
4. Thread D will call number() which should only output the numbers.

Solution:

4 Semaphores

// Author: Huahua
class Semaphore {
public:
  Semaphore (int count = 0): count_(count) {}

  inline void notify() {
    unique_lock<std::mutex> lock(mtx_);
    count_++;
    cv_.notify_one();
  }

  inline void wait() {
    unique_lock<std::mutex> lock(mtx_);
    while (count_ == 0) cv_.wait(lock);
    count_--;
  }

private:
  mutex mtx_;
  condition_variable cv_;
  int count_;
};

class FizzBuzz {
private:
  int n;
  Semaphore sn;
  Semaphore s3;
  Semaphore s5;
  Semaphore s15;
  

public:
  FizzBuzz(int n): n(n), sn(1), s3(0), s5(0), s15(0) {}
  
  void fizz(function<void()> printFizz) {
    for (int i = 3; i <= n; i += 3) {
      if (i % 5 == 0) continue;
      s3.wait();
      printFizz();      
      sn.notify();
    }
  }
  
  void buzz(function<void()> printBuzz) {
    for (int i = 5; i <= n; i += 5) {
      if (i % 3 == 0) continue;
      s5.wait();
      printBuzz();      
      sn.notify();
    }
  }
  
  void fizzbuzz(function<void()> printFizzBuzz) {
    for (int i = 15; i <= n; i += 15) {
      s15.wait();
      printFizzBuzz();      
      sn.notify();
    }
  }

  void number(function<void(int)> printNumber) {
    for (int i = 1; i <= n; ++i)
      if (i % 15 == 0) { s15.notify(); sn.wait(); }
      else if (i % 5 == 0) { s5.notify(); sn.wait(); }
      else if (i % 3 == 0) { s3.notify(); sn.wait(); }
      else { printNumber(i); }    
  }
};

The post 花花酱 LeetCode 1195. Fizz Buzz Multithreaded appeared first on Huahua's Tech Road.

In other words:

• If an oxygen thread arrives at the barrier when no hydrogen threads are present, it has to wait for two hydrogen threads.
• If a hydrogen thread arrives at the barrier when no other threads are present, it has to wait for an oxygen thread and another hydrogen thread.

We don’t have to worry about matching the threads up explicitly; that is, the threads do not necessarily know which other threads they are paired up with. The key is just that threads pass the barrier in complete sets; thus, if we examine the sequence of threads that bond and divide them into groups of three, each group should contain one oxygen and two hydrogen threads.

Write synchronization code for oxygen and hydrogen molecules that enforces these constraints.

Example 1:

Input: "HOH"
Output: "HHO"
Explanation: "HOH" and "OHH" are also valid answers.

Example 2:

Input: "OOHHHH"
Output: "HHOHHO"
Explanation: "HOHHHO", "OHHHHO", "HHOHOH", "HOHHOH", "OHHHOH", "HHOOHH", "HOHOHH" and "OHHOHH" are also valid answers.

Constraints:

• Total length of input string will be 3n, where 1 ≤ n ≤ 30.
• Total number of H will be 2n in the input string.
• Total number of O will be n in the input string.

Solution: Semaphore

class Semaphore {
public:
    Semaphore(int s) : s_(s) {}

    void P(int d = 1) {
      unique_lock<mutex> lock(m_);
      while (s_ < d) {
        cv_.wait(lock);
      }
      s_ -= d;
    }
  
    void V(int d = 1) {      
      unique_lock<mutex> lock(m_);
      s_ += d;      
      cv_.notify_all();
    }
private:
  mutex m_;
  condition_variable cv_;
  int s_;
};

class H2O {
public:
    H2O():s_h_(2), s_o_(2) {  }

    void hydrogen(function<void()> releaseHydrogen) {      
      s_h_.P();
      releaseHydrogen();
      s_o_.V();
    }

    void oxygen(function<void()> releaseOxygen) {
      s_o_.P(2);      
      releaseOxygen();
      s_h_.V(2);
    }
private:
  Semaphore s_h_;
  Semaphore s_o_;
};

The post 花花酱 LeetCode 1117. Building H2O appeared first on Huahua's Tech Road.

class ZeroEvenOdd {
  public ZeroEvenOdd(int n) { ... }      // constructor
  public void zero(printNumber) { ... }  // only output 0's
  public void even(printNumber) { ... }  // only output even numbers
  public void odd(printNumber) { ... }   // only output odd numbers
}

The same instance of ZeroEvenOdd will be passed to three different threads:

1. Thread A will call zero() which should only output 0’s.
2. Thread B will call even() which should only ouput even numbers.
3. Thread C will call odd() which should only output odd numbers.

Each of the thread is given a printNumber method to output an integer. Modify the given program to output the series 010203040506… where the length of the series must be 2n.

Example 1:

Input: n = 2
Output: "0102"
Explanation: There are three threads being fired asynchronously. One of them calls zero(), the other calls even(), and the last one calls odd(). "0102" is the correct output.

Example 2:

Input: n = 5
Output: "0102030405"

Solution: Mutex

// Author: Huahua, 40 ms / 9 MB
class ZeroEvenOdd {
private:
  int x;
  int n;
  mutex m_zero_;
  mutex m_odd_;
  mutex m_even_;
public:
    ZeroEvenOdd(int n) {
      this->n = n;
      this->x = 1;
      m_odd_.lock();
      m_even_.lock();
    }

    // printNumber(x) outputs "x", where x is an integer.
    void zero(function<void(int)> printNumber) {
      for (int i = 0; i < n; ++i) {
        m_zero_.lock();
        printNumber(0);
        if (i % 2 == 0) {
          m_odd_.unlock();
        } else {
          m_even_.unlock();
        }
      }
    }

    void even(function<void(int)> printNumber) {
      for (int i = 2; i <= n; i += 2) {
        m_even_.lock();
        printNumber(i);
        m_zero_.unlock();
      }
    }

    void odd(function<void(int)> printNumber) {
      for (int i = 1; i <= n; i += 2) {
        m_odd_.lock();
        printNumber(i);
        m_zero_.unlock();      
      }
    }
};

The post 花花酱 LeetCode 1116. Print Zero Even Odd appeared first on Huahua's Tech Road.

class FooBar {
  public void foo() {
    for (int i = 0; i < n; i++) {
      print("foo");
    }
  }

  public void bar() {
    for (int i = 0; i < n; i++) {
      print("bar");
    }
  }
}

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 given program to output “foobar” n times.

Example 1:

Input: n = 1
Output: "foobar"
Explanation: There are two threads being fired asynchronously. One of them calls foo(), while the other calls bar(). "foobar" is being output 1 time.

Example 2:

Input: n = 2
Output: "foobarfoobar"
Explanation: "foobar" is being output 2 times.

Solution: Mutex

class FooBar {
private:
  int n;
  std::mutex m1_;
  std::mutex m2_; 
public:
  FooBar(int n) {
    this->n = n;    
    m2_.lock();
  }

  void foo(function<void()> printFoo) {

      for (int i = 0; i < n; i++) {
        m1_.lock();
        // printFoo() outputs "foo". Do not change or remove this line.
        printFoo();
        m2_.unlock();
      }
  }

  void bar(function<void()> printBar) {

      for (int i = 0; i < n; i++) {
        m2_.lock();
        // printBar() outputs "bar". Do not change or remove this line.
        printBar();
        m1_.unlock();
      }
  }
};

The post 花花酱 LeetCode 1115. Print FooBar Alternately appeared first on Huahua's Tech Road.

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

The same instance of Foo will be passed to three different threads. Thread A will call first(), thread B will call second(), and thread C will call third(). Design a mechanism and modify the program to ensure that second() is executed after first(), and third() is executed after second().

Example 1:

Input: [1,2,3]
Output: "firstsecondthird"
Explanation: There are three threads being fired asynchronously. The input [1,2,3] means thread A calls first(), thread B calls second(), and thread C calls third(). "firstsecondthird" is the correct output.

Example 2:

Input: [1,3,2]
Output: "firstsecondthird"
Explanation: The input [1,3,2] means thread A calls first(), thread B calls third(), and thread C calls second(). "firstsecondthird" is the correct output.

Note:

We do not know how the threads will be scheduled in the operating system, even though the numbers in the input seems to imply the ordering. The input format you see is mainly to ensure our tests’ comprehensiveness.

Solution 1: Mutex

// Author: Huahua, 128 ms / 8.2 MB
class Foo {
public:
    Foo() {
      first_.lock();
      second_.lock();
    }

    void first(function<void()> printFirst) {        
      // printFirst() outputs "first". Do not change or remove this line.
      printFirst();  
      first_.unlock();
    }

    void second(function<void()> printSecond) {            
      first_.lock();
      // printSecond() outputs "second". Do not change or remove this line.
      printSecond();
      first_.unlock();
      second_.unlock();
    }

    void third(function<void()> printThird) {
      second_.lock();
      // printThird() outputs "third". Do not change or remove this line.
      printThird();      
      second_.unlock();
    }
private:
  std::mutex first_;
  std::mutex second_;
};

Solution 2: Busy waiting

// Author: Huahua, 176 ms / 9.2 MB
#include <unistd.h>

class Foo {
public:
    Foo() {}

    void first(function<void()> printFirst) {        
      // printFirst() outputs "first". Do not change or remove this line.
      printFirst();  
      state_ = 1;
    }

    void second(function<void()> printSecond) {            
      while (state_ != 1) usleep(1);
      // printSecond() outputs "second". Do not change or remove this line.
      printSecond();
      state_ = 2;
    }

    void third(function<void()> printThird) {
      while (state_ != 2) usleep(1);
      // printThird() outputs "third". Do not change or remove this line.
      printThird();      
      state_ = 3;
    }
private:
  int state_ = 0;
};

The post 花花酱 LeetCode 1114. Print in Order appeared first on Huahua's Tech Road.