c++11自定义线程池

为了保证退出程序前，所有运行的线程都已经停止。我引入了信号量，对线程池进行改造。改造实现代码如下。

#pragma once
#include<queue>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<iostream>
#include"Semaphore.h"
using namespace std;

class Thread
{
public:
	typedef void(*TheadFuncion)();
	thread* th = nullptr;
	void* data;
	TheadFuncion func;
	bool exit = false;
	bool isThreadEnd = false;
	bool idle = true;

	Semaphore taskSemaphore;
	Semaphore quitSemaphore;

	void Func()
	{
		isThreadEnd = false;
		while (!exit) {
			this->func();
			idle = true;
			taskSemaphore.wait();
		}

		isThreadEnd = true;
		quitSemaphore.signal();
	}

	bool Start(Thread::TheadFuncion func)
	{
		if (!idle) {
			return false;
		}
		idle = false;
		this->func = func;

		if (nullptr == th) {
			th = new thread([&]() {
				Func();
			});
			th->detach();
		}
		else {
			taskSemaphore.signal();
		}
		return true;
	}

	bool IsIdle() {
		return idle;
	}

	void Stop()
	{
		exit = true;
		if (!isThreadEnd) {
			taskSemaphore.signal();
			quitSemaphore.wait();
		}
		delete th;
	}

	Thread(){
	}

	~Thread(){
		if (nullptr == th) {
			exit = true;
		}else {
			if (!exit) {
				Stop();
			}
		}
	}
};



class ThreadPool
{
public:
	vector<Thread*> threads;
	typedef std::vector<Thread*>::iterator Iterator;
	mutex mtx;
	bool isEnd = false;

public:
	ThreadPool(int threadCount)
	{
		for (int i = 0; i < threadCount; i++) {
			Thread* thread = new Thread();
			threads.push_back(thread);
		}
	}

	~ThreadPool() {
		Iterator iter = threads.begin();
		while (iter != threads.end()) {
			if (nullptr != *iter) {
				delete *iter;
				iter = threads.erase(iter);
			}
			else {
				iter++;
			}
		}
		isEnd = true;
	}

	bool Add(Thread::TheadFuncion func) {
		mtx.lock();
		Iterator iter = threads.begin();
		bool isAddOk = false;
		while (iter != threads.end()) {
			if ((*iter)->IsIdle()) {
				isAddOk = (*iter)->Start(func);
				if (!isAddOk) {
					iter++;
				}
				else {
					break;
				}
			}
			else {
				iter++;
			}
		}
		mtx.unlock();
		return isAddOk;
	}

};

 信号量实现代码如下:

#include <mutex>
#include <condition_variable>
#include<iostream>
using namespace std;

class Semaphore {
private:
	int count;
	int wakeups;
	std::mutex mutex;
	std::condition_variable condition;


public:
	Semaphore(int value = 0) :count(value), wakeups(0) {}

	void wait() {
		std::unique_lock<std::mutex> lock(mutex);
		if (--count < 0) {
			condition.wait(lock, [&]()->bool {return wakeups > 0; });
			--wakeups;
		}
	}

	void signal() {
		std::lock_guard<std::mutex> lock(mutex);
		if (++count <= 0) {
			++wakeups;
			condition.notify_one();
		}
	}
};

信号量代码引用链接：

http://www.360doc.com/content/15/0303/20/203028_452313531.shtml