[pthread] Thread 실습 (운영체제🦖 강의-Chpater4. Thread & Cocurrency)

1. Thread의 개념

Thread의 종류

Thread는 크게 두 가지로 나뉩니다.

1. User Thread: 커널의 직접적인 지원 없이 사용자 공간에서 관리됩니다.
2. Kernel Thread: 커널이 직접 관리하는 쓰레드입니다.

User Thread와 Kernel Thread 간의 관계 모델

• Many-to-One Model: 여러 개의 user thread가 하나의 kernel thread에 매핑됩니다.
• One-to-One Model: 각각의 user thread가 하나의 kernel thread에 매핑됩니다.
• Many-to-Many Model: 여러 개의 user thread가 여러 개의 kernel thread에 매핑됩니다.

 

2. Thread 라이브러리

Thread 생성과 관리를 위해 라이브러리가 필요하며, 대표적인 라이브러리는 다음과 같습니다.

• POSIX Pthreads (Linux, Unix 환경)
• Windows Thread (Windows 환경)
• Java Thread (JVM 기반)

이번 실습에서는 POSIX Pthreads를 이용하여 thread를 생성하고 관리하는 방법을 실습해 보겠습니다.

3. Pthreads 실습

3.1 Pthreads 실습 1: 간단한 Thread 생성 및 실행

#include <stdio.h>
#include <stdlib.h> // atoi() 함수 사용 (문자열을 정수로 변환)
#include <pthread.h> //POSIX Thread 라이브러리

int sum; //전역 변수 선언

void *runner(void *param); //쓰레드에서 실행될 함수 선언

int main(int argc, char *argv[]) //argc: 명령줄 인자 개수, argv: 명령줄 인자 배열
{
    pthread_t tid; //쓰레드 아이디를 저장하는 변수
    pthread_attr_t attr; //쓰레드 속성을 저장하는 변수

    pthread_attr_init(&attr); //쓰레드 속성 초기화
    pthread_create(&tid, &attr, runner, argv[1]); // runner 함수 실행, argv[1] 전달
    pthread_join(tid, NULL); // Thread가 종료될 때까지 대기 (메인 함수가 먼저 끝나지 않게)

    printf("sum = %d\n", sum);
}

void *runner(void *param)
{
    int i, upper = atoi(param); //atoi로 문자열을 정수로 변환
    sum = 0;
    for (i = 1; i <= upper; i++)
        sum += i;
    pthread_exit(0); //실행이 끝났음을 알리고 종료
}

실행 예시

gcc -pthread pthread_example1.c -o pthread_example1
./pthread_example1 10
-> sum = 55

코드 설명

• pthread_create()를 이용하여 새로운 쓰레드를 생성하고 runner 함수를 실행합니다.
• pthread_join()을 호출하여 메인 쓰레드가 새롭게 생성된 쓰레드가 종료될 때까지 기다립니다.
• runner 함수는 전달된 upper 값을 기반으로 1부터 해당 값까지의 합을 계산합니다.

포인터 개념을 많이 까먹어서 예제에서 포인터 쓰여진 부분 정리

1️⃣ void *runner(void *param);

📌 void *runner

• void * → 포인터를 반환하는 함수라는 뜻
• 즉, runner() 함수는 어떤 데이터 타입이든 가리킬 수 있는 포인터를 반환할 수 있음을 의미.
• 하지만 실제로는 pthread_exit(0);으로 끝나기 때문에 반환값을 사용하진 않음.

📌 void *param

• param 앞의 *는 포인터 매개변수라는 뜻.
• 즉, param은 어떤 데이터 타입이든 가리킬 수 있는 포인터.
• pthread_create()로 새로운 쓰레드를 만들 때, 실행할 함수의 매개변수로 포인터 하나만 전달할 수 있음.
• 그래서 param을 void * 타입으로 선언해서 어떤 타입이든 받을 수 있도록 함.

💡 왜 포인터(void *param)를 쓰는 걸까?
쓰레드를 만들 때, 실행할 함수에 하나의 매개변수만 넘길 수 있기 때문.
→ 다양한 데이터 타입을 넘기려면 포인터를 사용해야 함.

---

2️⃣ pthread_create(&tid, &attr, runner, argv[1]);

📌 &tid → 쓰레드 ID 저장할 공간을 전달

• tid는 쓰레드 ID를 저장할 변수.
• pthread_create()는 새로운 쓰레드를 만들면서 그 쓰레드의 ID를 tid에 저장해야 함.
• 하지만 C에서 함수가 기본적으로 값을 복사해서 전달하기 때문에,
  값을 저장하려면 변수의 주소를 넘겨야 해.
• 그래서 &tid를 넘겨서 tid 변수 자체를 변경할 수 있도록 해야 함.

---

📌 &attr → 쓰레드 속성 구조체 전달

• pthread_attr_t는 쓰레드 속성(스택 크기, 우선순위 등)을 저장하는 구조체.
• pthread_attr_init(&attr);에서 속성을 기본값으로 초기화한 후, pthread_create()에 포인터(&attr)를 전달해야 함.
• 그래야 pthread_create() 함수가 attr을 직접 읽을 수 있음.

💡 왜 주소를 넘길까?

• C 언어에서 구조체를 함수에 전달하면 값이 복사됨.
• 복사본을 전달하면 원본을 수정할 수 없기 때문에, 원본을 수정하려면 주소를 넘겨야 함.

---

3️⃣ argv[1]은 왜 그냥 넘기나?

• argv[1]은 문자열(char *)이기 때문에, 원래부터 포인터 형태야.
• 그래서 굳이 &argv[1]을 넘길 필요 없이, 그냥 argv[1]을 전달하면 됨.

3.2 Pthreads 실습 2: Thread와 fork()를 함께 사용하는 경우

#include <stdio.h>
#include <unistd.h> //fork(), getpid() 사용
#include <wait.h>
#include <pthread.h>

int value = 0; //전역변수, 모든 함수에서 접근 가능
void * runner(void *param);

int main(int argc, char *argcv[])
{
    pid_t pid; //fork()가 반환하는 프로세스 ID를 저장하는 변수.
    pthread_t tid; //쓰레드 ID를 저장하는 변수.
    pthread_attr_t attr; //쓰레드 속성을 저장하는 구조체.

    pid = fork(); //자식 프로세스 생성 

    if(pid ==0) { //child process
        pthread_attr_init(&attr);
        pthread_create(&tid, &attr, runner, NULL); //쓰레드 생성 및 실행
        pthread_join(tid, NULL); //쓰레드 종료까지 대기
        printf("CHILD: value = %d\n", value);
    }
    else if (pid > 0) { //parent process
        wait(NULL); //자식 프로세스 종료까지 대기
        printf("PARENT: value = %d\n", value); //자식 프로세스 끝나면 출력
    }
}

void *runner(void *param)
{
    value = 5;
    pthread_exit(0);
}

실행 예시

CHILD: value = 5
PARENT: value = 0​

실행 결과 분석

• 자식 프로세스에서 쓰레드를 생성하여 value 값을 변경하면, 부모 프로세스는 영향을 받지 않습니다.
• fork() 이후 생성된 프로세스는 독립된 메모리 공간을 가지므로, 쓰레드가 변경한 값이 부모 프로세스에는 반영되지 않습니다.

추가 개념: Thread와 Process의 차이

• Thread는 같은 프로세스 내에서 메모리를 공유합니다.
• Process는 독립된 메모리를 가지므로, 한 프로세스의 변경 사항이 다른 프로세스에 영향을 미치지 않습니다.

3.3 Pthreads 실습 3: fork()와 Thread 생성

#include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <pthread.h>

void *runner(void *param);

int main(int argc, char *argv[])
{
    pid_t pid;
    pthread_t tid;

    printf("A = %d\n", getpid());
    pid = fork(); //첫 번째 fork 실행, 자식의 pid 반환
    if(pid > 0) {
        wait(NULL); //자식 종료까지 대기
        printf("B = %d\n", pid);
    }
    if(pid == 0) { //자식 프로세스
        pid = fork();
        if(pid > 0) { //다시 fork
            wait(NULL); //첫 번째 자식 대기
            if (pid > 0) printf("C = %d\n", pid);
        }
        pthread_create(&tid, NULL, runner, NULL); //두 번째 자식 스레드 생성, runner 실행
    }
    pid = fork(); //모든 프로세스에서 fork 실행
    if(pid > 0) {
        wait(NULL);
        if (pid > 0) printf("D = %d\n", pid);
    }
}

void *runner(void *param)
{
    printf("I'm a thread!\n");
    pthread_exit(0);
}

실행 예시

A = 9332
I'm a thread!
D = 9336
C = 9334
I'm a thread!
D = 9338
B = 9333
D = 9339

분석

아래와 같은 구조를 가지며, fork()와 pthread_create()를 사용하여 프로세스

와 쓰레드를 생성합니다.

pid_t pid;

pid = fork();
if(pid == 0) { /* child process */
    fork();
    pthread_create(...);
}
fork();

프로세스 및 쓰레드 개수 분석

a. Unique Process 개수: 6개

b. Unique Thread 개수: 2개

과정 설명

1. A (부모 프로세스)가 B (자식 프로세스)를 생성합니다.
2. B가 fork()를 호출하여 C를 생성합니다.
3. B와 C는 각각 pthread_create()를 호출하여 쓰레드를 생성하고 "I'm a thread!"를 출력합니다.
4. 이후 A, B, C 모두 fork()를 실행하여 D, D, D 프로세스(총 3개)를 추가로 생성합니다.

이 실습을 통해 fork()와 pthread_create()의 상호 작용을 이해하고, 프로세스와 쓰레드가 어떻게 생성되는지 실습할 수 있습니다.

 

4. Implicit Threading

쓰레드의 생성과 관리를 더욱 쉽게 하기 위해 Implicit Threading 기법이 등장했습니다. 대표적인 기법으로는 다음이 있습니다.

• Thread Pools: 미리 생성된 쓰레드 풀에서 쓰레드를 재사용하는 방식.
• Fork & Join Model: 병렬 처리를 명시적으로 지정하는 방식.
• OpenMP: 컴파일러 지시어를 사용하여 병렬 처리를 구현.

4.1 OpenMP 실습 1: 기본적인 병렬 실행

#include <stdio.h>
#include <omp.h>

int main(int argc, char *argv[])
{
    #pragma omp parallel
    {
        printf("I am a parallel region.\n");
    }
    return 0;
}

실행 방법

gcc -fopenmp openmp_example1.c -o openmp_example1
./openmp_example1

4.2 OpenMP 실습 2: 여러 개의 쓰레드 활용

 

#include <stdio.h>
#include <omp.h>

int main(int argc, char *argv[])
{
    omp_set_num_threads(4);

    #pragma omp parallel
    {
        printf("OpenMP thread: %d\n", omp_get_thread_num());
    }

    return 0;
}

실행 예시

OpenMP thread: 1
OpenMP thread: 3
OpenMP thread: 0
OpenMP thread: 2

쓰레드의 실행 순서는 보장되지 않습니다.

5. 마무리

이번 글에서는 pthread의 기본 개념과 실습을 진행하였으며, fork()와의 관계, OpenMP를 활용한 병렬 처리까지 살펴보았습니다.

추가 학습 추천

• mutex, semaphore를 활용한 동기화 기법
• pthread_cond_wait() 및 pthread_cond_signal()을 이용한 조건 변수
• 병렬 프로그래밍의 성능 최적화 기법

실습을 통해 쓰레드의 생성, 공유 메모리 활용, 병렬 프로그래밍 기법을 익히는 데 도움이 되었기를 바랍니다.