caijizhuo

typedef enum memory_order {
    memory_order_relaxed,
    memory_order_consume,
    memory_order_acquire,
    memory_order_release,
    memory_order_acq_rel,
    memory_order_seq_cst
} memory_order;

x = y = 0;

thread1:
x = 1;
r1 = y;

thread2:
y = 1;
r2 = x;

int add(int a, int b) {
    return a + b;
}
int main() {
    int a = 9;
    int b = 10;
    int c = 11;
    int d = add(a, b);
    return 0;
}

vector<int> ret;
void helper(TreeNode* root) {
    if (root == nullptr) {
        return;
    }
    helper(root->left);
    ret.push_back(root->val);
    helper(root->right);
}
vector<int> inorderTraversal(TreeNode* root) {
    ret.clear();
    helper(root);
    return ret;
}

typedef struct state {
    TreeNode* node;
    int stage;
};
vector<int> inorderTraversal(TreeNode* root) {
    stack<state> s;
    vector<int> ret;
    s.push({root, 0});
    while (!s.empty()) {
        state top = s.top();
        s.pop();
        if (top.stage == 0) {                  // 状态 1
            if (top.node == nullptr) {
                continue;
            }
            s.push({top.node, 1});             // 将本次调用栈状态修改为 1 再推回去（其实就不应该出栈）
            s.push({top.node->left, 0});       // 新开的函数调用栈 helper(root->left)
        } else if (top.stage == 1) {           // 状态 2
            s.push({top.node, 2});             // 将本次调用栈状态修改为 2 再推回去（其实就不应该出栈）
            ret.push_back(top.node->val);
            s.push({top.node->right, 0});      // 新开的函数调用栈 helper(root->right)
        } else if (top.stage == 2) {           // 状态 3
            // do nothing
        }
    }
    return ret;
}

#include <iostream>
using namespace std;
class A {
public:
    A(int num) : a_(num) {
        cout << a_ << endl;
    }
private:
    const int a_;
};

int main(){
    A a(12);
}

#include <iostream>
using namespace std;
class Test {
public:
    Test() {
        cout << "constructor called" << endl;
    }
    Test(const Test& t) {
        cout << "copy constructor called" << endl;
    }
    Test& operator=(const Test& t) {
        cout << "assignment operator called" << endl;
        return *this;
    }
};

class Base {
public:
    Base() {
        cout << "call base constructor" << endl;
    }
};

class B : public Base {
public:
    B(Test ele) : t_(ele) {
        cout << "call B constructor" << endl;
    }
private:
    Test t_;
};

int main(){
    Test t;
    cout << "==========" << endl;
    B b(t);
}

#include <iostream>
using namespace std;
class Test1 {
public:
    Test1() = default;
    Test1(const Test1& t) {
        cout << "Test1 copy constructor called" << endl;
    }
};

class Test2 {
public:
    Test2() = default;
    Test2(const Test2& t) {
        cout << "Test2 copy constructor called" << endl;
    }
};

class Test3 {
public:
    Test3() = default;
    Test3(const Test3& t) {
        cout << "Test3 copy constructor called" << endl;
    }
};

class A {
public:
    A(Test1 ele1, Test2 ele2, Test3 ele3) : t2_(ele2), t1_(ele1), t3_(ele3) {}
private:
    Test3 t3_;
    Test1 t1_;
    Test2 t2_;
};

int main(){
    Test1 t1;
    Test2 t2;
    Test3 t3;
    cout << "==========" << endl;
    A a(t1, t2, t3);
}

#include <iostream>
using namespace std;
class Test {
public:
    Test() {
        cout << "constructor called" << endl;
    }
    Test(const Test& t) {
        cout << "copy constructor called" << endl;
    }
    Test& operator=(const Test& t) {
        cout << "assignment operator called" << endl;
        return *this;
    }
};

class A {
public:
    A(Test ele) {
        t_ = ele;
    }
private:
    Test t_;
};

class B {
public:
    B(Test ele) : t_(ele) {}
private:
    Test t_;
};

int main(){
    Test t;
    cout << "==========" << endl;
    A a(t);
    cout << "==========" << endl;
    B b(t);
}

typedef std::function<void()> task_t;
void thread_pool::add_task(const task_t& task) {
  std::unique_lock<std::mutex> lock(mutex_);
  tasks_.push(task);
  wake_cond_.notify_one(); // 只唤醒一个线程
}

// 向线程池加入任务
template<class F, class... Args>
auto add_task(F&& f, Args&&... args) -> std::future<decltype(f(args...))> {
  using return_type = decltype(f(args...));
  auto task_ptr = std::make_shared<std::packaged_task<return_type()>>( // 因为 packaged_task 无法拷贝构造，所以用 make_shared
      std::bind(std::forward<F>(f), std::forward<Args>(args)...)
  );

  std::future<return_type> res = task_ptr->get_future();
  {
    std::unique_lock<std::mutex> lock(mutex_);
    tasks_.emplace([task_ptr]() {
      (*task_ptr)();
    });
  }
  wake_cond_.notify_one();
  return res;
}

#include <iostream>
#include <chrono>
#include <future>
#include "thread_pool.h"

std::mutex g_screen_mutex; // 向终端打印信息的锁

int test(int a, int b) {
  std::this_thread::sleep_for(std::chrono::seconds(1));
  std::lock_guard<std::mutex> lock(g_screen_mutex);
  std::cout << "test() at thread [ " << std::this_thread::get_id() << "] output [" << a + b << "]" << std::endl;
  return a + b;
}

int main() {
  thread_pool thread_pool;
  std::vector<std::future<int>> results;
  for(int i = 0; i < 5 ; i++) {
    auto fu = thread_pool.add_task(test, i, 2);
    results.emplace_back(std::move(fu));
  }
  getchar(); // 等待，不要让主进程退出
  for (int i = 0; i < 5; i++) {
    std::cout<< "result of number " << i << " :" << results[i].get() << std::endl;
  }
  return 0;
}

#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_

#include <vector>
#include <queue>
#include <thread>
#include <functional>
#include <mutex>
#include <condition_variable>

class thread_pool {
 public:
  // 定义为一个函数类型，返回值为 void，没有入参
  typedef std::function<void()> task_t;

  thread_pool(int init_size = 3);
  ~thread_pool();
  // 停止线程池
  void stop();
  // 向线程池加入任务
  template<class F, class... Args>
  auto add_task(F&& f, Args&&... args) -> std::future<decltype(f(args...))> {
    using return_type = decltype(f(args...));
    auto task_ptr = std::make_shared<std::packaged_task<return_type()>>(
        std::bind(std::forward<F>(f), std::forward<Args>(args)...)
    );
    std::future<return_type> res = task_ptr->get_future();
    {
      std::unique_lock<std::mutex> lock(mutex_);
      tasks_.emplace([task_ptr]() {
        (*task_ptr)();
      });
    }
    wake_cond_.notify_one();
    return res;
  }
 private:
  thread_pool(const thread_pool&) = delete; // 禁止复制拷贝
  const thread_pool& operator=(const thread_pool&) = delete;
  // 线程池启动函数
  void start();
  // 每个线程的循环函数
  void thread_loop();
  // 从线程池里拿一个线程
  task_t take();

  int init_threads_size_; // 初始线程数量
  std::vector<std::thread*> threads_; // 已经创建的线程列表
  std::queue<task_t> tasks_; // 待执行任务列表
  std::mutex mutex_; // 操作线程池共有变量之前先上锁
  std::condition_variable wake_cond_; // 唤醒线程的条件
  bool is_started_; // 线程池是否已经启动
};
#endif

#include <assert.h>
#include <iostream>
#include <future>
#include "thread_pool.h"

thread_pool::thread_pool(int init_size)
    : init_threads_size_(init_size), mutex_(), wake_cond_(), is_started_(false) {
  start();
}

thread_pool::~thread_pool() {
  if (is_started_) {
    stop();
  }
}

void thread_pool::start() {
  assert(threads_.empty());
  is_started_ = true;
  threads_.reserve(init_threads_size_);
  for (int i = 0; i < init_threads_size_; ++i) {
    threads_.push_back(new std::thread(std::bind(&thread_pool::thread_loop, this)));
  }
}

void thread_pool::stop() {
  std::cout << "thread_pool::stop() stop." << std::endl;
  {
    std::unique_lock<std::mutex> lock(mutex_);
    is_started_ = false;
    wake_cond_.notify_all();
    std::cout << "thread_pool::stop() notifyAll()." << std::endl;
  }

  for (auto thread : threads_) {
    thread->join();
    delete thread;
  }
  threads_.clear();
}

void thread_pool::thread_loop() {
  std::cout << "thread_pool::threadLoop() tid : " << std::this_thread::get_id() << " start." << std::endl;
  while (is_started_) {
    task_t task = take();
    if (task) {
      task();
    }
  }
  std::cout << "thread_pool::threadLoop() tid : " << std::this_thread::get_id() << " exit." << std::endl;
}

thread_pool::task_t thread_pool::take() {
  std::unique_lock<std::mutex> lock(mutex_);
  // 使用 while 循环，防止假唤醒
  while (tasks_.empty() && is_started_) {
    std::cout << "thread_pool::take() tid : " << std::this_thread::get_id() << " wait." << std::endl;
    wake_cond_.wait(lock);
  }

  std::cout << "thread_pool::take() tid : " << std::this_thread::get_id() << " wakeup." << std::endl;
  task_t task;
  size_t size = tasks_.size();
  if (!tasks_.empty() && is_started_) {
    task = tasks_.front();
    tasks_.pop();
    assert(size - 1 == tasks_.size());
  }
  if (task != nullptr) {
    std::cout << "thread_pool::take() tid : " << std::this_thread::get_id() << " took a task!" << std::endl;
  }
  return task;
}

#include <iostream>
#include <chrono>
#include "thread_pool.h"

std::mutex g_screen_mutex; // 向终端打印信息的锁

void testFunc() {
  std::this_thread::sleep_for(std::chrono::seconds(1));
  std::lock_guard<std::mutex> lock(g_screen_mutex);
  std::cout << "===============================================================" << std::endl;
  std::cout << "|       testFunc() at thread [ " << std::this_thread::get_id() << "] output [" << 0 << "]    |" << std::endl;
  std::cout << "===============================================================" << std::endl;
}

int main() {
  thread_pool thread_pool;
  for(int i = 0; i < 5 ; i++) { // 往里面插入 5 个任务
    thread_pool.add_task(testFunc);
  }
  getchar(); // 等待，不要让主进程退出
  return 0;
}

#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_

#include <vector>
#include <queue>
#include <thread>
#include <functional>
#include <mutex>
#include <condition_variable>

class thread_pool {
 public:
  // 定义为一个函数类型，返回值为 void，没有入参
  typedef std::function<void()> task_t;

  thread_pool(int init_size = 3);
  ~thread_pool();
  // 停止线程池
  void stop();
  // 向线程池加入任务
  void add_task(const task_t&);

 private:
  thread_pool(const thread_pool&) = delete; // 禁止复制拷贝
  const thread_pool& operator=(const thread_pool&) = delete;
  // 线程池启动函数
  void start();
  // 每个线程的循环函数
  void thread_loop();
  // 从线程池里拿一个线程
  task_t take();

  int init_threads_size_; // 初始线程数量
  std::vector<std::thread*> threads_; // 已经创建的线程列表
  std::queue<task_t> tasks_; // 待执行任务列表
  std::mutex mutex_; // 操作线程池共有变量之前先上锁
  std::condition_variable wake_cond_; // 唤醒线程的条件
  bool is_started_; // 线程池是否已经启动
};
#endif

#include <assert.h>
#include <iostream>
#include "thread_pool.h"

thread_pool::thread_pool(int init_size)
    : init_threads_size_(init_size), mutex_(), wake_cond_(), is_started_(false) {
  start();
}

thread_pool::~thread_pool() {
  if (is_started_) {
    stop();
  }
}

void thread_pool::start() {
  assert(threads_.empty());
  is_started_ = true;
  threads_.reserve(init_threads_size_);
  for (int i = 0; i < init_threads_size_; ++i) {
    // 非静态成员函数则需要传递 this 指针作为第一个参数
    threads_.push_back(new std::thread(std::bind(&thread_pool::thread_loop, this)));
  }
}

void thread_pool::stop() {
  std::cout << "thread_pool::stop() stop." << std::endl;
  {
    std::unique_lock<std::mutex> lock(mutex_); // 只有 unique_lock 才能和 condition_variable 配合使用
    is_started_ = false;
    wake_cond_.notify_all(); // 销毁前唤醒所有线程
    std::cout << "thread_pool::stop() notifyAll()." << std::endl;
  }

  for (auto thread : threads_) {
    thread->join(); // 销毁之前需要等待所有线程完成
    delete thread;
  }
  threads_.clear();
}

void thread_pool::thread_loop() {
  std::cout << "thread_pool::threadLoop() tid : " << std::this_thread::get_id() << " start." << std::endl;
  while (is_started_) {
    task_t task = take(); // 如果没有拿到会阻塞在这里
    if (task) {
      task();
    }
  }
  std::cout << "thread_pool::threadLoop() tid : " << std::this_thread::get_id() << " exit." << std::endl;
}

void thread_pool::add_task(const task_t& task) {
  std::unique_lock<std::mutex> lock(mutex_);
  tasks_.push(task);
  wake_cond_.notify_one(); // 只唤醒一个线程
}

thread_pool::task_t thread_pool::take() {
  std::unique_lock<std::mutex> lock(mutex_);
  // 使用 while 循环，防止假唤醒
  while (tasks_.empty() && is_started_) {
    std::cout << "thread_pool::take() tid : " << std::this_thread::get_id() << " wait." << std::endl;
    wake_cond_.wait(lock); // 如果没任务的话线程会阻塞在这里
  }

  std::cout << "thread_pool::take() tid : " << std::this_thread::get_id() << " wakeup." << std::endl;
  task_t task;
  size_t size = tasks_.size();
  if (!tasks_.empty() && is_started_) {
    task = tasks_.front(); // 拿出队列中第一个任务
    tasks_.pop();
    assert(size - 1 == tasks_.size());
  }
  if (task != nullptr) {
    std::cout << "thread_pool::take() tid : " << std::this_thread::get_id() << " took a task!" << std::endl;
  }
  return task;
}