【C++编程】C++实现多线程编程

在C++的多线程编程实现里有两种方式,一种是Windows头文件里的CreateProcess,另一种是process.h里的_beginthread,我这里用的是后一种,并且将多线程操作封装成了类似Java里的Thread类。

Thread类包含四种操作(对应线程的几种状态):就绪(start),挂起(suspend)、恢复(resume)以及终止(terminate),另外,还包含了一个可以设置线程超时的操作。

Thread类代码如下(Thread.h):

#ifndef THREAD_H
#define THREAD_H
#include <windows.h>
#include <process.h>
typedef void *HANDLE;
class Thread {
public:
    Thread();                               //构造器

    void         start();                   //线程启动函数
    virtual void run();                     //线程运行函数
    int          suspend();                 //线程挂起,返回之前挂起次数
    int          resume();                  //线程恢复,返回之前的挂起次数
    void         terminate();               //强行终止进程
    void         setTimeOut(DWORD time);    //设置超时时间,默认为INFINITE
    DWORD        getTimeOut();              //返回超时时间

private:
    HANDLE m_h;                             //当前线程的句柄
    DWORD  m_timeout;                       //超时时间
    static void init(void *_h);             //运行当前线程
};


#endif

实现文件(Thread.cpp):


#include <iostream>
using std::cin;
using std::cout;
using std::endl;

#include "Thread.h"

Thread::Thread(){
    m_timeout = INFINITE;               //设置默认的超时,为无穷大
}

void Thread::start()
{
    m_h = (HANDLE)_beginthread(init, 0, (void *)this);      //创建线程

}
void Thread::run()
{
    //线程运行方法
}

void Thread::init(void* _h){
    Thread *t = (Thread*)_h;
    t->run();
    DWORD dw = WaitForSingleObject(t->m_h, t->m_timeout); //等待线程,500ms后超时结束,INFINITE表示不超时
    switch (dw)
    {
    case WAIT_OBJECT_0:
        break;
    case WAIT_TIMEOUT: cout << "Time Out" << endl;
        break;
    case WAIT_FAILED:
        break;
    }
}

//线程挂起,返回之前挂起次数
int Thread::suspend(){
    return SuspendThread(this->m_h);
}

//线程恢复,返回之前的挂起次数
int Thread::resume(){
    DWORD re = ResumeThread(this->m_h);
    return re;
}

//强行终止进程
void Thread::terminate(){
    TerminateThread(this->m_h, EXIT_SUCCESS);
}

//设置超时时间,默认为INFINITE
void Thread::setTimeOut(DWORD time){
    this->m_timeout = time;
}
//返回超时时间
DWORD Thread::getTimeOut(){
    return this->m_timeout;
}

测试文件(TestThread.cpp):

 //测试文件
#include "Thread.h"

#include <windows.h>
#include <process.h>
#include <iostream>
using std::cin;
using std::cout;
using std::endl;
#include <string>
using std::string;

class TestThread : public Thread
{
public:
    TestThread(string _s){
        s = _s;
    }
    string s;
    void run();
};

void TestThread::run()
{
    for (int i = 0; i < 10; i++){
        cout <<s+"\n";
    }

}

int main(int argc, char *argv[])
{
    TestThread *dt[10];
    dt[0] = new TestThread("A");        //新建线程A
    dt[1] = new TestThread("B");        //新建线程B
    dt[0]->start();                     //开启线程A
    cout<<dt[0]->suspend()<<endl;       //挂起线程A
    dt[1]->setTimeOut(500);
    dt[1]->start();                     //开启线程B

    Sleep(2000);                        //暂停2s,此时线程A仍属于挂起状态,所以不执行
    dt[0]->resume();                    //恢复线程A,此时线程A属于恢复状态,继续执行

    getchar();
}

测试结果如图:
【C++编程】C++实现多线程编程_第1张图片

你可能感兴趣的:(封装,多线程编程,C++多线程,beginproce)