linux线程池课程设计,线程池 · 嵌入式linux开发 · 看云

# C++ 11实现

```

#ifndef THREAD_POOL_H

#define THREAD_POOL_H

#include

#include

#include

#include

#include

#include

#include

#include

#include

class ThreadPool {

public:

ThreadPool(size_t);

template

auto enqueue(F&& f, Args&&... args)

-> std::future::type>;

~ThreadPool();

private:

// need to keep track of threads so we can join them

std::vector< std::thread > workers;

// the task queue

std::queue< std::function > tasks;

// synchronization

std::mutex queue_mutex;

std::condition_variable condition;

bool stop;

};

// the constructor just launches some amount of workers

inline ThreadPool::ThreadPool(size_t threads)

: stop(false)

{

for(size_t i = 0;i

workers.emplace_back(

[this]

{

for(;;)

{

std::function task;

{

std::unique_lock<:mutex> lock(this->queue_mutex);

this->condition.wait(lock,

[this]{ return this->stop || !this->tasks.empty(); });

if(this->stop && this->tasks.empty())

return;

task = std::move(this->tasks.front());

this->tasks.pop();

}

task();

}

}

);

}

// add new work item to the pool

template

auto ThreadPool::enqueue(F&& f, Args&&... args)

-> std::future::type>

{

using return_type = typename std::result_of::type;

auto task = std::make_shared< std::packaged_task >(

std::bind(std::forward(f), std::forward(args)...)

);

std::future res = task->get_future();

{

std::unique_lock<:mutex> lock(queue_mutex);

// don't allow enqueueing after stopping the pool

if(stop)

throw std::runtime_error("enqueue on stopped ThreadPool");

tasks.emplace([task](){ (*task)(); });

}

condition.notify_one();

return res;

}

// the destructor joins all threads

inline ThreadPool::~ThreadPool()

{

{

std::unique_lock<:mutex> lock(queue_mutex);

stop = true;

}

condition.notify_all();

for(std::thread &worker: workers)

worker.join();

}

#endif

```

## git hub地址

```

git@github.com:progschj/ThreadPool.git

```

# 使用

~~~

// create thread pool with 4 worker threads

ThreadPool pool(4);

// enqueue and store future

auto result = pool.enqueue([](int answer) { return answer; }, 42);

// get result from future

std::cout << result.get() << std::endl;

~~~

```

#include

#include

#include

#include "ThreadPool.h"

int main()

{

ThreadPool pool(4);

std::vector< std::future > results;

for(int i = 0; i < 8; ++i) {

results.emplace_back(

pool.enqueue([i] {

std::cout << "hello " << i << std::endl;

std::this_thread::sleep_for(std::chrono::seconds(1));

std::cout << "world " << i << std::endl;

return i*i;

})

);

}

for(auto && result: results)

std::cout << result.get() << ' ';

std::cout << std::endl;

return 0;

}

```