OS核心概念完全整理：開発者面接に出るオペレーティングシステムの全て

┌─────────────────────────────────┐
│         PCB (Process            │
│         Control Block)          │
├─────────────────────────────────┤
│  Process ID (PID)               │
│  Process State                  │
│  Program Counter (PC)           │
│  CPU Registers                  │
│  CPU Scheduling Info            │
│  Memory Management Info         │
│  I/O Status Info                │
│  Accounting Info                │
└─────────────────────────────────┘

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();  // プロセス複製

    if (pid < 0) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子プロセス
        printf("Child PID: %d, Parent PID: %d\n", getpid(), getppid());
        execlp("ls", "ls", "-la", NULL);
        perror("exec failed");
    } else {
        // 親プロセス
        printf("Parent PID: %d, Child PID: %d\n", getpid(), pid);
        int status;
        waitpid(pid, &status, 0);
        printf("Child exited with status: %d\n", WEXITSTATUS(status));
    }
    return 0;
}

プロセス A               プロセス B
┌───────────────┐        ┌───────────────┐
│ Code  │ Data  │        │ Code  │ Data  │
│───────│───────│        │───────│───────│
│ Heap  │ Stack │        │ Heap  │ Stack │
└───────────────┘        └───────────────┘
  独立メモリ空間            独立メモリ空間

プロセス C（マルチスレッド）
┌───────────────────────────────┐
│ Code(共有) │  Data(共有)      │
│────────────│──────────────────│
│ Heap(共有) │ Stack1 │ Stack2  │
│            │ (T1)   │ (T2)   │
└───────────────────────────────┘

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

#define NUM_THREADS 4

typedef struct {
    int thread_id;
    int start;
    int end;
    long result;
} ThreadArg;

void* sum_range(void* arg) {
    ThreadArg* targ = (ThreadArg*)arg;
    targ->result = 0;
    for (int i = targ->start; i <= targ->end; i++) {
        targ->result += i;
    }
    printf("Thread %d: sum(%d..%d) = %ld\n",
           targ->thread_id, targ->start, targ->end, targ->result);
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    ThreadArg args[NUM_THREADS];
    int range_per_thread = 250;

    for (int i = 0; i < NUM_THREADS; i++) {
        args[i].thread_id = i;
        args[i].start = i * range_per_thread + 1;
        args[i].end = (i + 1) * range_per_thread;
        pthread_create(&threads[i], NULL, sum_range, &args[i]);
    }

    long total = 0;
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
        total += args[i].result;
    }

    printf("Total sum: %ld\n", total);  // 500500
    return 0;
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    results := make(chan int, 4)

    for i := 0; i < 4; i++ {
        wg.Add(1)
        go func(id, start, end int) {
            defer wg.Done()
            sum := 0
            for j := start; j <= end; j++ {
                sum += j
            }
            results <- sum
            fmt.Printf("Goroutine %d: sum(%d..%d) = %d\n", id, start, end, sum)
        }(i, i*250+1, (i+1)*250)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    total := 0
    for r := range results {
        total += r
    }
    fmt.Printf("Total: %d\n", total)
}

import threading
import multiprocessing
import time

# CPU-bound作業：GILによりスレッドは利点なし
def cpu_bound(n):
    total = 0
    for i in range(n):
        total += i * i
    return total

# スレッド方式（GIL制限）
def thread_test():
    threads = [threading.Thread(target=cpu_bound, args=(10_000_000,))
               for _ in range(4)]
    start = time.time()
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    print(f"Threads: {time.time() - start:.2f}s")

# プロセス方式（GIL回避）
def process_test():
    processes = [multiprocessing.Process(target=cpu_bound, args=(10_000_000,))
                 for _ in range(4)]
    start = time.time()
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(f"Processes: {time.time() - start:.2f}s")

# nice値でプロセス優先度調整（-20 ~ +19）
nice -n 10 ./my_program        # 低い優先度で実行
renice -n -5 -p 1234          # PID 1234の優先度を上げる

# cgroupsでCPUリソース制限
mkdir /sys/fs/cgroup/my_group
echo "25000 50000" > /sys/fs/cgroup/my_group/cpu.max  # 50%制限
echo 1234 > /sys/fs/cgroup/my_group/cgroup.procs

// レースコンディション例 — 同期化なしのカウンター
#include <pthread.h>
#include <stdio.h>

int counter = 0;  // 共有変数

void* increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++;  // アトミックでない！（read -> modify -> write）
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, increment, NULL);
    pthread_create(&t2, NULL, increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Counter: %d (expected 2000000)\n", counter);
    // 実際には2000000より小さい値を出力
    return 0;
}

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

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;

void* safe_increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&lock);     // ロック取得
        counter++;                      // クリティカルセクション
        pthread_mutex_unlock(&lock);   // ロック解放
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, safe_increment, NULL);
    pthread_create(&t2, NULL, safe_increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Counter: %d\n", counter);  // 正確に2000000
    return 0;
}

import threading
import time

lock_a = threading.Lock()
lock_b = threading.Lock()

def thread_1():
    lock_a.acquire()
    time.sleep(0.1)
    lock_b.acquire()  # デッドロック！Thread 2がlock_bを保持中
    lock_b.release()
    lock_a.release()

def thread_2():
    lock_b.acquire()
    time.sleep(0.1)
    lock_a.acquire()  # デッドロック！Thread 1がlock_aを保持中
    lock_a.release()
    lock_b.release()

def safe_thread_1():
    lock_a.acquire()   # 常にlock_aを先に
    lock_b.acquire()
    lock_b.release()
    lock_a.release()

def safe_thread_2():
    lock_a.acquire()   # 常にlock_aを先に（同じ順序）
    lock_b.acquire()
    lock_b.release()
    lock_a.release()

┌────────────────────┐  速度：非常に速い
│    CPU Registers   │  容量：数KB
├────────────────────┤
│    L1 Cache        │  ~1ns, 64KB
├────────────────────┤
│    L2 Cache        │  ~4ns, 256KB
├────────────────────┤
│    L3 Cache        │  ~12ns, 数MB
├────────────────────┤
│    Main Memory     │  ~100ns, 数GB
├────────────────────┤
│    SSD             │  ~100us, 数TB
├────────────────────┤  速度：非常に遅い
│    HDD             │  ~10ms, 数TB
└────────────────────┘

論理アドレス空間            物理メモリ
┌───────────┐              ┌───────────┐
│  Page 0   │──────────▶  │  Frame 3  │
├───────────┤              ├───────────┤
│  Page 1   │──────────▶  │  Frame 7  │
├───────────┤              ├───────────┤
│  Page 2   │──────────▶  │  Frame 1  │
└───────────┘              └───────────┘

1. CPUが論理アドレスにアクセス
2. ページテーブルで有効ビットを確認
3. 無効 → ページフォルト割込み発生
4. OSがディスクから該当ページを探す
5. 空きフレーム割当（なければページ置換）
6. ディスクからフレームにロード
7. ページテーブル更新（有効ビット = 1）
8. 中断された命令を再実行

ユーザープログラム
    |
    v
VFS (Virtual File System)
    |
    +-->  ext4
    +-->  XFS
    +-->  NFS
    +-->  procfs (/proc)
    +-->  sysfs (/sys)

#include <sys/epoll.h>

int epoll_fd = epoll_create1(0);

struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;  // Edge-Triggered
ev.data.fd = listen_fd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev);

struct epoll_event events[MAX_EVENTS];
while (1) {
    int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
    for (int i = 0; i < nfds; i++) {
        if (events[i].data.fd == listen_fd) {
            int conn_fd = accept(listen_fd, ...);
        } else {
            handle_client(events[i].data.fd);
        }
    }
}

#include <sys/sendfile.h>
// ファイルをソケットに直接送信（ユーザー空間コピーなし）
sendfile(socket_fd, file_fd, NULL, file_size);

# プロセスのシステムコール追跡
strace -p 1234

# 特定のシステムコールのみフィルタリング
strace -e trace=open,read,write ./my_program

# 統計要約
strace -c ./my_program

# CPUプロファイリング
perf record -g ./my_program
perf report

# キャッシュミス確認
perf stat -e cache-misses,cache-references ./my_program

# 全システムコールカウント
bpftrace -e 'tracepoint:raw_syscalls:sys_enter { @[comm] = count(); }'

# プロセス別ファイルオープン追跡
bpftrace -e 'tracepoint:syscalls:sys_enter_openat {
    printf("%s opened %s\n", comm, str(args->filename));
}'

# Dockerのcgroupsリソース制限
docker run --cpus="0.5"           # CPU 50%制限
docker run --memory="512m"        # メモリ512MB制限
docker run --pids-limit=100       # 最大100プロセス