see #2: revision of parallelism and concurrency

code/7/7.1.cpp

@@ -1,37 +0,0 @@
-//
-// 7.1.cpp
-// modern c++ tutorial
-//
-// created by changkun at changkun.de
-// https://github.com/changkun/modern-cpp-tutorial
-//
-// 线程支持库
-
-#include <iostream>
-#include <future>
-#include <thread>
-void foo() {
-    std::cout << "hello world" << std::endl;
-}
-
-void foo2() {
-    // 将一个返回值为7的 lambda 表达式封装到 task 中
-    // std::packaged_task 的模板参数为要封装函数的类型
-    std::packaged_task<int()> task([](){return 7;});
-    // 获得 task 的 future
-    std::future<int> result = task.get_future();    // 在一个线程中执行 task
-    std::thread(std::move(task)).detach();    std::cout << "Waiting...";
-    result.wait();
-    // 输出执行结果
-    std::cout << "Done!" << std:: endl << "Result is " << result.get() << '\n';
-}
-
-int main() {
-    std::thread t(foo);
-    
-    foo2();
-    
-    t.join();
-    
-    return 0;
-}

code/7/7.1.thread.basic.cpp

@@ -0,0 +1,19 @@
+//
+// 7.1.thread.basic.cpp
+// chapter 7 parallelism and concurrency
+// modern c++ tutorial
+//
+// created by changkun at changkun.de
+// https://github.com/changkun/modern-cpp-tutorial
+//
+
+#include <iostream>
+#include <thread>
+
+int main() {
+    std::thread t([](){
+        std::cout << "hello world." << std::endl;
+    });
+    t.join();
+    return 0;
+}

code/7/7.2.cpp

@@ -1,63 +0,0 @@
-//
-// 7.2.cpp
-// modern c++ tutorial
-//
-// created by changkun at changkun.de
-// https://github.com/changkun/modern-cpp-tutorial
-//
-// 生产者消费者模型
-
-#include <condition_variable>
-#include <mutex>
-#include <thread>
-#include <iostream>
-#include <queue>
-#include <chrono>
-
-int main()
-{
-    // 生产者数量
-    std::queue<int> produced_nums;
-    // 互斥锁
-    std::mutex m;
-    // 条件变量
-    std::condition_variable cond_var;
-    // 结束标志
-    bool done = false;
-    // 通知标志
-    bool notified = false;
-    
-    // 生产者线程
-    std::thread producer([&]() {
-        for (int i = 0; i < 5; ++i) {
-            std::this_thread::sleep_for(std::chrono::seconds(1));
-            // 创建互斥锁
-            std::unique_lock<std::mutex> lock(m);
-            std::cout << "producing " << i << '\n';
-            produced_nums.push(i);
-            notified = true;
-            // 通知一个线程
-            cond_var.notify_one();
-        }
-        done = true;
-        notified = true;
-        cond_var.notify_one();
-    });
-    // 消费者线程
-    std::thread consumer([&]() {
-        std::unique_lock<std::mutex> lock(m);
-        while (!done) {
-            while (!notified) {  // 循环避免虚假唤醒
-                cond_var.wait(lock);
-            }
-            while (!produced_nums.empty()) {
-                std::cout << "consuming " << produced_nums.front() << '\n';
-                produced_nums.pop();
-            }
-            notified = false;
-        }
-    });
-    
-    producer.join();
-    consumer.join();
-}

code/7/7.2.critical.section.a.cpp

@@ -0,0 +1,32 @@
+//
+// 7.2.critical.section.a.cpp
+// chapter 7 parallelism and concurrency
+// modern c++ tutorial
+//
+// created by changkun at changkun.de
+// https://github.com/changkun/modern-cpp-tutorial
+//
+
+#include <iostream>
+#include <thread>
+
+int v = 1;
+
+void critical_section(int change_v) {
+    static std::mutex mtx;
+    std::lock_guard<std::mutex> lock(mtx);
+
+    // do contention operations
+    v = change_v;
+
+    // mtx will be destructed when exit this region
+}
+
+int main() {
+    std::thread t1(critical_section, 2), t2(critical_section, 3);
+    t1.join();
+    t2.join();
+
+    std::cout << v << std::endl;
+    return 0;
+}

code/7/7.3.critical.section.b.cpp

@@ -0,0 +1,39 @@
+//
+// 7.3.critical.section.b.cpp
+// chapter 7 parallelism and concurrency
+// modern c++ tutorial
+//
+// created by changkun at changkun.de
+// https://github.com/changkun/modern-cpp-tutorial
+//
+
+#include <iostream>
+#include <thread>
+
+int v = 1;
+
+void critical_section(int change_v) {
+    static std::mutex mtx;
+    std::unique_lock<std::mutex> lock(mtx);
+    // do contention operations
+    v = change_v;
+    std::cout << v << std::endl;
+    // release the lock
+    lock.unlock();
+
+    // during this period,
+    // others are allowed to acquire v
+
+    // start another group of contention operations
+    // lock again
+    lock.lock();
+    v += 1;
+    std::cout << v << std::endl;
+}
+
+int main() {
+    std::thread t1(critical_section, 2), t2(critical_section, 3);
+    t1.join();
+    t2.join();
+    return 0;
+}

code/7/7.4.futures.cpp

@@ -0,0 +1,31 @@
+//
+// 7.2.critical.section.a.cpp
+// chapter 7 parallelism and concurrency
+// modern c++ tutorial
+//
+// created by changkun at changkun.de
+// https://github.com/changkun/modern-cpp-tutorial
+//
+
+#include <iostream>
+#include <thread>
+#include <iostream>
+#include <future>
+#include <thread>
+
+void foo() {
+
+}
+
+int main() {
+    // pack a lambda expression that returns 7 into a std::packaged_task
+    std::packaged_task<int()> task([](){return 7;});
+    // get the future of task
+    std::future<int> result = task.get_future();    // run task in a thread
+    std::thread(std::move(task)).detach();
+    std::cout << "waiting...";
+    result.wait(); // block until future has arrived
+    // output result
+    std::cout << "done!" << std:: endl << "future result is " << result.get() << std::endl;
+    return 0;
+}

code/7/7.5.producer.consumer.cpp

@@ -0,0 +1,64 @@
+//
+// 7.5.cpp
+// chapter 7 parallelism and concurrency
+// modern c++ tutorial
+//
+// created by changkun at changkun.de
+// https://github.com/changkun/modern-cpp-tutorial
+//
+
+#include <queue>
+#include <chrono>
+#include <mutex>
+#include <thread>
+#include <iostream>
+#include <condition_variable>
+
+
+int main() {
+    std::queue<int> produced_nums;
+    std::mutex mtx;
+    std::condition_variable cv;
+    bool notified = false;  // notification sign
+
+    auto producer = [&]() {
+        for (int i = 0; ; i++) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(500));
+            std::unique_lock<std::mutex> lock(mtx);
+            std::cout << "producing " << i << std::endl;
+            produced_nums.push(i);
+            notified = true;
+            cv.notify_all();
+        }
+    };
+    auto consumer = [&]() {
+        while (true) {
+            std::unique_lock<std::mutex> lock(mtx);
+            while (!notified) {  // avoid spurious wakeup
+                cv.wait(lock);
+            }
+
+            // temporal unlock to allow producer produces more rather than
+            // let consumer hold the lock until its consumed.
+            lock.unlock();
+            std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // consumer is slower
+            lock.lock();
+            if (!produced_nums.empty()) {
+                std::cout << "consuming " << produced_nums.front() << std::endl;
+                produced_nums.pop();
+            }
+            notified = false;
+        }
+    };
+
+    std::thread p(producer);
+    std::thread cs[2];
+    for (int i = 0; i < 2; ++i) {
+        cs[i] = std::thread(consumer);
+    }
+    p.join();
+    for (int i = 0; i < 2; ++i) {
+        cs[i].join();
+    }
+    return 0;
+}

code/7/Makefile

@@ -0,0 +1,14 @@
+#
+# modern cpp tutorial
+#
+# created by changkun at changkun.de
+# https://github.com/changkun/modern-cpp-tutorial
+#
+
+all: $(patsubst %.cpp, %.out, $(wildcard *.cpp))
+
+%.out: %.cpp Makefile
+	clang++ $< -o $@ -std=c++2a -pedantic
+
+clean:
+	rm *.out