add cpp_concurent

Author: zhao

example_code/cpp-concurrency-master/.gitignore

@@ -0,0 +1,29 @@
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# bin
+bin

example_code/cpp-concurrency-master/README.md

@@ -0,0 +1 @@
+Source code for [C++ 并发编程](https://paul.pub/cpp-concurrency/)

example_code/cpp-concurrency-master/make_all.sh

@@ -0,0 +1,11 @@
+rm -rf bin
+
+mkdir build
+cd build
+
+cmake ../src/
+make
+
+cd ../
+mv build/bin ./
+rm -rf build/

example_code/cpp-concurrency-master/src/01_hello_thread.cpp

@@ -0,0 +1,15 @@
+#include <iostream>
+#include <thread>
+
+using namespace std;
+
+void hello() {
+  cout << "Hello World from new thread." << endl;
+}
+
+int main() {
+  thread t(hello);
+  t.join();
+
+  return 0;
+}

example_code/cpp-concurrency-master/src/02_lambda_thread.cpp

@@ -0,0 +1,14 @@
+#include <iostream>
+#include <thread>
+
+using namespace std;
+
+int main() {
+  thread t([] {
+    cout << "Hello World from lambda thread." << endl;
+  });
+
+  t.join();
+
+  return 0;
+}

example_code/cpp-concurrency-master/src/02_thread.cpp

@@ -0,0 +1,71 @@
+#include <cmath>
+#include <chrono>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+using namespace std;
+
+static const int MAX = 10e8;
+
+static mutex gMutex;
+
+static double sum = 0;
+
+void worker(int min, int max) {
+  for (int i = min; i <= max; i++) {
+    sum += sqrt(i);
+  }
+}
+
+void serial_task(int min, int max) {
+  auto start_time = chrono::steady_clock::now();
+  sum = 0;
+  worker(0, MAX);
+  auto end_time = chrono::steady_clock::now();
+  auto ms = chrono::duration_cast<chrono::milliseconds>(end_time - start_time).count();
+  cout << "Serail task finish, " << ms << " ms consumed, Result: " << sum << endl;
+}
+
+void concurrent_worker(int min, int max) {
+  {
+    lock_guard guard(gMutex);
+    cout << "Thread " << this_thread::get_id() << " work for [" << min << ", " << max << "]" << endl;
+  }
+  double cur_sum = 0;
+  for (int i = min; i <= max; i++) {
+    cur_sum += sqrt(i);
+  }
+  {
+    lock_guard guard(gMutex);
+    sum += cur_sum;
+  }
+}
+
+void concurrent_task(int min, int max) {
+  auto start_time = chrono::steady_clock::now();
+
+  unsigned concurrent_count = thread::hardware_concurrency();
+  cout << "hardware_concurrency: " << concurrent_count << endl;
+  vector<thread> threads;
+  min = 0;
+  sum = 0;
+  for (int t = 0; t < concurrent_count; t++) {
+    int range = max / concurrent_count * (t + 1);
+    threads.push_back(thread(concurrent_worker, min, range));
+    min = range + 1;
+  }
+  for (int i = 0; i < threads.size(); i++) {
+    threads[i].join();
+  }
+
+  auto end_time = chrono::steady_clock::now();
+  auto ms = chrono::duration_cast<chrono::milliseconds>(end_time - start_time).count();
+  cout << "Concurrent task finish, " << ms << " ms consumed, Result: " << sum << endl;
+}
+
+int main() {
+  serial_task(0, MAX);
+  concurrent_task(0, MAX);
+  return 0;
+}

example_code/cpp-concurrency-master/src/03_thread_argument.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+#include <string>
+#include <thread>
+
+using namespace std;
+
+void hello(string name) {
+  cout << "Welcome to " << name << endl;
+}
+
+int main() {
+  thread t(hello, "https://paul.pub");
+  t.join();
+
+  return 0;
+}

example_code/cpp-concurrency-master/src/04_thread_self_manage.cpp

@@ -0,0 +1,41 @@
+#include <chrono>
+#include <ctime>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <thread>
+
+using namespace std;
+
+void print_time() {
+  auto now = chrono::system_clock::now();
+  auto in_time_t = chrono::system_clock::to_time_t(now);
+
+  std::stringstream ss;
+  ss << put_time(localtime(&in_time_t), "%Y-%m-%d %X");
+  cout << "now is: " << ss.str() << endl;
+}
+
+void sleep_thread() {
+  this_thread::sleep_for(chrono::seconds(3));
+  cout << "[thread-" << this_thread::get_id() << "] is waking up" << endl;
+}
+
+void loop_thread() {
+  for (int i = 0; i < 10; i++) {
+    cout << "[thread-" << this_thread::get_id() << "] print: " << i << endl;
+  }
+}
+
+int main() {
+  print_time();
+
+  thread t1(sleep_thread);
+  thread t2(loop_thread);
+
+  t1.join();
+  t2.detach();
+
+  print_time();
+  return 0;
+}

example_code/cpp-concurrency-master/src/05_call_once.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <mutex>
+#include <thread>
+
+using namespace std;
+
+void init() {
+  cout << "Initialing..." << endl;
+  // Do something...
+}
+
+void worker(once_flag* flag) {
+  call_once(*flag, init);
+}
+
+int main() {
+  once_flag flag;
+
+  thread t1(worker, &flag);
+  thread t2(worker, &flag);
+  thread t3(worker, &flag);
+
+  t1.join();
+  t2.join();
+  t3.join();
+
+  return 0;
+}

example_code/cpp-concurrency-master/src/06_naive_multithread.cpp

@@ -0,0 +1,53 @@
+#include <cmath>
+#include <chrono>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+using namespace std;
+
+static const int MAX = 10e8;
+static double sum = 0;
+
+void worker(int min, int max) {
+  for (int i = min; i <= max; i++) {
+    sum += sqrt(i);
+  }
+}
+
+void serial_task(int min, int max) {
+  auto start_time = chrono::steady_clock::now();
+  sum = 0;
+  worker(0, MAX);
+  auto end_time = chrono::steady_clock::now();
+  auto ms = chrono::duration_cast<chrono::milliseconds>(end_time - start_time).count();
+  cout << "Serail task finish, " << ms << " ms consumed, Result: " << sum << endl;
+}
+
+void concurrent_task(int min, int max) {
+  auto start_time = chrono::steady_clock::now();
+
+  unsigned concurrent_count = thread::hardware_concurrency();
+  cout << "hardware_concurrency: " << concurrent_count << endl;
+  vector<thread> threads; 
+  min = 0;
+  sum = 0;
+  for (int t = 0; t < concurrent_count; t++) {
+    int range = max / concurrent_count * (t + 1);
+    threads.push_back(thread(worker, min, range));
+    min = range + 1;
+  }
+  for (int i = 0; i < threads.size(); i++) {
+    threads[i].join();
+  }
+
+  auto end_time = chrono::steady_clock::now();
+  auto ms = chrono::duration_cast<chrono::milliseconds>(end_time - start_time).count();
+  cout << "Concurrent task finish, " << ms << " ms consumed, Result: " << sum << endl;
+}
+
+int main() {
+  serial_task(0, MAX);
+  concurrent_task(0, MAX);
+  return 0;
+}