C++两种线程模式：委托和继承（附示例）
时间:2022-06-06
本文章向大家介绍C++两种线程模式：委托和继承（附示例），主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。
继承方式实现简单，请参见：https://github.com/eyjian/mooon/blob/master/common_library/include/mooon/sys/thread.h 在C++11标准之前的实现较为复杂（可参见：https://github.com/eyjian/mooon/blob/master/common_library/include/mooon/sys/thread_engine.h）： 委托版本使用非常简单：
static void hello(int m, int n)
{
printf("[%u] hello: %d/%dn", pthread_self(), m, n);
}
class X
{
public:
void world(int m, int n, int l)
{
printf("[%u] X::world: %d/%d/%dn", pthread_self(), m, n, l);
}
};
int main()
{
X* x2 = new X;
// 带2个参数
CThreadEngine engine9(bind(&hello, 2015, 5));
// 带3个参数
CThreadEngine engine16(bind(&X::world, x2, 2016, 5, 3));
return 0;
}
委托版本实现：
#ifndef MOOON_SYS_THREAD_ENGINE_H
#define MOOON_SYS_THREAD_ENGINE_H
// 如果测试，请不需注释掉TEST_THREAD_ENGINE的定义
//#define TEST_THREAD_ENGINE 1
#if !defined(TEST_THREAD_ENGINE)
#include "mooon/sys/config.h" // 如果需要脱离mooon运行，请注释掉这行
#endif // TEST_THREAD_ENGINE
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#if defined(TEST_THREAD_ENGINE)
#define SYS_NAMESPACE_BEGIN
#define SYS_NAMESPACE_END
#endif // TEST_THREAD_ENGINE
SYS_NAMESPACE_BEGIN
// 基类
class Function
{
public:
virtual ~Function() {}
virtual void operator ()() = 0;
};
////////////////////////////////////////////////////////////////////////////////
// 不带参数
class FunctionWithoutParameter: public Function
{
public:
// 不使用返回值，所以不需要返回值，否则将void替换成需要的类型
typedef void (*FunctionPtr)();
FunctionWithoutParameter(FunctionPtr function_ptr)
: _function_ptr(function_ptr)
{
}
virtual void operator ()()
{
(*_function_ptr)();
}
private:
FunctionPtr _function_ptr;
};
template <class ObjectType>
class MemberFunctionWithoutParameter: public Function
{
public:
typedef void (ObjectType::*MemberFunctionPtr)();
MemberFunctionWithoutParameter(MemberFunctionPtr member_function_ptr, ObjectType* object)
: _member_function_ptr(member_function_ptr), _object(object)
{
}
virtual void operator ()()
{
(_object->*_member_function_ptr)();
}
private:
MemberFunctionPtr _member_function_ptr;
ObjectType* _object;
};
////////////////////////////////////////////////////////////////////////////////
// 带1个参数
template <typename ParameterType>
class FunctionWith1Parameter: public Function
{
public:
typedef void (*FunctionPtr)(ParameterType);
FunctionWith1Parameter(FunctionPtr function_ptr, ParameterType parameter)
: _function_ptr(function_ptr), _parameter(parameter)
{
}
virtual void operator ()()
{
(*_function_ptr)(_parameter);
}
private:
FunctionPtr _function_ptr;
ParameterType _parameter;
};
template <class ObjectType, typename ParameterType>
class MemberFunctionWith1Parameter: public Function
{
public:
typedef void (ObjectType::*MemberFunctionPtr)(ParameterType);
MemberFunctionWith1Parameter(MemberFunctionPtr member_function_ptr, ObjectType* object, ParameterType parameter)
: _member_function_ptr(member_function_ptr), _object(object), _parameter(parameter)
{
}
virtual void operator ()()
{
(_object->*_member_function_ptr)(_parameter);
}
private:
MemberFunctionPtr _member_function_ptr;
ObjectType* _object;
ParameterType _parameter;
};
////////////////////////////////////////////////////////////////////////////////
// 带2个参数
template <typename Parameter1Type, typename Parameter2Type>
class FunctionWith2Parameter: public Function
{
public:
typedef void (*FunctionPtr)(Parameter1Type, Parameter2Type);
FunctionWith2Parameter(FunctionPtr function_ptr, Parameter1Type parameter1, Parameter2Type parameter2)
: _function_ptr(function_ptr), _parameter1(parameter1), _parameter2(parameter2)
{
}
virtual void operator ()()
{
(*_function_ptr)(_parameter1, _parameter2);
}
private:
FunctionPtr _function_ptr;
Parameter1Type _parameter1;
Parameter2Type _parameter2;
};
template <class ObjectType, typename Parameter1Type, typename Parameter2Type>
class MemberFunctionWith2Parameter: public Function
{
public:
typedef void (ObjectType::*MemberFunctionPtr)(Parameter1Type, Parameter2Type);
MemberFunctionWith2Parameter(MemberFunctionPtr member_function_ptr, ObjectType* object, Parameter1Type parameter1, Parameter2Type parameter2)
: _member_function_ptr(member_function_ptr), _object(object), _parameter1(parameter1), _parameter2(parameter2)
{
}
virtual void operator ()()
{
(_object->*_member_function_ptr)(_parameter1, _parameter2);
}
private:
MemberFunctionPtr _member_function_ptr;
ObjectType* _object;
Parameter1Type _parameter1;
Parameter2Type _parameter2;
};
////////////////////////////////////////////////////////////////////////////////
// 带3个参数
template <typename Parameter1Type, typename Parameter2Type, typename Parameter3Type>
class FunctionWith3Parameter: public Function
{
public:
typedef void (*FunctionPtr)(Parameter1Type, Parameter2Type, Parameter3Type);
FunctionWith3Parameter(FunctionPtr function_ptr, Parameter1Type parameter1, Parameter2Type parameter2, Parameter3Type parameter3)
: _function_ptr(function_ptr), _parameter1(parameter1), _parameter2(parameter2), _parameter3(parameter3)
{
}
virtual void operator ()()
{
(*_function_ptr)(_parameter1, _parameter2, _parameter3);
}
private:
FunctionPtr _function_ptr;
Parameter1Type _parameter1;
Parameter2Type _parameter2;
Parameter3Type _parameter3;
};
template <class ObjectType, typename Parameter1Type, typename Parameter2Type, typename Parameter3Type>
class MemberFunctionWith3Parameter: public Function
{
public:
typedef void (ObjectType::*MemberFunctionPtr)(Parameter1Type, Parameter2Type, Parameter3Type);
MemberFunctionWith3Parameter(MemberFunctionPtr member_function_ptr, ObjectType* object, Parameter1Type parameter1, Parameter2Type parameter2, Parameter3Type parameter3)
: _member_function_ptr(member_function_ptr), _object(object), _parameter1(parameter1), _parameter2(parameter2), _parameter3(parameter3)
{
}
virtual void operator ()()
{
(_object->*_member_function_ptr)(_parameter1, _parameter2, _parameter3);
}
private:
MemberFunctionPtr _member_function_ptr;
ObjectType* _object;
Parameter1Type _parameter1;
Parameter2Type _parameter2;
Parameter3Type _parameter3;
};
////////////////////////////////////////////////////////////////////////////////
class Functor
{
public:
Functor()
: _function(NULL)
{
}
Functor(const Functor& other)
{
_function = other._function;
Functor& mutable_other = const_cast<Functor&>(other);
mutable_other._function = NULL;
}
~Functor()
{
delete _function;
}
Functor& operator =(const Functor& other)
{
_function = other._function;
Functor& mutable_other = const_cast<Functor&>(other);
mutable_other._function = NULL;
return *this;
}
void operator ()()
{
(*_function)();
}
// 不带参数
Functor(FunctionWithoutParameter::FunctionPtr function_ptr)
{
_function = new FunctionWithoutParameter(function_ptr);
}
template <class ObjectType>
Functor(typename MemberFunctionWithoutParameter<ObjectType>::MemberFunctionPtr member_function_ptr, ObjectType* object)
{
_function = new MemberFunctionWithoutParameter<ObjectType>(member_function_ptr, object);
}
// 带1个参数
template <typename ParameterType>
Functor(typename FunctionWith1Parameter<ParameterType>::FunctionPtr function_ptr, ParameterType parameter)
{
_function = new FunctionWith1Parameter<ParameterType>(function_ptr, parameter);
}
template <class ObjectType, typename ParameterType>
Functor(typename MemberFunctionWith1Parameter<ObjectType, ParameterType>::MemberFunctionPtr member_function_ptr, ObjectType* object, ParameterType parameter)
{
_function = new MemberFunctionWith1Parameter<ObjectType, ParameterType>(member_function_ptr, object, parameter);
}
// 带2个参数
template <typename Parameter1Type, typename Parameter2Type>
Functor(typename FunctionWith2Parameter<Parameter1Type, Parameter2Type>::FunctionPtr function_ptr, Parameter1Type parameter1, Parameter2Type parameter2)
{
_function = new FunctionWith2Parameter<Parameter1Type, Parameter2Type>(function_ptr, parameter1, parameter2);
}
template <class ObjectType, typename Parameter1Type, typename Parameter2Type>
Functor(typename MemberFunctionWith2Parameter<ObjectType, Parameter1Type, Parameter2Type>::MemberFunctionPtr member_function_ptr, ObjectType* object, Parameter1Type parameter1, Parameter2Type parameter2)
{
_function = new MemberFunctionWith2Parameter<ObjectType, Parameter1Type, Parameter2Type>(member_function_ptr, object, parameter1, parameter2);
}
// 带3个参数
template <typename Parameter1Type, typename Parameter2Type, typename Parameter3Type>
Functor(typename FunctionWith3Parameter<Parameter1Type, Parameter2Type, Parameter3Type>::FunctionPtr function_ptr, Parameter1Type parameter1, Parameter2Type parameter2, Parameter3Type parameter3)
{
_function = new FunctionWith3Parameter<Parameter1Type, Parameter2Type, Parameter3Type>(function_ptr, parameter1, parameter2, parameter3);
}
template <class ObjectType, typename Parameter1Type, typename Parameter2Type, typename Parameter3Type>
Functor(typename MemberFunctionWith3Parameter<ObjectType, Parameter1Type, Parameter2Type, Parameter3Type>::MemberFunctionPtr member_function_ptr, ObjectType* object, Parameter1Type parameter1, Parameter2Type parameter2, Parameter3Type parameter3)
{
_function = new MemberFunctionWith3Parameter<ObjectType, Parameter1Type, Parameter2Type, Parameter3Type>(member_function_ptr, object, parameter1, parameter2, parameter3);
}
public:
Function* _function;
};
////////////////////////////////////////////////////////////////////////////////
// 不带参数
Functor bind(FunctionWithoutParameter::FunctionPtr function_ptr)
{
return Functor(function_ptr);
}
template <class ObjectType>
Functor bind(typename MemberFunctionWithoutParameter<ObjectType>::MemberFunctionPtr member_function_ptr, ObjectType* object)
{
return Functor(member_function_ptr, object);
}
////////////////////////////////////////////////////////////////////////////////
// 带1个参数
template <typename ParameterType>
Functor bind(typename FunctionWith1Parameter<ParameterType>::FunctionPtr function_ptr, ParameterType parameter)
{
return Functor(function_ptr, parameter);
}
template <class ObjectType, typename ParameterType>
Functor bind(typename MemberFunctionWith1Parameter<ObjectType, ParameterType>::MemberFunctionPtr member_function_ptr, ObjectType* object, ParameterType parameter)
{
return Functor(member_function_ptr, object, parameter);
}
////////////////////////////////////////////////////////////////////////////////
// 带2个参数
template <typename Parameter1Type, typename Parameter2Type>
Functor bind(typename FunctionWith2Parameter<Parameter1Type, Parameter2Type>::FunctionPtr function_ptr, Parameter1Type parameter1, Parameter2Type parameter2)
{
return Functor(function_ptr, parameter1, parameter2);
}
template <class ObjectType, typename Parameter1Type, typename Parameter2Type>
Functor bind(typename MemberFunctionWith2Parameter<ObjectType, Parameter1Type, Parameter2Type>::MemberFunctionPtr member_function_ptr, ObjectType* object, Parameter1Type parameter1, Parameter2Type parameter2)
{
return Functor(member_function_ptr, object, parameter1, parameter2);
}
////////////////////////////////////////////////////////////////////////////////
// 带3个参数
template <typename Parameter1Type, typename Parameter2Type, typename Parameter3Type>
Functor bind(typename FunctionWith3Parameter<Parameter1Type, Parameter2Type, Parameter3Type>::FunctionPtr function_ptr, Parameter1Type parameter1, Parameter2Type parameter2, Parameter3Type parameter3)
{
return Functor(function_ptr, parameter1, parameter2, parameter3);
}
template <class ObjectType, typename Parameter1Type, typename Parameter2Type, typename Parameter3Type>
Functor bind(typename MemberFunctionWith3Parameter<ObjectType, Parameter1Type, Parameter2Type, Parameter3Type>::MemberFunctionPtr member_function_ptr, ObjectType* object, Parameter1Type parameter1, Parameter2Type parameter2, Parameter3Type parameter3)
{
return Functor(member_function_ptr, object, parameter1, parameter2, parameter3);
}
////////////////////////////////////////////////////////////////////////////////
static void* thread_proc(void* parameter)
{
Functor* functor = (Functor*)parameter;
(*functor)();
delete functor; // 记得这里需要delete
return NULL;
}
class CThreadEngine
{
public:
CThreadEngine(const Functor& functor)
{
// bind()返回的是一个临时对象，
// 故需要new一个，以便在thread_proc()过程中有效
Functor* new_functor = new Functor(functor);
int errcode = pthread_create(&_thread, NULL, thread_proc, new_functor);
if (errcode != 0)
{
delete new_functor;
}
}
~CThreadEngine()
{
join();
}
void join()
{
if (_thread > 0)
{
pthread_join(_thread, NULL);
_thread = 0;
}
}
private:
CThreadEngine();
CThreadEngine(const CThreadEngine&);
CThreadEngine& operator =(const CThreadEngine&);
private:
pthread_t _thread;
};
////////////////////////////////////////////////////////////////////////////////
// 以下为测试代码
#if defined(TEST_THREAD_ENGINE)
////////////////////////////////////////////////////////////////////////////////
// 非类成员函数
static void hello()
{
printf("[%u] hellon", pthread_self());
}
static void world()
{
printf("[%u] worldn", pthread_self());
}
static void hello(int m)
{
printf("[%u] hello: %dn", pthread_self(), m);
}
static void world(int m)
{
printf("[%u] world: %dn", pthread_self(), m);
}
static void hello(int m, int n)
{
printf("[%u] hello: %d/%dn", pthread_self(), m, n);
}
static void world(int m, int n)
{
printf("[%u] world: %d/%dn", pthread_self(), m, n);
}
static void hello(int m, int n, int l)
{
printf("[%u] hello: %d/%d/%dn", pthread_self(), m, n, l);
}
static void world(int m, int n, int l)
{
printf("[%u] world: %d/%d/%dn", pthread_self(), m, n, l);
}
////////////////////////////////////////////////////////////////////////////////
// 类成员函数
class X
{
public:
//
// 不带参数
//
void hello()
{
printf("[%u] X::hellon", pthread_self());
}
void world()
{
printf("[%u] X::worldn", pthread_self());
}
//
// 带1个参数
//
void hello(int m)
{
printf("[%u] X::hello: %dn", pthread_self(), m);
}
void world(int m)
{
printf("[%u] X::world: %dn", pthread_self(), m);
}
//
// 带2个参数
//
void hello(int m, int n)
{
printf("[%u] X::hello: %d/%dn", pthread_self(), m, n);
}
void world(int m, int n)
{
printf("[%u] X::world: %d/%dn", pthread_self(), m, n);
}
//
// 带3个参数
//
void hello(int m, int n, int l)
{
printf("[%u] X::hello: %d/%d/%dn", pthread_self(), m, n, l);
}
void world(int m, int n, int l)
{
printf("[%u] X::world: %d/%d/%dn", pthread_self(), m, n, l);
}
};
////////////////////////////////////////////////////////////////////////////////
int main()
{
// 不带参数
CThreadEngine engine1(bind(&hello));
CThreadEngine engine2(bind(&world));
X* x1 = new X;
X* x2 = new X;
CThreadEngine engine3(bind(&X::hello, x1));
CThreadEngine engine4(bind(&X::world, x2));
// 带1个参数
CThreadEngine engine5(bind(&hello, 2015));
CThreadEngine engine6(bind(&world, 2016));
CThreadEngine engine7(bind(&X::hello, x1, 2015));
CThreadEngine engine8(bind(&X::world, x2, 2016));
// 带2个参数
CThreadEngine engine9(bind(&hello, 2015, 5));
CThreadEngine engine10(bind(&world, 2016, 5));
CThreadEngine engine11(bind(&X::hello, x1, 2015, 5));
CThreadEngine engine12(bind(&X::world, x2, 2016, 5));
// 带3个参数
CThreadEngine engine13(bind(&hello, 2015, 5, 3));
CThreadEngine engine14(bind(&world, 2016, 5, 3));
CThreadEngine engine15(bind(&X::hello, x1, 2015, 5, 3));
CThreadEngine engine16(bind(&X::world, x2, 2016, 5, 3));
// 按任意键继续继续
printf("Press ENTER to exit ...n");
getchar();
engine1.join();
engine2.join();
engine3.join();
engine4.join();
engine5.join();
engine6.join();
engine7.join();
engine8.join();
engine9.join();
engine10.join();
engine11.join();
engine12.join();
engine13.join();
engine14.join();
engine15.join();
engine16.join();
delete x1;
delete x2;
// 按任意键继续退出
printf("Press ENTER to exit ...n");
getchar();
return 0;
}
SYS_NAMESPACE_END
#endif // TEST_THREAD_ENGINE
#endif // MOOON_SYS_THREAD_ENGINE_H
- JavaScript 教程
- JavaScript 编辑工具
- JavaScript 与HTML
- JavaScript 与Java
- JavaScript 数据结构
- JavaScript 基本数据类型
- JavaScript 特殊数据类型
- JavaScript 运算符
- JavaScript typeof 运算符
- JavaScript 表达式
- JavaScript 类型转换
- JavaScript 基本语法
- JavaScript 注释
- Javascript 基本处理流程
- Javascript 选择结构
- Javascript if 语句
- Javascript if 语句的嵌套
- Javascript switch 语句
- Javascript 循环结构
- Javascript 循环结构实例
- Javascript 跳转语句
- Javascript 控制语句总结
- Javascript 函数介绍
- Javascript 函数的定义
- Javascript 函数调用
- Javascript 几种特殊的函数
- JavaScript 内置函数简介
- Javascript eval() 函数
- Javascript isFinite() 函数
- Javascript isNaN() 函数
- parseInt() 与 parseFloat()
- escape() 与 unescape()
- Javascript 字符串介绍
- Javascript length属性
- javascript 字符串函数
- Javascript 日期对象简介
- Javascript 日期对象用途
- Date 对象属性和方法
- Javascript 数组是什么
- Javascript 创建数组
- Javascript 数组赋值与取值
- Javascript 数组属性和方法
- Android画画板的制作方法
- Android实现bitmap指定区域滑动截取功能
- Android开发实现应用层面屏蔽状态栏的方法小结
- Android实现实时搜索框功能
- 浅谈Android轻量级的数据缓存框架RxCache
- Android开发实现消除屏幕锁的方法
- Android中js和原生交互的示例代码
- 浅谈android获取设备唯一标识完美解决方案
- Android开发实现长按返回键弹出关机框功能
- Android View 完美实现EditText 在软键盘上边的示例
- Android蓝牙通信之搜索蓝牙设备
- Android listview定位到上次显示的位置的实现方法
- Android开发实现生成excel的方法详解
- Android ToolBar 修改边距的实现方法
- Android 自定义view实现TopBar效果