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

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

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

#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();
}

测试结果如图：