VC退出线程的方法（转载）

VC退出线程的方法

标题很简单，但是要讨论的地方不少；

多线程管理，在程序开发中非常重要；虽然应用比较简单，但是要用到不出错，就很难；

这里讲一下线程的退出方法；


一：简单说一下在windows上的线程启动：


方法（1）： WIN32程序通用方法；

//线程：

DWORD WINAPI thread_testexit( PVOID pParam )
{
while( g_bExtiThread )
{
Sleep(1000);


static int i = 0;


CString str;str.Format( L"%d",i++);


AfxGetApp()->GetMainWnd()->SetWindowText( str );
}


return 0;
}

启动：

HANDLE hThread = ::CreateThread( 0, 0, thread_testexit, 0, NULL, NULL );

方法（2）：MFC的方法

UINT thread_testexit( PVOID pParam )

{
while( g_bExtiThread )
{
Sleep(1000);


static int i = 0;


CString str;str.Format( L"%d",i++);


AfxGetApp()->GetMainWnd()->SetWindowText( str );
}


return 0;
}
启动：

CWinThread  * pWinThreadtestexit = AfxBeginThread( thread_testexit, 0 );

二：线程的退出:

(1):

我想大部分人为了图方便，会定义一个BOOL变量如： BOOL g_bExtiThread ; 当 if( g_bExtiThread  == 0 )的时候跳出线程循环，结束线程；

既：g_bExtiThread = 0;

只做这一步，会隐藏一个问题， 如果线程执行的时间较长，如循环中Sleep(1000);  这样会导致，执行 g_bExtiThread = 0; 后立即执行后面的函数，而不会等待线程结束；

如果线程中的变量鱼g_bExtiThread = 0;后面的执行相关，就可能隐藏问题；


(2):

这里自然，有人会用一个简单的方法避免这个过程就是：

g_bExtiThread = 0;
Sleep(2000);

这样， 等待线程结束后，执行其他语句；

这样做，有两个问题：1.效率上比较低，因为即使1000毫秒结束了，可是，却要等待Sleep(2000);

2.如果上述修改为：

g_bExtiThread = 0;
Sleep(1001);

这样看着不错，但是，如果线程中，Sleep (1000)，软后语句执行的时间，大于1毫秒，也就是说 线程循环一次的时间 大于1001毫秒，仍然可能导致 “（1）”中的问题；

或者，线程很多，当线程执行到某一段的时候， CPU的时间片分配给其他线程，这样，依然会导致 线程中的循环时间无法确定；

想通过Sleep的方法等待线程循环结束，只有将时间给的很长，但是这样太浪费时间和效率了。


（3）：

比较通用的方法：

通过WaitForSingleObject获取线程状态，如果线程退出，执行后面的语句；

g_bExtiThread = 0;
WaitForSingleObject( pWinThreadtestexit->m_hThread, INFINITE );
示例：

BOOL                g_bExtiThread = TRUE;
CWinThread  * pWinThreadtestexit = NULL;

UINT thread_testexit( PVOID pParam )
{
while( g_bExtiThread )
{
Sleep(1000);


static int i = 0;


CString str;str.Format( L"%d",i++);


//AfxGetApp()->GetMainWnd()->SetWindowText( str );
}


return 0;
}


void Ctmfc1Dlg::OnBnClickedButton1()
{
// TODO: 在此添加控件通知处理程序代码

pWinThreadtestexit = AfxBeginThread( thread_testexit, 0 );
}

void Ctmfc1Dlg::OnBnClickedButton2()
{
// TODO: 在此添加控件通知处理程序代码

g_bExtiThread = 0;

WaitForSingleObject( pWinThreadtestexit->m_hThread, INFINITE );

SetWindowText( L"线程已经停止" );
}

这里，可能有人已经注意到了， //AfxGetApp()->GetMainWnd()->SetWindowText( str );  我屏蔽了这句话；

这个问题留给读者，这里不再赘述了。


(4):

BOOL TerminateThread(
  HANDLE hThread,    // handle to thread
  DWORD dwExitCode   // exit code
);
这里推荐一篇文章：
TerminateThread is a dangerous function that should only be used in the most extreme cases. You should call TerminateThread only if you know exactly what the target thread is doing, and you control all of the code that the target thread could possibly be running at the time of the termination. For example, TerminateThread can result in the following problems:

If the target thread owns a critical section, the critical section will not be released.（未释放互斥区，造成死锁）
If the target thread is allocating memory from the heap, the heap lock will not be released.（未释放堆分配锁，造成死锁）
If the target thread is executing certain kernel32 calls when it is terminated, the kernel32 state fo the thread’s process could be inconsistent.（在执行内核函数时退出，造成该线程所在进程状态不确定，程序可能崩溃）
If the target thread is manipulating the global state of a shared DLL, the state of the DLL could be destroyed, affecting other users of the DLL.（在使用DLL时退出，造成DLL被销毁，其他使用该DLL得程序可能出现问题！）
A thread cannot protect itself against TerminateThread, other than by controlling access to its handles. The thread handle returned by the CreateThread and CreateProcess functions has THREAD_TERMINATE access, so any caller holding one of these handles can terminate your thread.



听过无数次不要TerminateThread，只是工作中常用，貌似也没有什么问题。今天在高强度测试中发现了一个不可原谅的错误。参看下面的例子

 

DWORD __stdcall mythread(void* )
{
    while( true )
    {
        char* p = new char[1024];

        delete p;
    }
}


int _tmain(int argc, _TCHAR* argv[])
{

    HANDLE h = CreateThread(NULL, 0, mythread, NULL, 0, NULL);

    Sleep(1000);

    TerminateThread(h, 0);
    h = NULL;

    char* p = new char[1024]; //这里会死锁，过不去

    delete []p;

    return 0;
}

为什么死锁呢？new操作符用的是小块堆，整个进程在分配和回收内存时，都要用同一把锁。如果一个线程在占用该锁时被杀死（即临死前该线程在new或delete操作中），其他线程就无法再使用new或delete了，表现为hang住。

《核心编程》里明确提醒不要TerminateThread，但原因并不是血淋淋滴。今天发现的这个bug印证了此书的价值。

另注：许多临时的网络操作经常用TerminateThread，作为网络不通时的退出机制，以后要改改了。比如让该线程自生自灭，自行退出。


再推荐一篇文章：

CloseHandle(),TerminateThread(),ExitThread()的区别

线程的handle用处:
线程的handle是指向“线程的内核对象”的，而不是指向线程本身.每个内核对象只是内核分配的一个内存块，并且只能由内核访问。该内存块是一种数据结构，它的成员负责维护对象的各种信息(eg: 安全性描述，引用计数等)。

CloseHandle()
在CreateThread成功之后会返回一个hThread的handle，且内核对象的计数加1，CloseHandle之后，引用计数减1，当变为0时，系统删除内核对象。
但是这个handle并不能完全代表这个线程，它仅仅是线程的一个“标识”，系统和用户可以利用它对相应的线程进行必要的操纵。如果在线程成功创建后，不再需要用到这个句柄，就可以在创建成功后，线程退出前直接CloseHandle掉，但这并不会影响到线程的运行。

不执行CloseHandle() 带来的后果:
若在线程执行完之后，没有通过CloseHandle()将引用计数减1，在进程执行期间，将会造成内核对象的泄露，相当与句柄泄露，但不同于内存泄露， 这势必会对系统的效率带来一定程度上的负面影响。但是，请记住，当进程结束退出后，系统仍然会自动帮你清理这些资源。但是在这里不推荐这种做法，毕竟不是 一个良好的编程习惯！
( 应用程序运行时，有可能泄露内核对象，但是当进程终止运行时，系统能确保所有内容均被正确地清除。另外，这个情况是用于所有对象，资源和内存块，也就是说，当进程终止时，系统将保证不会留下任何对象。)

TerminateThread()
函数的声明如下：
BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode);
作用：
在线程外终止一个线程，用于强制终止线程。
参数说明：
HANDLE htread：被终止的线程的句柄，为CWinThread指针。
DWORD dwExitCode：退出码。
返回值：
函数执行成功则返回非零值，执行失败返回0。调用getlasterror获得返回的值。


听过无数次不要TerminateThread，只是工作中常用，貌似也没有什么问题。今天在高强度测试中发现了一个不可原谅的错误。参看下面的例子


[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
DWORD __stdcall mythread(void*)   
{   
    while( true )   
    {   
        char* p = new char[1024];   
   
        delete [] p;   
    }   
}   
   
int _tmain(int argc, _TCHAR* argv[])   
{   
   
    HANDLE h = CreateThread(NULL, 0, mythread, NULL, 0, NULL);   
   
    Sleep(1000);   
   
    TerminateThread(h , 0);   
    h = NULL;   
   
    char* p = new char[1024]; // 这里会死锁, 过不去   
   
    delete [] p;   
   
    return 0;   
} 
[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
DWORD __stdcall mythread(void*)   
{   
    while( true )   
    {   
        char* p = new char[1024];   
   
        delete [] p;   
    }   
}   
   
int _tmain(int argc, _TCHAR* argv[])   
{   
   
    HANDLE h = CreateThread(NULL, 0, mythread, NULL, 0, NULL);   
   
    Sleep(1000);   
   
    TerminateThread(h , 0);   
    h = NULL;   
   
    char* p = new char[1024]; // 这里会死锁, 过不去   
   
    delete [] p;   
   
    return 0;   
} 
为什么死锁呢？new操作符用的是小块堆，整个进程在分配和回收内存时，都要用同一把锁。如果一个线程在占用该锁时被杀死（即临死前该线程在new或delete操作中），其他线程就无法再使用new或delete了，表现为hang住。

<核心编程>里明确提醒不要TerminateThread，但原因并不是血淋淋滴。今天发现的这个bug印证了此书的价值。

另注：许多临时的网络操作经常用TerminateThread，作为网络不通时的退出机制，以后要改改了。比如让该线程自生自灭，自行退出。

ExitThread是推荐使用的结束一个线程的方法，当调用该函数时，当前线程的栈被释放，然后线程终止，相对于TerminateThread函数来说，这样做能够更好地完成附加在该线程上的DLL的清除工作



终止线程两个函数：ExitThread() 和 TerminateThread()

若要终止线程的运行，可以使用下面四种的方法：
线程函数退出循环来返回   （最佳方法 ）。
通过调用ExitThread 函数，线程将自行撤消（尽量不要使用这种方法 ）。
同一个进程或另一个进程中的线程调用TerminateThread 函数（最好避免使用这种方法 ）。
该线程的主进程终止运行（避免使用 ）。
下面将介绍终止线程运行的方法，并且说明线程终止运行时会出现什么情况。


1.线程函数返回
始终都应该将线程设计成这样的形式，即当想要线程终止运行时，它们就能够返回。这是
确保所有线程资源被正确地清除的唯一办法。
如果线程能够返回，就可以确保下列事项的实现：
a) 在线程函数中创建的所有C + +对象均将通过它们的撤消函数正确地撤消。
b)操作系统将正确地释放线程堆栈使用的内存。
c)系统将线程的退出代码（在线程的内核对象中维护）设置为线程函数的返回值。
d)系统将递减线程内核对象的使用计数。


2.ExitThread 函数
可以让线程调用ExitThread 函数，以便强制线程终止运行：
该函数将终止线程的运行，并导致操作系统清除该线程使用的所有操作系统资源。但是，C++资源（如C++类对象）将不被撤消。由于这个原因，最好从线程函数返回，而不是通过调用ExitThread 来返回。
当然，可以使用ExitThread  的dwExitThread 参数告诉系统将线程的退出代码设置为什么。ExitThread 函数并不返回任何值，因为线程已经终止运行，不能执行更多的代码。
注意终止线程运行的最佳方法是让它的线程函数返回。但是，如果使用本节介绍的方法，应该知道ExitThread 函数是Windows用来撤消线程的函数。如果编写C/C++代码，那么决不应该调用ExitThread 。应该使用Visual C++运行期库函数_endthreadex。如果不使用Microsoft的Visual C++编译器，你的编译器供应商有它自己的ExitThread 的替代函数。不管这个替代函数是什么，都必须使用。本章后面将说明_endthreadex的作用和它的重要性。


3.TerminateThread 函数
调用TerminateThread 函数也能够终止线程的运行：
与ExitThread 不同，ExitThread 总是撤消调用的线程，而TerminateThread 能够撤消任何线程。hThread参数用于标识被终止运行的线程的句柄。当线程终止运行时，它的退出代码成为你作为dwExitThread 参数传递的值。同时，线程的内核对象的使用计数也被递减。
注意TerminateThread 函数是异步运行的函数，也就是说，它告诉系统你想要线程终止运行，但是，当函数返回时，不能保证线程被撤消。如果需要确切地知道该线程已经终止运行，必须调用WaitForSingleObject或者类似的函数，传递线程的句柄。
设计良好的应用程序从来不使用这个函数，因为被终止运行的线程收不到它被撤消的通知。线程不能正确地清除，并且不能防止自己被撤消。注意当使用返回或调用ExitThread 的方法撤消线程时，该线程的内存堆栈也被撤消。但是，如果使用TerminateThread ，那么在拥有线程的进程终止运行之前，系统不撤消该线程的堆栈。Microsoft故意用这种方法来实现TerminateThread 。如果其他仍然正在执行的线程要引用强制撤消的线程堆栈上的值，那么其他的线程就会出现访问违规的问题。如果将已经撤消的线程的堆栈留在内存中，那么其他线程就可以继续很好地运行。此外，当线程终止运行时， DLL通常接收通知。如果使用Terminate Thread 强迫线程终止，DLL就不接收通知，这能阻止适当的清除（详细信息参见第20章）。


4.在进程终止运行时撤消线程
ExitProcess和TerminateProcess函数也可以用来终止线程的运行。差别在于这些线程将会使终止运行的进程中的所有线程全部终止运行。另外，由于整个进程已经被关闭，进程使用的所有资源肯定已被清除。这当然包括所有线程的堆栈。这两个函数会导致进程中的剩余线程被强制撤消，就像从每个剩余的线程调用TerminateThread 一样。显然，这意味着正确的应用程序清除没有发生，即C++对象撤消函数没有被调用，数据没有转至磁盘等等