function test2_threadpool()

    local tp = Dll.MyTHdPool()

    local n =

    local function f()

        n = n+

        print('f ' .. n)

        if(n==) then return end

        tp:sleep1(, f)

    end

    f()

    tp:join()

end

#include "stdafx.h"

#include <luabind.hpp>

#include <vector>

#include <queue>

#include <boost/thread.hpp>

using namespace luabind;

#include "stdafx.h"

#include <boost/asio.hpp>

#include <boost/bind.hpp>

#include <boost/thread/thread.hpp>

#include <deque>

class ThreadPool

{

    boost::asio::io_service ioService;

    boost::thread_group threadpool;

    boost::asio::io_service::work work;

public:

    ThreadPool() :work(ioService)

    {

        /*

        * This will start the ioService processing loop. All tasks

        * assigned with ioService.post() will start executing.

        */

        //boost::asio::io_service::work work(ioService);

        /*

        * This will add  threads to the thread pool. (You could just put it in a for loop)

        */

        threadpool.create_thread(

            boost::bind(&boost::asio::io_service::run, &ioService)

            );

        threadpool.create_thread(

            boost::bind(&boost::asio::io_service::run, &ioService)

            );

    }

    ~ThreadPool()

    {

    }

    void post(boost::function<void()> f)

    {

        ioService.post(f);

    }

    void join()

    {

        threadpool.join_all();

    }

private:

};

namespace bamthread

{

    typedef std::unique_ptr<boost::asio::io_service::work> asio_worker;

    struct ThreadPool {

        ThreadPool(size_t threads) :service(), working(new asio_worker::element_type(service)) {

            while (threads--)

            {

                auto worker = boost::bind(&boost::asio::io_service::run, &(this->service));

                g.add_thread(new boost::thread(worker));

            }

        }

        template<class F>

        void post(F f){

            service.post(f);

        }

        ~ThreadPool() {

            working.reset(); //allow run() to exit

            g.join_all();

            service.stop();

        }

    private:

        boost::asio::io_service service; //< the io_service we are wrapping

        asio_worker working;

        boost::thread_group g; //< need to keep track of threads so we can join them

    };

}

void my_task()

{

    Sleep();

    printf("mytask");

}

void test1()

{

    bamthread::ThreadPool tp();

    tp.post(boost::bind(my_task));

    //tp.join();

}

void test()

{

    /*

    * Create an asio::io_service and a thread_group (through pool in essence)

    */

    boost::asio::io_service ioService;

    boost::thread_group threadpool;

    /*

    * This will start the ioService processing loop. All tasks

    * assigned with ioService.post() will start executing.

    */

    boost::asio::io_service::work work(ioService);

    /*

    * This will add  threads to the thread pool. (You could just put it in a for loop)

    */

    threadpool.create_thread(

        boost::bind(&boost::asio::io_service::run, &ioService)

        );

    threadpool.create_thread(

        boost::bind(&boost::asio::io_service::run, &ioService)

        );

    /*

    * This will assign tasks to the thread pool.

    * More about boost::bind: "http://www.boost.org/doc/libs/1_54_0/libs/bind/bind.html#with_functions"

    */

    ioService.post(boost::bind(my_task));

    /*

    * This will stop the ioService processing loop. Any tasks

    * you add behind this point will not execute.

    */

    ioService.stop();

    /*

    * Will wait till all the threads in the thread pool are finished with

    * their assigned tasks and 'join' them. Just assume the threads inside

    * the threadpool will be destroyed by this method.

    */

    threadpool.join_all();

}

template <typename T>

class queue

{

private:

    boost::mutex              d_mutex;

    boost::condition_variable d_condition;

    std::deque<T>           d_queue;

public:

    void push(T const& value) {

        {

            boost::unique_lock<boost::mutex> lock(this->d_mutex);

            d_queue.push_front(value);

        }

        this->d_condition.notify_one();

    }

    T pop() {

        boost::unique_lock<boost::mutex> lock(this->d_mutex);

        this->d_condition.wait(lock, [=]{ return !this->d_queue.empty(); });

        T rc(std::move(this->d_queue.back()));

        this->d_queue.pop_back();

        return rc;

    }

};

class MyTHdPool

{

    bamthread::ThreadPool tp;

    boost::mutex m;

    std::map<int, boost::function<void()> > f2s;    // key: taskid, value: post processing

    //boost::thread t_;

    queue<int> q_;

    int taskid_;

public:

    MyTHdPool() :tp(), taskid_(){}

    ~MyTHdPool(){

        join();

    }

    void Call(boost::function<void()> f1, boost::function<void()> f2)

    {

        int taskid = taskid_++;

        printf("begin call task %d\n", taskid);

        boost::function<void()> f = [=]() mutable {

            f1();

            q_.push(taskid);

            printf("done task %d\n", taskid);

        };

        {

            boost::lock_guard<boost::mutex> lock(m);

            f2s[taskid] = (f2);

        }

        tp.post(f);

        printf("end post task %d\n", taskid);

    }

    void join()

    {

        while (true)

        {

            boost::function<void()> f2;

            int taskid = ;

            {

                {

                    boost::lock_guard<boost::mutex> lock(m);

                    if (f2s.empty())

                        return;

                }

                printf("start pop a task from queue\n");

                int taskid = q_.pop();

                printf("got a task %d from queue\n", taskid);

                {

                    boost::lock_guard<boost::mutex> lock(m);

                    auto it = f2s.find(taskid);

                    assert(it != f2s.end());

                    f2 = it->second;

                    f2s.erase(it);

                }

            }

            printf("exec task post ftn %d\n", taskid);

            f2();

        }

    }

    void sleep1(double n, object f2)

    {

        Call([n](){Sleep(n * ); }, [f2, this]() mutable {

            f2();

        });

    }

    void sleep2(double n)

    {

        Call([n](){Sleep(n * ); }, [](){});

    }

private:

};

void callback(object o)

{

    printf("before callback\n");

    o();

    printf("after callback\n");

}

int luaopen_Dll(lua_State* L)

{

    luaL_openlibs(L);

    open(L);

    // define a module in _G["t"]

    module(L, "Dll")[

        class_<MyTHdPool>("MyTHdPool")

        .def(constructor<>())

        .def("sleep1", &MyTHdPool::sleep1)

        .def("sleep2", &MyTHdPool::sleep2)

        .def("join", &MyTHdPool::join),

        def("test1", &test1),

        def("callback", &callback)

    ];

    // push _G["t"] to stack

    lua_getglobal(L, "Dll");

    // set _G["t"]=nil

    lua_pushnil(L);

    lua_setglobal(L, "Dll");

    return ;

}