主线程退出时，各子线程是否会强制退出

[传落古]

在侯捷翻译的书《win32多线程程序设计》中，说到：主线程的结束(不论是因为返回或因为调用了ExitThread())会使得程序中的所有线程都被强迫结束，程序也因此而结束；但在后面又说，在主线程中调用ExitThread()，会导致主线程结束而“worker线程”继续存在。
我搜索CSDN中的博客中，说：如果调用pthread_exit()的话，只会使主函数所在的线程（可以说是进程的主线程）退出；而如果是return，从而导致进程及其所有线程结束运行。
请问究竟是怎样？

[zhaomilu]

转： https://blog.csdn.net/fivedoumi/article/details/51863931
1、进程中线程之间的关系

线程不像进程，一个进程中的线程之间是没有父子之分的，都是平级关系。即线程都是一样的, 退出了一个不会影响另外一个。

但是所谓的"主线程"main,其入口代码是类似这样的方式调用main的：exit(main(...))。

main执行完之后, 会调用exit()。

exit() 会让整个进程over终止，那所有线程自然都会退出。


2、主线程先退出，子线程继续运行的方法


在进程主函数（main()）中调用pthread_exit()，只会使主函数所在的线程（可以说是进程的主线程）退出；而如果是return，编译器将使其调用进程退出的代码（如_exit()），从而导致进程及其所有线程结束运行。

理论上说，pthread_exit()和线程宿体函数退出的功能是相同的，函数结束时会在内部自动调用pthread_exit()来清理线程相关的资源。但实际上二者由于编译器的处理有很大的不同。


按照POSIX标准定义，当主线程在子线程终止之前调用pthread_exit()时，子线程是不会退出的。

When you program with POSIX Threads API, there is one thing about pthread_exit() that you may ignore for mistake. In subroutines that complete normally, there is nothing special you have to do unless you want to pass a return code back using pthread_exit(). The completion won't affect the other threads which were created by the main thread of this subroutine. However, in main(), when the code has been executed to the end, there could leave a choice for you. If you want to kill all the threads that main() created before, you can dispense with calling any functions. But if you want to keep the process and all the other threads except for the main thread alive after the exit of main(), then you can call pthread_exit() to realize it. And any files opened inside the main thread will remain open after its termination.



main()中调用了pthread_exit后，导致住线程提前退出，其后的exit()无法执行了，所以要到其他线程全部执行完了，整个进程才会退出。





from： http://bbs.chinaunix.net/thread-1286290-1-1.html

个人分类： Linux进程、线程间通讯、同步 Linux进程线程

[自信男孩]

主线程，即执行“main”函数的线程（这么描述可能不够严谨，姑且这么说吧），若main退出了，那么相当于主线程退出了，那么程序就退出了。那么，其他线程也会跟着退出了。（一个程序可以理解一个进程，线程是基于进程的，它是进程的更小单元），main函数退出了，也是该程序进程退出了，那么所有线程也就退出了。

[传落古]

引用 2 楼 cfjtaishan 的回复:

主线程，即执行“main”函数的线程（这么描述可能不够严谨，姑且这么说吧），若main退出了，那么相当于主线程退出了，那么程序就退出了。那么，其他线程也会跟着退出了。（一个程序可以理解一个进程，线程是基于进程的，它是进程的更小单元），main函数退出了，也是该程序进程退出了，那么所有线程也就退出了。

但书上后面又说了，如果main函数在return之前，调用ExitThread()函数，则主线程退出，但worker线程继续存在，这又怎么理解呢？

[自信男孩]

引用 3 楼 wushuchuan 的回复:

[quote=引用 2 楼 cfjtaishan 的回复:]
主线程，即执行“main”函数的线程（这么描述可能不够严谨，姑且这么说吧），若main退出了，那么相当于主线程退出了，那么程序就退出了。那么，其他线程也会跟着退出了。（一个程序可以理解一个进程，线程是基于进程的，它是进程的更小单元），main函数退出了，也是该程序进程退出了，那么所有线程也就退出了。

但书上后面又说了，如果main函数在return之前，调用ExitThread()函数，则主线程退出，但worker线程继续存在，这又怎么理解呢？[/quote]
调用ExitThread()函数后main函数有没有执行完呢？

[传落古]

引用 4 楼 cfjtaishan 的回复:

[quote=引用 3 楼 wushuchuan 的回复:]
[quote=引用 2 楼 cfjtaishan 的回复:]
主线程，即执行“main”函数的线程（这么描述可能不够严谨，姑且这么说吧），若main退出了，那么相当于主线程退出了，那么程序就退出了。那么，其他线程也会跟着退出了。（一个程序可以理解一个进程，线程是基于进程的，它是进程的更小单元），main函数退出了，也是该程序进程退出了，那么所有线程也就退出了。

但书上后面又说了，如果main函数在return之前，调用ExitThread()函数，则主线程退出，但worker线程继续存在，这又怎么理解呢？[/quote]
调用ExitThread()函数后main函数有没有执行完呢？[/quote]
在return之前调用ExitThread（)的话，ExitThread函数与return之间的代码将不再执行，线程直接退出，这也是书上有说的

[自信男孩]

ExitThread()是强制退出线程，若在main中执行（调用）这个函数，相当于强制将主线程退出，那么由于main属于主线程的，所以也相当于执行了exit()函数，自然后面的代码（从ExitThread到return之间的代码）就不会执行了。

[传落古]

引用 6 楼 cfjtaishan 的回复:

ExitThread()是强制退出线程，若在main中执行（调用）这个函数，相当于强制将主线程退出，那么由于main属于主线程的，所以也相当于执行了exit()函数，自然后面的代码（从ExitThread到return之间的代码）就不会执行了。

是的，这个我可以理解，但回到最开始的问题，书上说，如果调用了ExitThread函数，则主线程退出，但worker线程继续存在，这 与主线程退出后，所有的线程都强迫退出 矛盾

[传落古]

引用 10 楼 a34140974 的回复:

[quote=引用 9 楼 cfjtaishan 的回复:]
[quote=引用 8 楼 a34140974 的回复:]
[quote=引用 7 楼 wushuchuan 的回复:]
[quote=引用 6 楼 cfjtaishan 的回复:]
ExitThread()是强制退出线程，若在main中执行（调用）这个函数，相当于强制将主线程退出，那么由于main属于主线程的，所以也相当于执行了exit()函数，自然后面的代码（从ExitThread到return之间的代码）就不会执行了。

是的，这个我可以理解，但回到最开始的问题，书上说，如果调用了ExitThread函数，则主线程退出，但worker线程继续存在，这 与主线程退出后，所有的线程都强迫退出 矛盾[/quote]
需要考虑一个退出时机问题，线程的终止一般都是比较麻烦的，比较好的一个做法是毒丸策略。你调用了ExitThread函数，只是“告诉”了线程该exit了，但是线程到底退不退出，什么时候退出还是由线程自己决定的。这个还和操作系统有一些关系。
所以你会看到好多代码都会在主线程等待 子线程结束。如join()操作。[/quote]
ExitThread是强制退出线程。“什么时候退出还是由线程自己决定的”这句话还是有点不严谨的，ExitThread会强制退出线程，不是由线程自己决定的。就像一个进程，我们可以用kill杀死进程，一样可以让其退出的[/quote]
你在线程里面调用ExitThread，不是自己杀死自己么？正常来讲，在一个线程里杀掉另一个线程难道就是，被杀线程再也拿不到任何cpu时间片了么？那属于被杀线程的对象，资源，堆栈怎么清除？
至于杀死进程，那又是另一回事情了。
另外ExitThread只是强制退出当前线程。即使强制退出的线程是主线程，其他线程依然运行。你写个程序自己看下就知道了，你应该以实测和MSDN为准。

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <windows.h>
DWORD WINAPI ThreadProc(LPVOID);
DWORD WINAPI ThreadProc(LPVOID p) {
    for (;;) {
        puts("In ThreadProc()");
        Sleep(100);
    } 
    return 100;
}
int main() {
    HANDLE hThread;
    DWORD dwThId;
    hThread = CreateThread(NULL, 0, ThreadProc, 0, 0, &dwThId);
    if (hThread) {
        puts("start thread");
        CloseHandle(hThread);
    }
    ExitThread(2);
    assert(FALSE);
    return EXIT_SUCCESS;
}

[/quote]
对，就是这个问题，exitThread只是退出当前线程，那如果当前线程是主线程，主线程退出后，其他线程依然在运行；这与主线程一结束，其他线程都强制退出不是矛盾了吗？

[走好每一步]

线程是线程，进程是进程，不要搞混淆了。

[传落古]

引用 15 楼 tajon1226 的回复:

线程是线程，进程是进程，不要搞混淆了。

主线程退出后，进程不就退出了吗，那其他线程不应该也退出了吗

[赵4老师]

理解和讨论之前请先学会如何观察！

不要迷信书、考题、老师、回帖；
要迷信CPU、编译器、调试器、运行结果。
并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。
任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

Process Monitor 实时监视文件系统、注册表、进程、线程和 DLL 活动。 http://www.microsoft.com/china/technet/sysinternals/utilities/processmonitor.mspx

[wjlsmail]

主线程退出了，子线程何以存在？

[月凉西厢]

引用 7 楼 wushuchuan 的回复:

[quote=引用 6 楼 cfjtaishan 的回复:]
ExitThread()是强制退出线程，若在main中执行（调用）这个函数，相当于强制将主线程退出，那么由于main属于主线程的，所以也相当于执行了exit()函数，自然后面的代码（从ExitThread到return之间的代码）就不会执行了。

是的，这个我可以理解，但回到最开始的问题，书上说，如果调用了ExitThread函数，则主线程退出，但worker线程继续存在，这 与主线程退出后，所有的线程都强迫退出 矛盾[/quote]
需要考虑一个退出时机问题，线程的终止一般都是比较麻烦的，比较好的一个做法是毒丸策略。你调用了ExitThread函数，只是“告诉”了线程该exit了，但是线程到底退不退出，什么时候退出还是由线程自己决定的。这个还和操作系统有一些关系。
所以你会看到好多代码都会在主线程等待 子线程结束。如join()操作。

[自信男孩]

引用 8 楼 a34140974 的回复:

[quote=引用 7 楼 wushuchuan 的回复:]
[quote=引用 6 楼 cfjtaishan 的回复:]
ExitThread()是强制退出线程，若在main中执行（调用）这个函数，相当于强制将主线程退出，那么由于main属于主线程的，所以也相当于执行了exit()函数，自然后面的代码（从ExitThread到return之间的代码）就不会执行了。

是的，这个我可以理解，但回到最开始的问题，书上说，如果调用了ExitThread函数，则主线程退出，但worker线程继续存在，这 与主线程退出后，所有的线程都强迫退出 矛盾[/quote]
需要考虑一个退出时机问题，线程的终止一般都是比较麻烦的，比较好的一个做法是毒丸策略。你调用了ExitThread函数，只是“告诉”了线程该exit了，但是线程到底退不退出，什么时候退出还是由线程自己决定的。这个还和操作系统有一些关系。
所以你会看到好多代码都会在主线程等待 子线程结束。如join()操作。[/quote]
ExitThread是强制退出线程。“什么时候退出还是由线程自己决定的”这句话还是有点不严谨的，ExitThread会强制退出线程，不是由线程自己决定的。就像一个进程，我们可以用kill杀死进程，一样可以让其退出的

[月凉西厢]

引用 9 楼 cfjtaishan 的回复:

[quote=引用 8 楼 a34140974 的回复:]
[quote=引用 7 楼 wushuchuan 的回复:]
[quote=引用 6 楼 cfjtaishan 的回复:]
ExitThread()是强制退出线程，若在main中执行（调用）这个函数，相当于强制将主线程退出，那么由于main属于主线程的，所以也相当于执行了exit()函数，自然后面的代码（从ExitThread到return之间的代码）就不会执行了。

是的，这个我可以理解，但回到最开始的问题，书上说，如果调用了ExitThread函数，则主线程退出，但worker线程继续存在，这 与主线程退出后，所有的线程都强迫退出 矛盾[/quote]
需要考虑一个退出时机问题，线程的终止一般都是比较麻烦的，比较好的一个做法是毒丸策略。你调用了ExitThread函数，只是“告诉”了线程该exit了，但是线程到底退不退出，什么时候退出还是由线程自己决定的。这个还和操作系统有一些关系。
所以你会看到好多代码都会在主线程等待 子线程结束。如join()操作。[/quote]
ExitThread是强制退出线程。“什么时候退出还是由线程自己决定的”这句话还是有点不严谨的，ExitThread会强制退出线程，不是由线程自己决定的。就像一个进程，我们可以用kill杀死进程，一样可以让其退出的[/quote]
你在线程里面调用ExitThread，不是自己杀死自己么？正常来讲，在一个线程里杀掉另一个线程难道就是，被杀线程再也拿不到任何cpu时间片了么？那属于被杀线程的对象，资源，堆栈怎么清除？
至于杀死进程，那又是另一回事情了。
另外ExitThread只是强制退出当前线程。即使强制退出的线程是主线程，其他线程依然运行。你写个程序自己看下就知道了，你应该以实测和MSDN为准。

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <windows.h>
DWORD WINAPI ThreadProc(LPVOID);
DWORD WINAPI ThreadProc(LPVOID p) {
    for (;;) {
        puts("In ThreadProc()");
        Sleep(100);
    } 
    return 100;
}
int main() {
    HANDLE hThread;
    DWORD dwThId;
    hThread = CreateThread(NULL, 0, ThreadProc, 0, 0, &dwThId);
    if (hThread) {
        puts("start thread");
        CloseHandle(hThread);
    }
    ExitThread(2);
    assert(FALSE);
    return EXIT_SUCCESS;
}

[走好每一步]

记住一点就好了，进程退出了，所有线程都会被销毁！

[自信男孩]

#include <iostream>
#include <pthread.h>
#include <stdlib.h>
using namespace std;

int flag=0;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

void* thread1(void *var);
void* thread2(void *var);

int main()
{
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,thread1,&tid2);
    pthread_create(&tid2,NULL,thread2,NULL);
    pthread_exit(NULL);
    pthread_cond_wait(&cond,&mutex);
    cout<<"init thread exit"<<endl;
    //pthread_exit(NULL);
}

void* thread1(void *var)
{
    //	pthread_detach(pthread_self());
    pthread_mutex_lock(&mutex);
    if(flag==2)
        pthread_cond_signal(&cond);
    cout<<"this is thread1"<<endl;
    flag=1;
    pthread_mutex_unlock(&mutex);
    pthread_join(*(pthread_t *)var,NULL);
    cout<<"thread1 exit"<<endl;
}

void* thread2(void *var)
{
    //	pthread_detach(pthread_self());
    pthread_mutex_lock(&mutex);
    if(flag==1)
        pthread_cond_signal(&cond);
    cout<<"this is thread2"<<endl;
    flag=2;
    pthread_mutex_unlock(&mutex);
    cout<<"thread2 exit"<<endl;
}

这个程序验证的结果是：主线程和其他线程都是平级关系（一个退出不影响其他线程），这个程序是一个进程，这些线程属于这个进程下的线程。
但是一旦main退出时，进程就是退出了，那么该进程下的线程也会退出。即使该进程下的堆栈资源也会被系统回收

[自信男孩]

如果调用pthread_exit()的话，只会使主函数所在的线程（可以说是进程的主线程）退出；而如果是return，从而导致进程及其所有线程结束运行

这句话就好理解了。

引用 12 楼 cfjtaishan 的回复:

#include <iostream>
#include <pthread.h>
#include <stdlib.h>
using namespace std;

int flag=0;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

void* thread1(void *var);
void* thread2(void *var);

int main()
{
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,thread1,&tid2);
    pthread_create(&tid2,NULL,thread2,NULL);
    pthread_exit(NULL);
    pthread_cond_wait(&cond,&mutex);
    cout<<"init thread exit"<<endl;
    //pthread_exit(NULL);
}

void* thread1(void *var)
{
    //	pthread_detach(pthread_self());
    pthread_mutex_lock(&mutex);
    if(flag==2)
        pthread_cond_signal(&cond);
    cout<<"this is thread1"<<endl;
    flag=1;
    pthread_mutex_unlock(&mutex);
    pthread_join(*(pthread_t *)var,NULL);
    cout<<"thread1 exit"<<endl;
}

void* thread2(void *var)
{
    //	pthread_detach(pthread_self());
    pthread_mutex_lock(&mutex);
    if(flag==1)
        pthread_cond_signal(&cond);
    cout<<"this is thread2"<<endl;
    flag=2;
    pthread_mutex_unlock(&mutex);
    cout<<"thread2 exit"<<endl;
}

这个程序验证的结果是：主线程和其他线程都是平级关系（一个退出不影响其他线程），这个程序是一个进程，这些线程属于这个进程下的线程。
但是一旦main退出时，进程就是退出了，那么该进程下的线程也会退出。即使该进程下的堆栈资源也会被系统回收

[矛盾博弈]

正常说，主线程结束，意味着主程序随之结束，这里讨论的线程，有个疑惑点，即，线程是否正常使用，先说工作线程，如果是正常使用，最简单的独立工作线程，一次运算这种，主线程结束，程序会正常结束。 问题点在于，真实情况比较复杂，线程一般为死循环或有结束条件，这个一般在主程序结束前，应当提前结束相应线程，如果没有，那么这些线程依然存在，且程序也不会退出，即使使用ExitThread结束主线程