linux c++自己使用pthread封装的线程类

#include<iostream>
#include<pthread.h>
#include<unistd.h>

using namespace std;

//typedef void *(*methodFunction)(void *);

class CThread
{
    public:
    CThread();
    ~CThread();
    void run();
    int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
    void wait();
    private:
    void *(*m_WorkFunction)(void *);
    void *m_args;
    pthread_t m_thread;
    int m_count;
    int m_state;
};

CThread::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(0),
m_count(0)
{    
}

CThread::~CThread()
{
    m_WorkFunction = NULL;
    m_args = NULL;
    m_state = 0;
}

void CThread::run()
{
    m_state = pthread_create(&m_thread, NULL, m_WorkFunction,m_args);
}

void CThread::wait()
{
    if( 0 == m_state)
    {
        pthread_join(m_thread, NULL);
    }
}

int CThread::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
    if(args != NULL)
    {
        m_args = args;
    }
    m_WorkFunction = methodFunction;
    
    return 0;
}

void * thread_work(void*)
{
    for ( int i = 0; i < 20; i++)
    {
        cout << "the thread output the number:"<<i<< endl;
    }
}

int main(int argc, char * argv[])
{
    cout << "test for thread class" <<endl;
    CThread T;
    T.setWorkMethod(thread_work);
    T.run();
    T.wait();
    cout << "the process ending"<< endl;
    return 0;
}

 //demo2: 传入相应参数

#include<iostream>
#include<pthread.h>
#include<unistd.h>

using namespace std;

//typedef void *(*methodFunction)(void *);

class CThread
{
    public:
    CThread();
    ~CThread();
    void run();
    int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
    void wait();
    private:
    void *(*m_WorkFunction)(void *);
    void *m_args;
    pthread_t m_thread;
    int m_count;
    int m_state;
};

CThread::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(0),
m_count(0)
{    
}

CThread::~CThread()
{
    m_WorkFunction = NULL;
    m_args = NULL;
    m_state = 0;
}

void CThread::run()
{
    m_state = pthread_create(&m_thread, NULL, m_WorkFunction,m_args);
}

void CThread::wait()
{
    if( 0 == m_state)
    {
        pthread_join(m_thread, NULL);
    }
}

int CThread::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
    if(args != NULL)
    {
        m_args = args;
    }
    m_WorkFunction = methodFunction;
    
    return 0;
}

void * thread_work(void* args)
{
    for ( int i = 0; i < 20; i++)
    {
        cout << "the thread output the number:"<<i<< (char*) args<<endl;
    }
}

int main(int argc, char * argv[])
{
    cout << "test for thread class" <<endl;
    CThread T;
    T.setWorkMethod(thread_work, (void *)"hellowrold");
    T.run();
    T.wait();
    cout << "the process ending"<< endl;
    return 0;
}

 //demo3:抛出发送信息

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>

using namespace std;
struct MSG
{
    MSG():
    _msg_count(0),
    _msg_str_message("")
    {}
    int _msg_count;
    std::string _msg_str_message;
};
//typedef void *(*methodFunction)(void *);

class CThread
{
public:
    CThread();
    ~CThread();
    void run();
    int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
    int setSleepTimeForSeconds(int sec);
    void sendMessage(void *(*dealMessageFunction)(MSG *), void* type = NULL);
    void stop();
    void wait();
private:
    static void * func_workFunction(void * args);
    void *(*m_WorkFunction)(void *);
    void *m_args;
    pthread_t m_thread;
    int m_count;
    int m_state;
    bool m_destroy;
    int m_sleepSeconds;
    MSG m_msg;
};

CThread::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(0),
m_count(0),
m_sleepSeconds(2),
m_destroy(false)
{    
    m_msg._msg_count = 1;
    m_msg._msg_str_message ="this is a message";
}

CThread::~CThread()
{
    m_WorkFunction = NULL;
    m_args = NULL;
    m_state = 0;
}

void CThread::run()
{
    m_state = pthread_create(&m_thread, NULL, func_workFunction, this);
}

void CThread::wait()
{
    if( 0 == m_state)
    {
        pthread_join(m_thread, NULL);
    }
}
void *  CThread::func_workFunction(void * args)
{
    CThread * ptrCThread = (CThread *)args;
    while(NULL == ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
    {
        cout << "the thread do nothing, sleep "<< ptrCThread->m_sleepSeconds<<" seconds" << endl;
        sleep(ptrCThread->m_sleepSeconds);
    }
    if(NULL != ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
    {
        //cout << "DEBUG:run the function "<< endl;
        ptrCThread->m_WorkFunction(ptrCThread->m_args);
        //cout << "DEBUG:end the function "<< endl;
    }
}

int CThread::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
    if(args != NULL)
    {
        m_args = args;
    }
    m_WorkFunction = methodFunction;
    //cout << "DEBUG:set method "<< endl;
    return 0;
}
void CThread::sendMessage(void *(*dealMessageFunction)(MSG *), void* type)
{
    if(!m_msg._msg_str_message.empty())
    {
        if(NULL == type)
        {
            dealMessageFunction(&m_msg);
        }else
        {
            
        }
    }
}


int CThread::setSleepTimeForSeconds(int sec)
{
    if(sec > 0)
    {
        m_sleepSeconds = sec;
    }
}
void CThread::stop()
{
    m_destroy = true;
}

void * thread_work(void* args)
{
    for ( int i = 0; i < 20; i++)
    {
        cout << "the thread output the number: "<< i <<" "<< (char*) args<<endl;
    }
}

void * dealwithMessage(MSG * msg)
{
    MSG tmpMsg;
    tmpMsg._msg_count = msg->_msg_count;
    tmpMsg._msg_str_message = msg->_msg_str_message;
    
    cout << "[INFO]***get the message from the thread***:"<< tmpMsg._msg_str_message << endl;
}

void * tread_work1(void *args)
{
    for( int i = 0; i< 40; i++)
    {
        cout <<"another tread output: "<< i <<"  "<<(char*) args<< std::endl;
    }
}

int main(int argc, char * argv[])
{
    cout << "test for thread class" <<endl;
    CThread T;CThread T1;
    //T.setWorkMethod(thread_work, (void *)"hellowrold");
    T.run();
    T1.run();T1.setWorkMethod(tread_work1, (void*)"wssdsfsafa");
    T1.sendMessage(dealwithMessage);
    sleep(6);
    T.setWorkMethod(thread_work, (void *)"hellowrold");
    T.wait();
    T1.wait();
    cout << "the process ending"<< endl;
    return 0;
}

//demo4: 线程调用类方法执行

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>

using namespace std;
struct MSG
{
	MSG():
	_msg_count(0),
	_msg_str_message("")
	{}
	int _msg_count;
	std::string _msg_str_message;
};
//typedef void *(*methodFunction)(void *);
class CWork
{
public:
	CWork();
	~CWork();
	void init(void *);
};
class CThread
{
public:
	CThread();
	~CThread();
	void run();
	int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
	int setWorkMethod(CWork & t, void * args = NULL);
	// int setWorkMethod(const T *t, void * args = NULL);
	int setSleepTimeForSeconds(int sec);
	void sendMessage(void *(*dealMessageFunction)(MSG *), void* type = NULL);
	void stop();
	void wait();
private:
	static void * func_workFunction(void * args);
	void *(*m_WorkFunction)(void *);
	void *m_args;
	pthread_t m_thread;
	int m_count;
	int m_state;
	bool m_destroy;
	int m_sleepSeconds;
	CWork *ptrCWork;
	MSG m_msg;
};

CThread::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(0),
m_count(0),
m_sleepSeconds(2),
m_destroy(false),
ptrCWork(NULL)
{	
	m_msg._msg_count = 1;
	m_msg._msg_str_message ="this is a message";
}

CThread::~CThread()
{
	m_WorkFunction = NULL;
	m_args = NULL;
	m_state = 0;
}

void CThread::run()
{
	m_state = pthread_create(&m_thread, NULL, func_workFunction, this);
}

void CThread::wait()
{
	if( 0 == m_state)
	{
		pthread_join(m_thread, NULL);
	}
}
void *  CThread::func_workFunction(void * args)
{
	CThread * ptrCThread = (CThread *)args;
	while(NULL == ptrCThread->m_WorkFunction && !ptrCThread->m_destroy && ptrCThread->ptrCWork == NULL)
	{
		cout << "the thread do nothing, sleep "<< ptrCThread->m_sleepSeconds<<" seconds" << endl;
		sleep(ptrCThread->m_sleepSeconds);
	}
	if(NULL != ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
	{
		//cout << "DEBUG:run the function "<< endl;
		ptrCThread->m_WorkFunction(ptrCThread->m_args);
		//cout << "DEBUG:end the function "<< endl;
	}else if(NULL !=ptrCThread->ptrCWork && !ptrCThread->m_destroy)
	{
		ptrCThread->ptrCWork->init(ptrCThread->m_args);
	}
}

int CThread::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
	if(args != NULL)
	{
		m_args = args;
	}
	m_WorkFunction = methodFunction;
	//cout << "DEBUG:set method "<< endl;
	return 0;
}
int CThread::setWorkMethod( CWork &  t, void * args)
{
	if(args != NULL)
	{
		m_args = args;
	}
	ptrCWork = &t;
}
// int CThread::setWorkMethod(const  T *t, void * args)
// {
	// T * ptrClass = (T*)t;
	// ptrClass->init(args);
// }
void CThread::sendMessage(void *(*dealMessageFunction)(MSG *), void* type)
{
	if(!m_msg._msg_str_message.empty())
	{
		if(NULL == type)
		{
			dealMessageFunction(&m_msg);
		}else
		{
			
		}
	}
}


int CThread::setSleepTimeForSeconds(int sec)
{
	if(sec > 0)
	{
		m_sleepSeconds = sec;
	}
}
void CThread::stop()
{
	m_destroy = true;
}

void * thread_work(void* args)
{
	for ( int i = 0; i < 20; i++)
	{
		cout << "the thread output the number: "<< i <<" "<< (char*) args<<endl;
	}
}

void * dealwithMessage(MSG * msg)
{
	MSG tmpMsg;
	tmpMsg._msg_count = msg->_msg_count;
	tmpMsg._msg_str_message = msg->_msg_str_message;
	
	cout << "[INFO]***get the message from the thread***:"<< tmpMsg._msg_str_message << endl;
}

void * tread_work1(void *args)
{
	for( int i = 0; i< 40; i++)
	{
		cout <<"another tread output: "<< i <<"  "<<(char*) args<< std::endl;
	}
}

CWork::CWork(){}
CWork::~CWork(){}
void CWork::init(void * args)
{
	cout << "this is the class function result: "<< (char*)args <<endl;
}

int main(int argc, char * argv[])
{
	cout << "test for thread class" <<endl;
	CThread T;
	CWork work;
	//T.setWorkMethod(thread_work, (void *)"hellowrold");
	T.run();
	sleep(6);
	// T.setWorkMethod(thread_work, (void *)"hellowrold");
	T.setWorkMethod(work, (void *)"hellowrold");
	// T.setWorkMethod(&work, (void *)"hellowrold");
	T.wait();
	cout << "the process ending"<< endl;
	return 0;
}

　//demo4:使用类模板方式，线程调用类方法

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>

using namespace std;
struct MSG
{
    MSG():
    _msg_count(0),
    _msg_str_message("")
    {}
    int _msg_count;
    std::string _msg_str_message;
};
//typedef void *(*methodFunction)(void *);
template<typename T>
class CThread
{
public:
    CThread();
    ~CThread();
    void run();
    int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
    int setWorkMethod(T & t, void * args = NULL);
    int setSleepTimeForSeconds(int sec);
    void sendMessage(void *(*dealMessageFunction)(MSG *), void* type = NULL);
    void stop();
    void wait();
private:
    static void * func_workFunction(void * args);
    void *(*m_WorkFunction)(void *);
    void *m_args;
    pthread_t m_thread;
    int m_count;
    int m_state;
    bool m_destroy;
    int m_sleepSeconds;
    MSG m_msg;
    T * m_ptrClass;
};

template<typename T>
CThread<T>::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(0),
m_count(0),
m_sleepSeconds(2),
m_destroy(false),
m_ptrClass(NULL)
{    
    m_msg._msg_count = 1;
    m_msg._msg_str_message ="this is a message";
}

template<typename T>
CThread<T>::~CThread()
{
    m_WorkFunction = NULL;
    m_args = NULL;
    m_state = 0;
}

template<typename T>
void CThread<T>::run()
{
    m_state = pthread_create(&m_thread, NULL, func_workFunction, this);
}

template<typename T>
void CThread<T>::wait()
{
    if( 0 == m_state)
    {
        pthread_join(m_thread, NULL);
    }
}
template<typename T>
void *  CThread<T>::func_workFunction(void * args)
{
    CThread<T> * ptrCThread = (CThread<T> *)args;
    while(NULL == ptrCThread->m_WorkFunction && !ptrCThread->m_destroy && ptrCThread->m_ptrClass == NULL)
    {
        cout << "the thread do nothing, sleep "<< ptrCThread->m_sleepSeconds<<" seconds" << endl;
        sleep(ptrCThread->m_sleepSeconds);
    }
    if(NULL != ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
    {
        //cout << "DEBUG:run the function "<< endl;
        ptrCThread->m_WorkFunction(ptrCThread->m_args);
        //cout << "DEBUG:end the function "<< endl;
    }else if(NULL !=ptrCThread->m_ptrClass && !ptrCThread->m_destroy)
    {
        ptrCThread->m_ptrClass->init(ptrCThread->m_args);
    }
}

template<typename T>
int CThread<T>::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
    if(args != NULL)
    {
        m_args = args;
    }
    m_WorkFunction = methodFunction;
    //cout << "DEBUG:set method "<< endl;
    return 0;
}
template<typename T>
int CThread<T>::setWorkMethod( T & t, void * args)
{
    if(args != NULL)
    {
        m_args = args;
    }
    m_ptrClass = &t;
}
template<typename T>
void CThread<T>::sendMessage(void *(*dealMessageFunction)(MSG *), void* type)
{
    if(!m_msg._msg_str_message.empty())
    {
        if(NULL == type)
        {
            dealMessageFunction(&m_msg);
        }else
        {
            
        }
    }
}

template<typename T>
int CThread<T>::setSleepTimeForSeconds(int sec)
{
    if(sec > 0)
    {
        m_sleepSeconds = sec;
    }
}

template<typename T>
void CThread<T>::stop()
{
    m_destroy = true;
}

void * thread_work(void* args)
{
    for ( int i = 0; i < 20; i++)
    {
        cout << "the thread output the number: "<< i <<" "<< (char*) args<<endl;
    }
}

void * dealwithMessage(MSG * msg)
{
    MSG tmpMsg;
    tmpMsg._msg_count = msg->_msg_count;
    tmpMsg._msg_str_message = msg->_msg_str_message;
    
    cout << "[INFO]***get the message from the thread***:"<< tmpMsg._msg_str_message << endl;
}

void * tread_work1(void *args)
{
    for( int i = 0; i< 40; i++)
    {
        cout <<"another tread output: "<< i <<"  "<<(char*) args<< std::endl;
    }
}

class CWork
{
public:
    CWork();
    ~CWork();
    void init(void *);
};
CWork::CWork(){}
CWork::~CWork(){}
void CWork::init(void * args)
{
    cout << "this is the class function "<< (char*)args <<endl;
}

int main(int argc, char * argv[])
{
    cout << "test for thread class" <<endl;
    CThread<CWork> T;
    CWork work;
    //T.setWorkMethod(thread_work, (void *)"hellowrold");
    T.run();
    sleep(6);
    //T.setWorkMethod(thread_work, (void *)"hellowrold");
    T.setWorkMethod(work, (void *)"hellowrold");
    // T.setWorkMethod(&work, (void *)"hellowrold");
    T.wait();
    cout << "the process ending"<< endl;
    return 0;
}

 // worker is changed

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>

#define FREE 0
#define BUSY 1
using namespace std;
struct MSG
{
    MSG():
    _msg_count(0),
    _msg_str_message("")
    {}
    int _msg_count;
    std::string _msg_str_message;
};
//typedef void *(*methodFunction)(void *);
template<typename T>
class CThread
{
public:
    CThread();
    ~CThread();
    void run();
    int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
    int setWorkMethod(T & t, void * args = NULL);
    int setSleepTimeForSeconds(int sec);
    void sendMessage(void *(*dealMessageFunction)(MSG *), void* type = NULL);
    void stop();
    void wait();
private:
    static void * func_workFunction(void * args);
    void *(*m_WorkFunction)(void *);
    void *m_args;
    pthread_t m_thread;
    int m_count;
    int m_state;
    bool m_destroy;
    int m_sleepSeconds;
    MSG m_msg;
    T * m_ptrClass;
};

template<typename T>
CThread<T>::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(0),
m_count(0),
m_sleepSeconds(2),
m_destroy(false),
m_ptrClass(NULL)
{
    m_msg._msg_count = 1;
    m_msg._msg_str_message ="this is a message";
}

template<typename T>
CThread<T>::~CThread()
{
    m_WorkFunction = NULL;
    m_args = NULL;
    m_state = 0;
}

template<typename T>
void CThread<T>::run()
{
    m_state = pthread_create(&m_thread, NULL, func_workFunction, this);
}

template<typename T>
void CThread<T>::wait()
{
    if( 0 == m_state)
    {
        pthread_join(m_thread, NULL);
    }
}
template<typename T>
void *  CThread<T>::func_workFunction(void * args)
{
    CThread<T> * ptrCThread = (CThread<T> *)args;
    while(NULL == ptrCThread->m_WorkFunction && !ptrCThread->m_destroy && ptrCThread->m_ptrClass == NULL)
    {
        cout << "the thread do nothing, sleep "<< ptrCThread->m_sleepSeconds<<" seconds" << endl;
        sleep(ptrCThread->m_sleepSeconds);
    }
    if(NULL != ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
    {
        //cout << "DEBUG:run the function "<< endl;
        ptrCThread->m_WorkFunction(ptrCThread->m_args);
        //cout << "DEBUG:end the function "<< endl;
    }else if(NULL !=ptrCThread->m_ptrClass && !ptrCThread->m_destroy)
    {
        ptrCThread->m_ptrClass->init(ptrCThread->m_args);
    }
}

template<typename T>
int CThread<T>::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
    if(args != NULL)
    {
        m_args = args;
    }
    m_WorkFunction = methodFunction;
    //cout << "DEBUG:set method "<< endl;
    return 0;
}
template<typename T>
int CThread<T>::setWorkMethod( T & t, void * args)
{
    if(args != NULL)
    {
        m_args = args;
    }
    m_ptrClass = &t;
}
template<typename T>
void CThread<T>::sendMessage(void *(*dealMessageFunction)(MSG *), void* type)
{
    if(!m_msg._msg_str_message.empty())
    {
        if(NULL == type)
        {
            dealMessageFunction(&m_msg);
        }else
        {

        }
    }
}

template<typename T>
int CThread<T>::setSleepTimeForSeconds(int sec)
{
    if(sec > 0)
    {
        m_sleepSeconds = sec;
    }
}

template<typename T>
void CThread<T>::stop()
{
    m_destroy = true;
}

void * thread_work(void* args)
{
    for ( int i = 0; i < 20; i++)
    {
        cout << "the thread output the number: "<< i <<" "<< (char*) args<<endl;
    }
}

void * dealwithMessage(MSG * msg)
{
    MSG tmpMsg;
    tmpMsg._msg_count = msg->_msg_count;
    tmpMsg._msg_str_message = msg->_msg_str_message;

    cout << "[INFO]***get the message from the thread***:"<< tmpMsg._msg_str_message << endl;
}

void * tread_work1(void *args)
{
    for( int i = 0; i< 40; i++)
    {
        cout <<"another tread output: "<< i <<"  "<<(char*) args<< std::endl;
    }
}

class CWork
{
public:
    CWork();
    ~CWork();
    void init(void *);
    void start(char * args = NULL);
private:
    int m_state;
    string m_strMsg;
};
CWork::CWork():m_state(FREE){}
CWork::~CWork(){}
void CWork::init(void * args)
{
    while(m_state == FREE)
    {
        cout << "this is the class work function "<< (char*)args <<endl;
        sleep(1);
        cout << "wait msg"<<endl;
    }
    while(m_state == BUSY)
    {
        cout << "the work start wokrking, the work message is :"<< m_strMsg<<endl;
        sleep(1);

    }
    /*
    for( int i = 0; i < 100 ; i++)
    {
        cout << "the work start wokrking, the work message is :"<< m_strMsg<<endl;
    }
    */

}
void CWork::start(char * args)
{
    if( NULL == args)
    {
        std::cout <<"the start args is none, so nothing to do "<< std::endl;
    }else
    {
        m_strMsg = args;
        m_state = BUSY;
    }
}
int main(int argc, char * argv[])
{
    cout << "test for thread class" <<endl;
    CThread<CWork> T;
    CWork work;
    T.run();
     for(int i =0;i <10; i++)
    {
     std::cout << "main thread message:first -----" <<i <<std::endl;
    }

    sleep(6);
    cout<<"********set the thread worker"<<endl;
    T.setWorkMethod(work, (void *)"hellowrold");
    for(int i =0;i <10; i++)
    {
     std::cout << "main thread message:second -----" <<i <<std::endl;
    }
    string strinput;
    while(cin>>strinput)
    {
        cout << strinput << endl;
        if(strinput.compare("q") == 0)
            break;
    }
    cout<<"********set the  worker start state"<<endl;
    work.start("we have a good way to work");
    strinput.clear();
    while(cin>>strinput)
    {
        cout << strinput << endl;
        if(strinput.compare("q") == 0)
            break;
    }
    for(int i =0;i <100; i++)
    {
     std::cout << "main thread message:" <<i <<std::endl;
    }
   // sleep(6);
    //T.stop();
    T.wait();
    cout << "the process ending"<< endl;
    return 0;
}