New theme:Concurrency. update

Author: KongJHong

solution/1114.Print in Order/README.md

@@ -0,0 +1,88 @@
+## 1114.按顺序打印
+
+### 问题描述
+
+我们提供了一个类：
+
+```
+public class Foo {
+  public void one() { print("one"); }
+  public void two() { print("two"); }
+  public void three() { print("three"); }
+}
+```
+
+三个不同的线程将会共用一个 `Foo` 实例。
+
+- 线程 A 将会调用 `one()` 方法
+- 线程 B 将会调用 `two()` 方法
+- 线程 C 将会调用 `three()` 方法
+
+请设计修改程序，以确保 `two()` 方法在 `one()` 方法之后被执行，`three()` 方法在 `two()` 方法之后被执行。
+
+ 
+
+**示例 1:**
+
+```
+输入: [1,2,3]
+输出: "onetwothree"
+解释: 
+有三个线程会被异步启动。
+输入 [1,2,3] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 two() 方法，线程 C 将会调用 three() 方法。
+正确的输出是 "onetwothree"。
+```
+
+**示例 2:**
+
+```
+输入: [1,3,2]
+输出: "onetwothree"
+解释: 
+输入 [1,3,2] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 three() 方法，线程 C 将会调用 two() 方法。
+正确的输出是 "onetwothree"。
+```
+
+### 解法
+
+多线程同步问题，很好理解
+
+#### CPP
+
+```cpp
+class Foo { //C++ 11
+public:
+    Foo() {
+        _mutex1.lock();
+        _mutex2.lock();
+    }
+
+    void first(function<void()> printFirst) {
+        
+        printFirst();
+        _mutex1.unlock();
+    }
+
+    void second(function<void()> printSecond) {
+        
+        _mutex1.lock();
+        printSecond();
+        _mutex1.unlock();
+        _mutex2.unlock();
+    }
+
+    void third(function<void()> printThird) {
+        
+        _mutex2.lock();
+        printThird();
+        _mutex2.unlock();
+    }
+    
+    
+private:
+    std::mutex _mutex1;
+    std::mutex _mutex2;
+    
+};
+```
+

solution/1114.Print in Order/solution.cpp

@@ -0,0 +1,34 @@
+class Foo {
+public:
+    Foo() {
+        _mutex1.lock();
+        _mutex2.lock();
+    }
+
+    void first(function<void()> printFirst) {
+        
+        printFirst();
+        _mutex1.unlock();
+    }
+
+    void second(function<void()> printSecond) {
+        
+        _mutex1.lock();
+        printSecond();
+        _mutex1.unlock();
+        _mutex2.unlock();
+    }
+
+    void third(function<void()> printThird) {
+        
+        _mutex2.lock();
+        printThird();
+        _mutex2.unlock();
+    }
+    
+    
+private:
+    std::mutex _mutex1;
+    std::mutex _mutex2;
+    
+};

solution/1115.Print FooBar Alternately/README.md

@@ -0,0 +1,82 @@
+## 1115.交替打印FooBar
+### 问题描述
+
+我们提供一个类：
+
+```
+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");
+    }
+  }
+}
+```
+
+两个不同的线程将会共用一个 `FooBar` 实例。其中一个线程将会调用 `foo()` 方法，另一个线程将会调用 `bar()` 方法。
+
+请设计修改程序，以确保 "foobar" 被输出 n 次。
+
+ 
+
+**示例 1:**
+
+```
+输入: n = 1
+输出: "foobar"
+解释: 这里有两个线程被异步启动。其中一个调用 foo() 方法, 另一个调用 bar() 方法，"foobar" 将被输出一次。
+```
+
+**示例 2:**
+
+```
+输入: n = 2
+输出: "foobarfoobar"
+解释: "foobar" 将被输出两次。
+```
+
+
+
+### 思路
+
+两锁交替的同步，后进行的代码先加锁原则
+
+```cpp
+class FooBar {
+private:
+    int n;
+    std::mutex _mutex1;
+    std::mutex _mutex2;
+
+public:
+    FooBar(int n) {
+        this->n = n;
+        _mutex2.lock();
+    }
+
+    void foo(function<void()> printFoo) {
+        
+        for (int i = 0; i < n; i++) {
+            _mutex1.lock();
+        	printFoo();
+            _mutex2.unlock();
+        }
+    }
+
+    void bar(function<void()> printBar) {
+        
+        for (int i = 0; i < n; i++) {
+            _mutex2.lock();
+        	printBar();
+            _mutex1.unlock();
+        }
+    }
+};
+```
+

solution/1115.Print FooBar Alternately/Solution.cpp

@@ -0,0 +1,30 @@
+class FooBar {
+private:
+    int n;
+    std::mutex _mutex1;
+    std::mutex _mutex2;
+
+public:
+    FooBar(int n) {
+        this->n = n;
+        _mutex2.lock();
+    }
+
+    void foo(function<void()> printFoo) {
+        
+        for (int i = 0; i < n; i++) {
+            _mutex1.lock();
+        	printFoo();
+            _mutex2.unlock();
+        }
+    }
+
+    void bar(function<void()> printBar) {
+        
+        for (int i = 0; i < n; i++) {
+            _mutex2.lock();
+        	printBar();
+            _mutex1.unlock();
+        }
+    }
+};

solution/1116.Print Zero Even Odd/README.md

@@ -0,0 +1,91 @@
+## 1116.Print Zero Even Odd（leetcode未翻译）
+### 问题描述
+
+Suppose you are given the following code:
+
+```
+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 2*n*.
+
+ 
+
+**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"
+```
+
+
+
+### 思路
+
+一个同步问题，一个互斥问题，奇偶打印是互斥，0和奇/偶的打印是同步问题，所以用到3把锁
+
+```cpp
+class ZeroEvenOdd {
+private:
+    int n;
+    int flag;
+    mutex m1,m2,m3;
+
+public:
+    ZeroEvenOdd(int n) {
+        this->n = n;
+        flag = 1; //奇偶判断
+        m1.lock();
+        m2.lock();
+        m3.lock();
+    }
+
+    // printNumber(x) outputs "x", where x is an integer.
+    void zero(function<void(int)> printNumber) {
+        m3.unlock();
+        for(int i = 0; i < n ;i++){
+            m3.lock();
+            printNumber(0);
+            if(flag == 1)flag = 0,m2.unlock();  
+            else flag = 1,m1.unlock();           
+        }
+    }
+    
+
+    void odd(function<void(int)> printNumber) { //输出奇数
+        for(int i = 1;i <= n; i+=2){
+            m2.lock();
+            printNumber(i);
+            m3.unlock();
+        }
+    }
+
+    void even(function<void(int)> printNumber) { //输出偶数
+        for(int i = 2;i <= n; i+=2){
+            m1.lock();
+            printNumber(i);
+            m3.unlock();
+        }
+    }
+};
+```
+

solution/1116.Print Zero Even Odd/Solution.cpp

@@ -0,0 +1,43 @@
+class ZeroEvenOdd {
+private:
+    int n;
+    int flag;
+    mutex m1,m2,m3;
+
+public:
+    ZeroEvenOdd(int n) {
+        this->n = n;
+        flag = 1; //奇偶判断
+        m1.lock();
+        m2.lock();
+        m3.lock();
+    }
+
+    // printNumber(x) outputs "x", where x is an integer.
+    void zero(function<void(int)> printNumber) {
+        m3.unlock();
+        for(int i = 0; i < n ;i++){
+            m3.lock();
+            printNumber(0);
+            if(flag == 1)flag = 0,m2.unlock();  
+            else flag = 1,m1.unlock();           
+        }
+    }
+    
+
+    void odd(function<void(int)> printNumber) { //输出奇数
+        for(int i = 1;i <= n; i+=2){
+            m2.lock();
+            printNumber(i);
+            m3.unlock();
+        }
+    }
+
+    void even(function<void(int)> printNumber) { //输出偶数
+        for(int i = 2;i <= n; i+=2){
+            m1.lock();
+            printNumber(i);
+            m3.unlock();
+        }
+    }
+};