1. 说明
此博客记录如何以面向对象的方式进行编程，以及如何让线程和线程对象同时销毁
2. 相关代码：
2.1 Thread.h
#ifndef _THREAD_H_
#define _THREAD_H_
#include <pthread.h>
class Thread
{
public:
Thread();
virtual ~Thread();
void Start();
void Join();
void SetAutoDelete(bool autoDelete);
private:
static void* ThreadRoutine(void* arg);
virtual void Run() = 0;
pthread_t _threadId;
bool _autoDelete;
};
#endif
2.2 Thread.cpp
#include "Thread.h"
#include <iostream>
using namespace std;
Thread::Thread() : _autoDelete(false)
{
cout << "Thread() ..." << endl;
}
Thread:: ~Thread()
{
cout << "~Thread() ..." << endl;
}
void Thread::Start()
{
//创建一个线程，指定线程入口函数ThreadRoutine,参数为this指针(指向实际对象本身)
pthread_create(&_threadId, nullptr, ThreadRoutine, this);
}
void Thread::Join()
{
//以阻塞的形式等待指定的线程终止
pthread_join(_threadId,nullptr);
}
void* Thread::ThreadRoutine(void* arg)
{
//将传递过来的对象指针转换为Thread*(基类)类型
//即基类指针thread指向了派生类对象
Thread* thread = static_cast<Thread*>(arg);
//利用虚函数多态，使用基类指针调用子类对象的函数
//也可以理解为此时的基类相当于一个库，回调了子类中的虚函数
thread->Run();
//当子类对象run函数执行完毕后,自动删除当前线程
if(thread->_autoDelete){
delete thread;
}
return nullptr;
}
void Thread::SetAutoDelete(bool autoDelete)
{
_autoDelete = autoDelete;
}
2.3 Thread.h
#include "Thread.h"
#include <iostream>
#include <unistd.h>
using namespace std;
class TestThread : public Thread
{
public:
TestThread(int count) : _count(count)
{
cout << "TestThread() ..." << endl;
}
~TestThread()
{
cout << "~TestThread() ..." << endl;
}
void Run()
{
while (_count--)
{
cout << "this is a test ..." << endl;
sleep(1);
}
}
int _count;
};
int main()
{
/*
TestThread t(5);
t.Start();//隐式的传递了一个参数this(&t --> 指向对象本身)
t.Join();
*/
//线程对象和线程本身销毁的时间并不同步
//使用下述方式实现线程对象和线程本身同时销毁
TestThread* t2 = new TestThread(5);
t2->SetAutoDelete(true);
t2->Start();
t2->Join();
cout << "主线程运行结束..." << endl;
return 0;
}
