스레드 프로그래밍

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_func(void *arg) {
    int id = *(int *)arg;
    printf("Thread %d running (tid=%lu)\n", id, (unsigned long)pthread_self());
    return NULL;
}

int main() {
    pthread_t threads[3];
    int ids[3] = {1, 2, 3};

    for (int i = 0; i < 3; i++) {
        int ret = pthread_create(&threads[i], NULL, thread_func, &ids[i]);
        if (ret != 0) {
            fprintf(stderr, "pthread_create failed: %d\n", ret);
            exit(1);
        }
    }

    for (int i = 0; i < 3; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("All threads done\n");
    return 0;
}

gcc -o thread_basic pthread_basic.c -pthread

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *compute(void *arg) {
    int input = *(int *)arg;
    int *result = malloc(sizeof(int));
    if (result == NULL) return NULL;
    *result = input * input;
    return result;  /* 힙에 할당한 결과를 반환 */
}

int main() {
    pthread_t tid;
    int input = 7;
    void *retval = NULL;

    int ret = pthread_create(&tid, NULL, compute, &input);
    if (ret != 0) {
        fprintf(stderr, "pthread_create failed: %d\n", ret);
        return 1;
    }
    ret = pthread_join(tid, &retval);
    if (ret != 0) {
        fprintf(stderr, "pthread_join failed: %d\n", ret);
        return 1;
    }
    if (retval == NULL) {
        fprintf(stderr, "result allocation failed\n");
        return 1;
    }

    int *result = (int *)retval;
    printf("7^2 = %d\n", *result);  /* 49 */

    free(result);  /* 스레드가 할당한 메모리를 해제 */
    return 0;
}

/* 이렇게 하면 안 됩니다 */
for (int i = 0; i < 3; i++) {
    pthread_create(&threads[i], NULL, thread_func, &i);
    /* 모든 스레드가 같은 &i를 공유!
       i가 변경되면 스레드가 잘못된 값을 읽을 수 있음 */
}

pthread_t tid;
int ret = pthread_create(&tid, NULL, background_task, NULL);
if (ret != 0) return ret;
ret = pthread_detach(tid);
if (ret != 0) return ret;
/* 이후 join 불가, 스레드 종료 시 자동 자원 회수 */

import threading
import time

def worker(name, delay):
    tid = threading.current_thread().ident
    print(f"Thread {name} starting (tid={tid})")
    time.sleep(delay)
    print(f"Thread {name} done")

threads = []
for i in range(3):
    t = threading.Thread(target=worker, args=(i, 1))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print("All threads done")

import threading
import time

def cpu_bound(n):
    """CPU 연산 집약적 작업"""
    total = 0
    for i in range(n):
        total += i * i
    return total

def io_bound(seconds):
    """타이머로 I/O 대기를 모사 (실제 네트워크 요청 없음)"""
    time.sleep(seconds)

# CPU 바운드: 싱글 스레드
start = time.perf_counter()
cpu_bound(10_000_000)
cpu_bound(10_000_000)
print(f"CPU 바운드 순차: {time.perf_counter() - start:.2f}s")

# CPU 바운드: 멀티 스레드
start = time.perf_counter()
t1 = threading.Thread(target=cpu_bound, args=(10_000_000,))
t2 = threading.Thread(target=cpu_bound, args=(10_000_000,))
t1.start(); t2.start()
t1.join(); t2.join()
print(f"CPU 바운드 2스레드: {time.perf_counter() - start:.2f}s")

# I/O 바운드: 싱글 스레드
start = time.perf_counter()
io_bound(1); io_bound(1)
print(f"I/O 바운드 순차: {time.perf_counter() - start:.2f}s")

# I/O 바운드: 멀티 스레드
start = time.perf_counter()
t1 = threading.Thread(target=io_bound, args=(1,))
t2 = threading.Thread(target=io_bound, args=(1,))
t1.start(); t2.start()
t1.join(); t2.join()
print(f"I/O 바운드 2스레드: {time.perf_counter() - start:.2f}s")

from multiprocessing import Pool

def cpu_bound(n):
    total = 0
    for i in range(n):
        total += i * i
    return total

if __name__ == "__main__":
    with Pool(processes=4) as pool:
        results = pool.map(cpu_bound, [10_000_000] * 4)
        print(sum(results))

import threading
import time

def background_monitor():
    while True:
        print("모니터링 중...")
        time.sleep(2)

t = threading.Thread(target=background_monitor, daemon=True)
t.start()

time.sleep(5)
print("메인 종료")
# 이 예제는 메인이 마지막 non-daemon 스레드이므로 종료가 진행됨

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def fetch_url(url):
    """URL 내용을 가져오는 I/O 바운드 작업 (시뮬레이션)"""
    time.sleep(1)  # 네트워크 지연 시뮬레이션
    return f"{url} 완료 (URL 문자 수: {len(url)})"

urls = [f"https://example.com/page/{i}" for i in range(8)]

with ThreadPoolExecutor(max_workers=4) as executor:
    # submit()은 Future 객체를 반환
    future_to_url = {executor.submit(fetch_url, url): url for url in urls}

    # 완료되는 순서대로 결과 수집
    for future in as_completed(future_to_url):
        url = future_to_url[future]
        result = future.result()
        print(f"{url} → {result}")

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define POOL_SIZE 4
#define QUEUE_SIZE 16

typedef struct {
    void (*function)(void *);
    void *arg;
} task_t;

typedef struct {
    task_t queue[QUEUE_SIZE];
    int head, tail, count;
    pthread_mutex_t lock;
    pthread_cond_t not_empty;
    pthread_cond_t not_full;
    int shutdown;
    pthread_t workers[POOL_SIZE];
} thread_pool_t;

void *worker_thread(void *arg) {
    thread_pool_t *pool = (thread_pool_t *)arg;

    while (1) {
        pthread_mutex_lock(&pool->lock);

        while (pool->count == 0 && !pool->shutdown) {
            pthread_cond_wait(&pool->not_empty, &pool->lock);
        }
        if (pool->shutdown) {
            pthread_mutex_unlock(&pool->lock);
            break;
        }

        task_t task = pool->queue[pool->head];
        pool->head = (pool->head + 1) % QUEUE_SIZE;
        pool->count--;
        pthread_cond_signal(&pool->not_full);
        pthread_mutex_unlock(&pool->lock);

        task.function(task.arg);  /* 작업 실행 */
    }
    return NULL;
}

import threading

counter = 0

def increment():
    global counter
    for _ in range(1_000_000):
        counter += 1  # 이 한 줄이 원자적이지 않음

t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=increment)
t1.start(); t2.start()
t1.join(); t2.join()

print(f"기대값: 2000000, 실제값: {counter}")

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(1_000_000):
        with lock:
            counter += 1

t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=increment)
t1.start(); t2.start()
t1.join(); t2.join()

print(f"기대값: 2000000, 실제값: {counter}")
# 두 스레드가 정상적으로 모두 완료하면 2000000