BOOST使用：1成员函数作为线程函数，编译不过示例 2线程组使用

1. 引入。 先上代码

// 本事件通信类应该支持一个事件的上半部、下半部方法的注册，以及cancel_event方法的注册。(或者不采用注册，而借助信号与槽)
// 外界可以通过本类对外提供的wake_event接口触发本类的do_event方法的执行。
// do_event方法内部如果需要等待资源，则可以调用wait_resource方法进行等待，外界使用wake_resource方法通知资源到位。

class indev_event_waiter{

    boost::condition_variable cond;    
    boost::mutex mutex;   

    int step;

    int event_t;
    void* p_event_t; // 

    int wait_event(){
    // 等待消息队列，取出事件类型

    }

    int wait_resource(){
        boost::unique_lock<boost::mutex> lock(mutex);
        cond.wait(lock); 
    }    


public:
    indev_event_waiter(int state): step(state){

    
    }
   
    void do_event_loop_thread(const int &id)
    {
        while(1)
        {
            switch(step) 
            {

                case s_start_init:
                {
                // 资源初始化


                    step = s_waitevent; 
                    break;
                }

                case s_waitevent:
                {
                    event_t = wait_event();       // 等待外部调用wake_event()方法
                    step = s_dofunc_part_up;
                    break;
                }

                case s_dofunc_part_up:  // 执行事件的上半部
                {
                        // 在这里添加事件的上半部的处理函数
                        // ...

                        // 可选方案：
                        // 借助信号与槽机制，将事件的上半部的处理函数作为槽函数，在此处维护一个信号或其引用？
                            
                    step = s_wait_resource; 
                    break;
                }   
                        
                case s_wait_resource: 
                {
                    int type = wait_resource();     // 等待外部调用wake_resource()方法   

                    if(type == t_resource_for_funcpartdown_gotready){
                        step = s_dofunc_part_down; 
                    }
                    else if(type == t_cancel_funcpartdown){      
                        step = s_waitevent;  
                    }

                    break;
                }
                case s_dofunc_part_down: // 执行事件的下半部
                {
                        // 在这里添加事件的下半部的处理函数
                // ...

                // 事件的下半部分完成以后，重新回到等待下一轮事件的状态。
                    step = s_waitevent; 
                    break;
                }  

                default:
                    break;
            }
        }
    }


    #if 1
    void create_event_loop(){

      // 这里应该执行获取消息队列中的消息(可以是，事件类型 或 纯数据，或者兼有)，
      // 然后执行对应的事件，事件进行异步处理(单独放在一个线程)
      // 比如：获取到事件类型，然后执行状态机的对应动作。event_invoke(EVENT_STOP) 这种。

        boost::thread t(do_event_loop_thread, 1);
        t.detach();   

    }
    #endif

    void wake_event(int event_t){
     // 这里应该执行向消息队列发送消息，同时传递事件类型
    
    
    }

    void wake_resource(int type){
        //唤醒资源的同时，可以传递消息。以便唤醒资源后执行不同的操作。
    }

    void cancel_funcpartdown(){ // 取消执行当前事件的下半部
        wake_resource(t_cancel_funcpartdown);

    }
   
};

这里产生了编译报错，104行是引发报错所在行： 本类的do_event_loop_thread成员函数不可以直接作为新创建线程的线程函数的实体。

解决办法：虽然本类的该非静态成员函数隐含了this指针，但我们仍需显示传入this指针。

下面展示解决方案的代码：

1:

创建线程，使用bind技术，来解决和上述demo一样的编译问题

#include <boost/thread/thread.hpp>

#include <boost/bind.hpp>
#include <iostream>
using namespace std;

#include <unistd.h>

class Count
{
public:
    Count();
    void addCount();
    void getCount();
    void mainThread();

    void print(int i);
private:
    typedef boost::mutex::scoped_lock slock;
    boost::mutex mutex;    //for count
        //boost::condition cond;
    int count;
};

Count::Count()
{
    this->count = 0;
}

void Count::addCount()
{
    
    while(1)
    {
      cout<<"--11111--"<<endl;
      sleep(1);  
    
      slock lock(this->mutex);
      this->count++;
    }
}

void Count::getCount()
{
    cout<<"--22222--"<<endl;

    slock lock(this->mutex);
    this->print(this->count);
}

void Count::mainThread()
{
    boost::thread thrd1(boost::bind(&Count::addCount, this));
    thrd1.detach();
}

void Count::print(int i)
{
    cout << "i = "<< i << endl;
}

int main()
{
    Count object;
    object.mainThread(); 
    object.getCount();   
    
    sleep(6);
    cout << "Process END!"<< endl;
    return 0;
}

2：

创建线程组，使用bind技术，来解决一样的编译问题

#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
using namespace std;
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/syscall.h> 

pid_t gettid()
{
    return syscall(SYS_gettid); /*这才是内涵*/
}

class CTestThread
{
public:
    CTestThread(int nNum):m_nThreadNum(nNum){}
    ~CTestThread(){}
 
    void TestThread(){
        printf("Thread ID %ld -- Thread Num: %d 
", gettid(), m_nThreadNum);
    }
 
    void BeginThread(){
        threadGroups.create_thread(boost::bind(&CTestThread::TestThread, this));
    }
private:
    int m_nThreadNum;
    boost::thread_group threadGroups;
};
int main(void)
{
 
    CTestThread t1(11);
    CTestThread t2(22);
    CTestThread t3(33);
    CTestThread t4(44);
 
    t1.BeginThread();
    t2.BeginThread();
    t3.BeginThread();
    t4.BeginThread();

    while(1){
        sleep(5); 
        cout << "pause" << endl;
        }


    return 0;
}

bind技术，看这里，参考 https://www.cnblogs.com/benxintuzi/p/4862129.html

 本次用到的知识点就是上述划红线处。

 

.