C++模拟实现线程池及多线程原子打印

C++模拟实现线程池及多线程原子打印

#include <iostream>
#include <thread>
#include <vector>
#include <unordered_map>
#include <mutex>
#include <condition_variable>

using namespace std;

namespace myTest {

class Task {
public:
	template<typename FUNCTION, typename ...ARGS>
	Task(FUNCTION &&func, ARGS ...args) {
		func = bind(func, forward<ARGS>(args)...);
	}

	void run() {
		func();
		return ;
	}

	~Task() {}

private:
	function<void()> func;

};


class TreadPool {
public:
	TreadPool(int n = 5) {
		for ( int i = 0; i < n; i++ ) {
			threads.push_back(new thread(&worker_thread, this));  // 标注1
		}
	}

	template<typename FUNCTION, typename ...ARGS>
	void addOneTask(FUNCTION &&func, ARGS ...args) {
		unique_lock<mutex> lock(m_mutex);
		tasks.push(new Task(func, forward<ARGS>(args)...));
		m_cond.notify_one();
	}

    // 标注6
	void stop_thread() {
		thread::id id = this_thread::get_id();
		running[id] = false;
		return ;
	}

    // 标注5
	void stop() {
		for ( int i = 0; i < threads.size(); i++ ) {
			this->addOneTask(&stop_thread, this);
		}
		for ( auto t : threads ) {
			t->join();
		}
		return ;
	}


private:
	vector<thread *> threads;
	queue<Task *> tasks;
    unordered_map<thread::id, bool> running;
	mutex m_mutex;
	condition_variable m_cond;
	
	void worker_thread() {
		thread::id id = this_thread::get_id();  // 标注2
		running[id] = true;
		while ( running[id] ) {
			Task *t = this->getOneTask();
			t->run();
			delete t;
		}	
		return ;
	}

	Task *getOneTask() {
		unique_lock<mutex> lock(m_mutex);  // 标注3
		while ( tasks.empty() ) {
			m_cond.wait(lock);  // 标注4
		}
		Task *temp = tasks.front();
		tasks.pop();
		return temp;
	}
};

} // end of myTest

标注：

1. thread构造函数

   // Creates new thread object which does not represent a thread.
   thread() noexcept;
   
   // Move constructor. Constructs the thread object to represent the thread of execution that was represented by other. After this call other no longer represents a thread of execution.
   thread( thread&& other ) noexcept;
   
   // Creates new std::thread object and associates it with a thread of execution.
   template< class Function, class... Args >
   explicit thread( Function&& f, Args&&... args );
   
   // The copy constructor is de