封装windows线程

namespace posix_style_thread
{
#ifdef _WIN32
#include <Windows.h>
#endif
	
#include <process.h>

	interface runnable
	{
		virtual unsigned int run() = 0;
	};

	class thread
	{
		runnable * m_which_to_run;
		HANDLE m_hThread;
	protected:
		static unsigned int __stdcall to_run(void * t)
		{
			thread * thisthread = (thread *)t;
			return (thisthread->m_which_to_run)->run();
		}
	public:
		thread():m_which_to_run(NULL){}
		thread(runnable * _r):m_which_to_run(_r){}
		int attach(runnable * _r)
		{
			m_which_to_run = _r;
		}
		virtual unsigned int run()
		{
			if ( m_which_to_run )
			{
				m_hThread = (HANDLE)_beginthreadex(NULL , 0 , thread::to_run , this , 0 , NULL);
				return (m_hThread != 0);
			}
			return 0;
		}
		int suspend()
		{
			if ( m_hThread )
			{
				return SuspendThread( m_hThread );
			}
		}
		int wait(DWORD dwMillsec)
		{
			if ( m_hThread )
			{
				WaitForSingleObject( m_hThread , dwMillsec );
				return 1;
			}
			return 0;
		}
		int join(DWORD dwMillsec)
		{
			return wait(dwMillsec);
		}
	};
}


class my_work_thread : public posix_style_thread::runnable
{
	const char * m_task_name;
public:
	my_work_thread(const char * _task_name):m_task_name(_task_name){}

	unsigned int run()
	{
		for ( int i = 0 ; i < 100 ; ++i )
		{
			printf("%s : %d * %d = %d\n" , m_task_name , i , i , i * i);
		}

		return 1;
	}
};

	//在main函数中测试线程

	my_work_thread task1("task1") , task2("task2");
	posix_style_thread::thread th1(&task1);
	posix_style_thread::thread th2(&task2);

	th1.run();
	th2.run();

	th1.wait(INFINITE);
	th2.wait(INFINITE);