Windows 多线程实现

 

---

/***************************/
/*   filename thread.h
/*   author:  ZORRO
/*   date:    2009-11-29
****************************/
#ifndef _THREAD_H__
#define _THREAD_H__
#include <stdio.h>
#include <iostream.h>
#include <process.h>
#include <windows.h>

static unsigned int __stdcall threadFunction(void *);

class Thread {
        friend unsigned int __stdcall threadFunction(void *);
public:
        Thread();
        virtual ~Thread();
        int start(void * = NULL);
        void * wait();
        void stop();
        void detach();
        static void sleep(unsigned int);

protected:
        virtual void * run(void *) = 0;

private:
        HANDLE threadHandle;
        bool started;
        bool detached;
        void * param;
        unsigned int threadID;
};

class create:public Thread
{
protected:
 void * run(void * param)
 {
  char * msg = (char *) param;
  printf("%s/n",msg);
  //sleep(100);  //Add this can check muti-thread clearly.
  printf("One Day past/n");
  return NULL;
 }
};

#endif

---

/***************************/
/*   filename thread.cpp
/*   author:  ZORRO
/*   date:    2009-11-29
****************************/

#include <process.h>
#include "thread.h"

unsigned int __stdcall threadFunction(void * object)
{
        Thread * thread = (Thread *) object;
        return  (unsigned int ) thread->run(thread->param);
}

Thread::Thread()
{
        started = false;
        detached = false;
}

Thread::~Thread()
{
        stop();
}

int Thread::start(void* pra)
{
        if (!started)
        {
                param = pra;
                if (threadHandle = (HANDLE)_beginthreadex(NULL, 0, threadFunction, this, 0, &threadID))
                {
                        if (detached)
                        {
                                CloseHandle(threadHandle);
                        }
                        started = true;
                }
        }
        return started;
}

//wait for current thread to end.
void * Thread::wait()
{
        DWORD status = (DWORD) NULL;
        if (started && !detached)
        {
                WaitForSingleObject(threadHandle, INFINITE);
                GetExitCodeThread(threadHandle, &status);      
                CloseHandle(threadHandle);
                detached = true;
        }

        return (void *)status;
}

void Thread::detach()
{
  if (started && !detached)
  {
    CloseHandle(threadHandle);
  }
  detached = true;
}

void Thread::stop()
{
        if (started && !detached)
        {
                TerminateThread(threadHandle, 0);

                //Closing a thread handle does not terminate
                //the associated thread.
                //To remove a thread object, you must terminate the thread,
                //then close all handles to the thread.
                //The thread object remains in the system until
                //the thread has terminated and all handles to it have been
                //closed through a call to CloseHandle
                CloseHandle(threadHandle);
                detached = true;
        }
}

void Thread::sleep(unsigned int delay)
{
        ::Sleep(delay);
}

 

void main()
{
 create monday,tuesday;
 monday.detach();
 tuesday.detach();
 printf("1111111/n");
 monday.start("first monday.");
 tuesday.start("second tuesday.");
 Sleep(1000);
 printf("222222222222/n");
}