你的位置:首页 > 操作系统

[操作系统]Windows线程漫谈界面线程和工作者线程


每个系统都有线程,而线程的最重要的作用就是并行处理,提高软件的并发率。针对界面来说,还能提高界面的响应力。

 线程分为界面线程和工作者线程,界面实际就是一个线程画出来的东西,这个线程维护一个“消息队列”,“消息队列”也是界面线程和工作者线程的最大区别,这个词应该进到你的脑子里,根深蒂固的!

如果在界面线程的某个地方停住,这说明它处理不了窗口消息了,所以有时候我们就会看到整个界面无响应了。这种问题后面会提供一个叫 WaitForObjectEx 的函数来解决,我们后面再谈。

线程首先就是它的创建,创建是用下面这个函数:CreateThread; 具体的参数我不说了,自己查MSDN。其中的 Thread1 是线程函数。线程函数是一个全局函数,如下:

DWORD WINAPI Thread1(LPVOID lpParam)
{
  while(1)
 {
  OutputDebugString("11111");

  Sleep(10);
 }
 return 0;
}

// 下面这一句是创建线程
CreateThread(NULL, 0, Thread1, 0, 0, NULL);

当然我们不能让一个线程自生自灭,那样有可能在你退出程序的时候出现一些莫名其妙的问题,或者丢失一些数据,或者给你弹一个崩溃的对话框等等。。。

所以我们就要对这个线程进行管理,首先就是让它退出。

我们给它的while加上一个 BOOL 变量 g_bExitThread的判断,这样的话,线程函数就变成下面这样:

DWORD WINAPI Thread1(LPVOID lpParam)
{
  while(!g_bExitThread)
 {
  OutputDebugString("11111");

  Sleep(10);
 }
 return 0;
}

然后在需要它退出的时候把g_bExitThread设为TRUE,表示,喂,兄弟,你该退出了。

当然我们还要知道它是否成功退出了,因为线程句柄是一个内核对象,所以我们就要用到Windows的WaitForSingleObject来等待了。创建的时候和等待它退出的代码就要改变了,多了一个 HANDLE g_hTrd的变量:

// 创建
g_bExitThread = FALSE;
g_hTrd = CreateThread(NULL, 0, Thread1, 0, 0, NULL);

// 等待线程结束
g_bExitThread = TRUE;

 if(g_hTrd != NULL)
 {
  DWORD dwRet = WaitForSingleObject(g_hTrd, 5000);
  if(dwRet == WAIT_OBJECT_0)
  {
   AfxMessageBox("Thread exit success!");
  }
  else
  {
   DWORD dwRet = 0;
   GetExitCodeThread(g_hTrd, &dwRet);
   TerminateThread(g_hTrd, dwRet);
   AfxMessageBox("Thread exit, but not all ok!");
  }
  CloseHandle(g_hTrd);
  g_hTrd = NULL;
 }

上面说了在界面线程里等待别的线程结束,也就是使用 WaitForSingleObject 的时候会阻塞整个窗口消息的处理,所以我们如果在界面线程里要等待别的内核对象时,我们要采用这种“等一下,处理一下界面消息”的方法。我已经写好了一个 WaitForObjectEx 的函数,如下:

// 此函数只能用于界面线程
static DWORD WaitForObjectEx( HANDLE hHandle, DWORD dwMilliseconds )
{
 BOOL bRet;
 MSG msg;
 INT iWaitRet;
 int nTimeOut = 0;
 while( (bRet = ::GetMessage( &msg, NULL, 0, 0 )) != 0)
 { 
  if(nTimeOut++ * 20 >= dwMilliseconds)
   break;

  iWaitRet = WaitForSingleObject(hHandle, 20);
  if(iWaitRet != WAIT_TIMEOUT)
  {
   break;
  }
  if (bRet == -1)
  {
   break;
  }
  else
  {
   ::TranslateMessage(&msg); 
   ::DispatchMessage(&msg); 
  }
 }

 return iWaitRet;
}

很多时候,我们不想把线程作为一个全局函数来使用,所以这个时候我们把线程作为一个类的静态成员对象来写。当然也不能少了刚才的两个变量:退出标志和线程句柄。(设这个类是CTestThreadDlg)

// H 文件 
BOOL m_bExitThread;
 HANDLE m_hTrd;
 static DWORD WINAPI Thread1(LPVOID lpParam);

// CPP文件,创建的时候把 this 指针传进去,因为类静态成员函数不能访问类的非静态成员,没有this指针
//(C++的知识点)
 m_bExitThread = FALSE;
 m_hTrd = CreateThread(NULL, 0, Thread1, this, 0, NULL);

线程函数变成了:

 DWORD WINAPI CTestThreadDlg::Thread1(LPVOID lpParam)
 {
  CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
  while(!pDlg->m_bExitThread)
  {
   OutputDebugString("11111");
  
   Sleep(10);
  }
  return 0;
 }

当有几个线程一起跑的时候,我们就要注意线程的同步问题了,线程的同步一般来说,是在多个线程共用了资源的时候。比如两个线程都用到了同一个VECTOR,都对VECTOR进行插入操作,不幸的是,VECTOR不是线程安全的,这个时候程序就会崩溃,所以我们就要对VECTOR这个资源做同步,同步的意思是“我访问的时候,你等待”。程序大致如下:

DWORD WINAPI CTestThreadDlg::Thread1(LPVOID lpParam)
 {
  CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
  while(!pDlg->m_bExitThread)
  {
   OutputDebugString("11111");
 
   pDlg->m_csForVec.Lock();
   pDlg->m_vecTest.push_back("111");
   pDlg->m_csForVec.Unlock();
 
   Sleep(10);
  }
  return 0;
 }

DWORD WINAPI CTestThreadDlg::Thread2(LPVOID lpParam)
{
 CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
 while(!pDlg->m_bExitThread2)
 {
  OutputDebugString("222");

  pDlg->m_csForVec.Lock();
  pDlg->m_vecTest.push_back("222");
  pDlg->m_csForVec.Unlock(); 

  Sleep(10);
 }
 return 0;
}

m_csForVec 是一个CCriticalSection变量,这个同步对象和其他的同步变量(事件、信号量、互斥区等)有一些不一样,例如只能在同一个进程的线程间访问、在操作系统的用户态访问,其他的必须进入核心态。所以这样导致了这种关键区的核心对象的速度要比其他的快100倍左右。。。

上面已经说了线程的创建、管理(退出线程、等待线程)、同步等,那我们发现了什么共性呢?作为一个程序员,我们要很敏感的发现这些代码上的共性,这是我们设计代码的主要前提。

首先我们发现上面的线程都有两个变量: 
BOOL m_bExitThread;  // 让线程退出的标志
 HANDLE m_hTrd;  // 线程句柄

另外我们WaitForSingleObject 的时候不能无限等待,所以要多一个 DWORD m_dwWaitTimeOut;

由于我想把线程启动和结束封装起来,所以我设计了这几个接口:

 BOOL Start(LPVOID lpParam);  //  启动线程,线程所需要的参数从这里传进
 BOOL End(); // 结束线程
 virtual void Run(); // 重写Run函数 hovertree.com

所以整个的线程封装成以下的类:

// MyThread.h

#ifndef MY_THREAD_H
#define MY_THREAD_H

class CMyThread
{
public:
 CMyThread();
 virtual ~CMyThread();

 BOOL Start(LPVOID lpParam);
 BOOL End();
 virtual void Run();

protected:
 static DWORD WINAPI Thread(LPVOID lpParam);
 void RunOnceEnd();

 DWORD m_dwWaitTimeOut;
 BOOL m_bExitThread;
 HANDLE m_hTrd;
 LPVOID m_lpParam;
};

#endif

// MyThread.Cpp

#include "stdafx.h"
#include "MyThread.h"
/////////////////////////////////////////////////////////////////////////////
// CMyThread
CMyThread::CMyThread()
{
 m_bExitThread = FALSE;
 m_hTrd = NULL;
 m_dwWaitTimeOut = 5000;
}

CMyThread::~CMyThread()
{

}

BOOL CMyThread::Start(LPVOID lpParam)
{
 m_lpParam = lpParam;
 m_bExitThread = FALSE;
 m_hTrd = CreateThread(NULL, 0, Thread, this, 0, NULL);

 return TRUE;
}

BOOL CMyThread::End()
{
 m_bExitThread = TRUE;

 if(m_hTrd != NULL)
 {
  DWORD dwRet = WaitForSingleObject(m_hTrd, m_dwWaitTimeOut);
  if(dwRet == WAIT_OBJECT_0)
  {
   AfxMessageBox("Thread exit success!");
  }
  else
  {
   DWORD dwRet = 0;
   GetExitCodeThread(m_hTrd, &dwRet);
   TerminateThread(m_hTrd, dwRet);
   AfxMessageBox("Thread fucking exit!");
  }

  CloseHandle(m_hTrd);
  m_hTrd = NULL;
 }
 
 return TRUE;
}

DWORD WINAPI CMyThread::Thread(LPVOID lpParam)
{
 CMyThread *pTrd = (CMyThread *)lpParam;
 
 while(!pTrd->m_bExitThread)
 {
  pTrd->Run();
 }

 return 0;
}

void CMyThread::RunOnceEnd()
{
 m_bExitThread = TRUE;
 CloseHandle(m_hTrd);
 m_hTrd = NULL;
}

void CMyThread::Run()
{
}

我们需要写我们自己的线程的时候就重载一下这个Run函数

// 派生出一个类 何问起
class CMyThread1 : public CMyThread
{
public:
 virtual void Run();
};

// 改写Run函数
void CMyThread1::Run()
{
 CTestThreadDlg *pDlg = (CTestThreadDlg *)m_lpParam;

 OutputDebugString("222");
 
 pDlg->m_csForVec.Lock();
 pDlg->m_vecTest.push_back("222");
 pDlg->m_csForVec.Unlock(); 
 
 Sleep(10);

 // 如果此线程只想运行一次,加上下面这句
 RunOnceEnd();
}

然后我们之前的两个线程的使用就变成了下面的形式:

CMyThread1 g_t1, g_t2, g_t3;
void CTestThreadDlg::OnButton3() 
{
 g_t1.Start(this);
 g_t2.Start(this);
 g_t3.Start(this); 
}

void CTestThreadDlg::OnButton4() 
{
 g_t1.End();
 g_t2.End();
 g_t3.End();  
}

只需要以下几步:
1、派生自己的线程类
2、重载Run函数
3、调用Start启动线程
4、调用End结束线程

当然这种封装方式是我自己喜欢的,封装的目的是方便使用,隐藏细节,诸位看官也可以根据自己的喜好,封装线程的使用方法,如果能在此公开一下你的成果,让我和大家都学习一下你的设计手法,那就真是very good and 3q了!

http://www.cnblogs.com/roucheng/