다중쓰레드가 돌고있는 프로세스를 포크시키면 어떻게 될까..

제가 알기로는 어떤 스레드를 사용하는가에 따라 다른 것으로 알고 있습니다.
만약 posix pthread를 사용할 경우, 스레드를 포크하면 포크된 프로세스는 모든 스레드를 카피하는 것으로 알구 있고, 솔라리스의 그린스레드의 경우는 포크한 스레드만을 카피해서 프로세스로 만드는 것으로 알고 있습니다.

아직 테스트는 안 해본 상태이고, 공룡책(탄네바움의 운영체제)에 그렇게 나온 것으로 알고 있습니다.

'애벌레' 책에 설명 되었던 내용입니다.

pthread-compliant 한 implementation에서는 다음과 같습니다.
fork()를 호출한 스레드만을 포함하는 프로세스가 fork() 됩니다.
다른 스레드들은 생성되지 않습니다.

parent의 다른 스레드( fork()를 호출하지 않은 스레드) 들이 allocation한 heap도 그대로 복사됩니다.
parent의 다른 스레드가 걸어놓았던 lock이 그대로 inherit 됩니다.
이런 문제들 때문에 child process의 스레드는 dead lock에 걸릴 수 있으며 memory leak이 생길 수도 있습니다.

해결책으로 pthread_atfork() 함수가 있다고 하네요.

이 또한 멋진 문구군요.

감사합니다...

제 서명 문구는 체 게바라가 했던 말을 인용했습니다. 개인적으로 애착이 가는 표현입니다. ^^

참고로, 전에 GNU의 pth를 공부(?)하면서 본것을 소개하자면,
(pth는 대표적인 GNU의 user level thread library 입니다.)

pid_t pth_fork(void)
{
    pid_t pid;
    int i;

    /* run preparation handlers in LIFO order */
    for (i = pth_atfork_idx-1; i >= 0; i--)
        if (pth_atfork_list[i].prepare != NULL)
            pth_atfork_list[i].prepare(pth_atfork_list[i].arg);

    /* fork the process */
    if ((pid = pth_sc(fork)()) == -1)
        return FALSE;

    /* handle parent and child contexts */
    if (pid != 0) {
        /* Parent: */

        /* run parent handlers in FIFO order */
        for (i = 0; i <= pth_atfork_idx-1; i++)
            if (pth_atfork_list[i].parent != NULL)
                pth_atfork_list[i].parent(pth_atfork_list[i].arg);
    }
    else {
        /* Child: */

        /* kick out all threads except for the current one and the scheduler */
        pth_scheduler_drop();

        /* run child handlers in FIFO order */
        for (i = 0; i <= pth_atfork_idx-1; i++)
            if (pth_atfork_list[i].child != NULL)
                pth_atfork_list[i].child(pth_atfork_list[i].arg);
    }
    return pid;
}

이부분은 pth_fork 라는 함수로서, pth가 syscall-soft 를 지원하는 경우 fork 가 사용되는 곳에 fork 대신 define 되어 들어가는 함수 입니다.

잘보면, child 일때, pth_scheduler_drop 이 불리고, 다음에 pthread_atfork로 등록된 callback들이 불립니다.

pth_scheduler_drop 이 하는 일은,

void pth_scheduler_drop(void)
{   
    pth_t t;
    
    /* clear the new queue */
    while ((t = pth_pqueue_delmax(&pth_NQ)) != NULL)
        pth_tcb_free(t);
    pth_pqueue_init(&pth_NQ);
    
    /* clear the ready queue */
    while ((t = pth_pqueue_delmax(&pth_RQ)) != NULL)
        pth_tcb_free(t);
    pth_pqueue_init(&pth_RQ);

    /* clear the waiting queue */
    while ((t = pth_pqueue_delmax(&pth_WQ)) != NULL)
        pth_tcb_free(t);
    pth_pqueue_init(&pth_WQ);

    /* clear the suspend queue */
    while ((t = pth_pqueue_delmax(&pth_SQ)) != NULL)
        pth_tcb_free(t);
    pth_pqueue_init(&pth_SQ);

    /* clear the dead queue */
    while ((t = pth_pqueue_delmax(&pth_DQ)) != NULL)
        pth_tcb_free(t);
    pth_pqueue_init(&pth_DQ);
    return;
}   

대충 보시면, 내부에 queue들을 지우는 것인데, thread 상태별로 큐가 있는 상황입니다. 그런 thread들을 모두 제거하는 것입니다.

따라서, fork가 일어나면, fork를 부른 thread 외에 다른 thread들은 스케쥴러와 함께 바로 제거됩니다. 부른 thread도 사실 thread개념이 사라지기 때문에 main thread 로 남게 됩니다.

pth를 공부하실때는.. pth_sched.c (약 800라인) 를 뽑아다가 분석하시면, 재밌는 도움이 되실 것 같습니다.

#include <pthread.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
                                                                                                   
pid_t pid;
                                                                                                   
void *user_thread0(void *ptr)
{
        while (1) {
                printf ("pid: %d, thr: %d\n", pid, (int) pthread_self ());
                sleep (2);
        }
        return NULL;
}
                                                                                                   
void *user_thread1(void *ptr)
{
        while (1) {
                printf ("pid: %d, thr: %d\n", pid, (int) pthread_self ());
                sleep (2);
        }
        return NULL;
}
                                                                                                   
int main(int argc, char **argv)
{
        pthread_t thr1;
        pthread_t thr2;
                                                                                                   
        pthread_create (&thr1, NULL, user_thread0, NULL);
        pthread_create (&thr2, NULL, user_thread1, NULL);
                                                                                                   
        if ((pid = fork ()) == 0) {
                // child
                printf ("pid: %d, thr: %d\n", pid, (int) pthread_self ());
        } else {
                printf ("pid: %d, thr: %d\n", pid, (int) pthread_self ());
                pause ();
        }
                                                                                                   
        pthread_join (thr1, NULL);
        pthread_join (thr2, NULL);
                                                                                                   
        return 0;
}

./fork_thread
pid: 0, thr: 1082395840
pid: 0, thr: 1090784320
pid: 0, thr: 1074004608
pid: 23842, thr: 1074004608
pid: 23842, thr: 1082395840
pid: 23842, thr: 1090784320
pid: 23842, thr: 1082395840
pid: 23842, thr: 1090784320
pid: 23842, thr: 1082395840
pid: 23842, thr: 1090784320

아.. 참고로.. linux의 thread는 pth는 아닙니다.. 아시죠?

linux thread 는 clone() 에 의한 잠깐의 눈속임 정도...
2.4까진 그런데...
NGPT 인가를 사용하면 진정한 thread를 사용할 수있다는 글을 지난번에 본거 같은데...
2.6 에선 이 기능이 추가 되었으니...
한껏 더 뛰어난 기능의 threading의 세계를 맛 볼 수가 있겠네요^^

참고: http://www.kernelnewbies.org/status/Status-02-Nov-2003.html

Pth는 저번에 잠시 접할 기회가 있었는데...

요즘 메신저 표준프로토콜로 준비중인 XMPP를 사용하는 Jabber 서버에서 사용하더군요.
pynoos님께서 말씀하신대로 Pth는 GNU Portable Thread 이며, user-level thread를 library 로 구현한 것입니다.

저는 대충 개념만 살펴보고 넘어갔었는데... 저런 내용까지 있었군요. 대단하네요..

<어떠한 역경에도 굴하지 않는 '하양 지훈'>