#include "u_def.h"
#include <windows.h>
#include <stdio.h>
#include "u_task.h"
HANDLE g_handle;
HANDLE test_entry_func(char *name)
{
    int num = 5;
    printf("%s\n", name);
    Sleep(1000);
    while(num--)  // 保证子线程不退出
    {
        printf("%s, %d\n", __FILE__, __LINE__);
        Sleep(500);
    }
    TASK_KillThread(g_handle); // 不能杀死主线程 ??
    Sleep(500);
    return NULL;
}
int main(int argc, char **argv)
{
    UINT32 ret;
    ret = TASK_CreateThread(NULL, NULL, test_entry_func, "zhong");
    ret += 100;
    printf("sakdja %d\n", ret); // 偶然被重复打印
    g_handle = GetCurrentThread();
    //TASK_KillThread(g_handle); // 能杀死自己
    SuspendThread(g_handle);
    //Sleep(16000);                // 等等子线程启动
    return 0;
}

测试发现 HANDLE test_entry_func(char *name)程序中的 TASK_KillThread(g_handle); 不能将主线程杀死，也就是程序一直不会退出
而主函数 int main(int argc, char **argv)中的 SuspendThread(g_handle);能把自己杀死，主线程不会进到Suspend状态！

这能否说明子线程不能杀死主线程？

#include "u_def.h"
#include <windows.h>
#include <stdio.h>
#include "u_task.h"
HANDLE g_handle;
HANDLE g_handle1;
UINT32 TASK_KillThread(HANDLE thread)
{
    UINT32 exit_code;
    GetExitCodeThread(thread, (LPDWORD)&exit_code);
    return !TerminateThread(thread, exit_code);
}
HANDLE test_entry_func(char *name)
{
    //int num = 5;
    printf("%s\n", name);
    Sleep(1000);
    g_handle1 = GetCurrentThread();
    printf("test %x\n", g_handle1);
    //while(num--)  // 保证子线程不退出
    while(TRUE)
    {
        printf("%s, %d\n", __FILE__, __LINE__);
        Sleep(500);
    }
    //TASK_KillThread(g_handle1); // 不能杀死主线程 ??
    Sleep(500);
    return NULL;
}
int main(int argc, char **argv)
{
    UINT32 ret;
    ret = TASK_CreateThread(NULL, NULL, test_entry_func, "zhong");
    ret += 100;
    printf("sakdja %d\n", ret); // 偶然被重复打印
    g_handle = GetCurrentThread();
    printf("main %x\n", g_handle);
    //TASK_KillThread(g_handle); // 能杀死自己
    Sleep(6000);                // 等等子线程启动
    printf("end sleep\n");
    TASK_KillThread(g_handle1); // 不能杀死子线程 ????
    SuspendThread(g_handle);    // 挂起主线程
    return 0;
}

是不是我的 TASK_KillThread 定义的有问题，突然发现主线程连杀死自己的子线程也不行!

#include "u_task.h"

HANDLE g_handle;
HANDLE g_handle1;

HANDLE test_entry_func(char *name)
{
    //int num = 5;
    printf("%s\n", name);
    TASK_Sleep(1000);
    g_handle1 = GetCurrentThread();
    printf("test %x\n", g_handle1);
    //while(num--)  // 保证子线程不退出
    while(TRUE)
    {
        printf("%s, %d\n", __FILE__, __LINE__);
        TASK_Sleep(500);
        TASK_KillThread(g_handle1); // 不能杀死主线程 ??
    }
  
    TASK_Sleep(500);
    return NULL;
}
int main(int argc, char **argv)
{
    UINT32 ret;
    ret = TASK_CreateThread(NULL, NULL, test_entry_func, "zhong");
    ret += 100;
    printf("sakdja %d\n", ret); // 偶然被重复打印
    g_handle = GetCurrentThread();
    printf("main %x\n", g_handle);
    //TASK_KillThread(g_handle); // 能杀死自己
    TASK_Sleep(6000);                // 等等子线程启动
    printf("end sleep\n");
    //TASK_KillThread(g_handle1); // 不能杀死子线程 ????
    SuspendThread(g_handle);    // 挂起主线程
    return 0;
}

刚才突然发现不同线程中使用 GetCurrentThread获取到的线程句柄值竟然相同！


[ 本帖最后由 vfdff 于 2010-7-4 21:58 编辑 ]

The function cannot be used by one thread to create a handle that can be used by other threads to refer to the first thread. The handle is always interpreted as referring to the thread that is using it.

原来GetCurrentThread得到的伪句柄只能在调用者函数内部使用