c++线程池的简单实现

任务描述：

有1000个文件，每个文件1000行字符串，要求统计回文串的总数
要求：

1. 实现一个线程池
2. 符合生产者消费者模型
3. 生产者多线程读取文件，将字符串加入队列中
4. 消费者读取队列内容并计算回文个数

#include <condition_variable>
#include <fstream>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>
class ThreadPool { // 线程池
 public:
  ThreadPool(const ThreadPool &) = delete;
  ThreadPool &operator=(const ThreadPool &other) = delete; // 单例模式  禁用拷贝赋值构造
  ThreadPool(int thread_num) {
    this->_thread_num = thread_num;
    this->_is_running = false;
    this->num = 0;
  }
  typedef std::string Task;
  std::atomic_int num; // 原子操作数
  ~ThreadPool() {
    if (_is_running) {
      stop();
    }
  }
  void start() {
    _is_running = true;
    num = 0;
    for (int i = 0; i < _thread_num; i++) {
      _threads.emplace_back(std::thread(&ThreadPool::work, this));
    }
  }
  void stop() {
    while (!_tasks.empty()) {
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    { // 锁在花括号内生效  退出花括号就会析构
      std::unique_lock<std::mutex> lk(_mtx);
      _is_running = false;
      _cond.notify_all(); // 唤醒所有线程
    }
    for (std::thread &t : _threads) {
      if (t.joinable()) {
        t.join();
      }
    }
  }
  void appendTask(const Task &task) {
    if (_is_running) {
      std::unique_lock<std::mutex> lk(_mtx);
      _tasks.push(task);
      _cond.notify_one(); // 唤醒一个线程去做
    }
  }
  void out_task() { std::cout << _tasks.size() << std::endl; }

 private:
  std::atomic_bool _is_running;
  std::mutex _mtx;
  std::condition_variable _cond;
  int _thread_num;
  std::vector<std::thread> _threads;
  std::queue<Task> _tasks;
  void work() {
    while (_is_running) {
      Task task = "";
      {
        std::unique_lock<std::mutex> lk(_mtx);
        if (!_tasks.empty()) {
          task = _tasks.front();
          _tasks.pop();
        } else if (_is_running && _tasks.empty()) {
          _cond.wait(lk); // 休眠
        }
      }
      std::unique_lock<std::mutex> lk(_mtx);
      if (task.length()) {
        int len = task.length(), i;
        for (i = 0; i < len / 2; i++) {
          if (task[i] != task[len - i - 1]) {
            break;
          }
        }
        num += (int)(i == len / 2);
      }
    }
  }
};
void thread_read(std::string file_name,
                 std::shared_ptr<ThreadPool> thread_pool) {
  std::ifstream file(("./file/" + file_name).c_str(), std::ios::in);
  while (file.good()) {
    std::string s;
    getline(file, s);
    thread_pool->appendTask(s);
  }
  file.close()
}
int main() {
  std::shared_ptr<ThreadPool> thread_pool = std::make_shared<ThreadPool>(5);
  thread_pool->start();
  std::string file_name = "./file/file_name.txt";
  std::ifstream file(file_name.c_str(), std::ios::in);
  std::vector<std::thread> read_threads;
  while (file.good()) {
    std::string s;
    getline(file, s);
    read_threads.emplace_back(std::thread(&thread_read, s, thread_pool));
  }
  for (std::thread &t : read_threads) {
    if (t.joinable()) {
      t.join();
    }
  }
  thread_pool->stop();
  std::cout << thread_pool->num << std::endl;
  return 0;
}