동시성과 병렬성 완전 정복: 멀티스레딩, 비동기, 이벤트 루프의 모든 것

"동시성(Concurrency)은 독립적으로 실행되는 작업들을 다루는 것이고,
 병렬성(Parallelism)은 여러 작업을 동시에 실행하는 것이다.
 동시성은 구조(structure)에 관한 것이고,
 병렬성은 실행(execution)에 관한 것이다."
                                          — Rob Pike

동시성 (Concurrency):          병렬성 (Parallelism):
한 사람이 두 가지 일을 번갈아    두 사람이 각각 한 가지 일을 동시에

   Task A ━━━━━━╸             Task A ━━━━━━━━━━━━
                 ╻             Task B ━━━━━━━━━━━━
   Task B ━━━━━━╸
                 ╻             CPU Core 1 ━━━━━━━━
   Task A ━━━━━━╸             CPU Core 2 ━━━━━━━━
                 ╻
   CPU Core 1 ━━━━━━━━
   (시분할로 번갈아 실행)       (물리적으로 동시 실행)

사용자 스레드:  T1    T2    T3    T4
               │      │      │      │
커널 스레드:   KT1   KT2   KT3   KT4
               │      │      │      │
CPU 코어:     Core1  Core2  Core1  Core2

사용자 스레드:  T1  T2  T3  T4  T5  T6
               └──┬──┘  └──┬──┘  └──┬──┘
                  │        │        │
커널 스레드:     KT1      KT1      KT1
                  │
CPU 코어:       Core1

사용자 스레드:  G1  G2  G3  G4  G5  G6  G7  G8
               └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘
                  │       │       │       │
커널 스레드:     KT1     KT2     KT3     KT4
                  │       │       │       │
CPU 코어:       Core1   Core2   Core3   Core4

┌─────────────────┬──────────────┬──────────────┬──────────────┐
│ 항목            │ 1:1          │ N:1          │ M:N          │
├─────────────────┼──────────────┼──────────────┼──────────────┤
│ 스레드 비용     │ ~1MB 스택    │ ~KB 스택     │ ~KB 스택     │
│ 생성 속도       │ 느림 (~ms)   │ 빠름 (~us)   │ 빠름 (~us)   │
│ 컨텍스트 스위치 │ 비쌈 (커널)  │ 저렴 (유저)  │ 저렴 (유저)  │
│ 멀티코어 활용   │ O            │ X            │ O            │
│ I/O 블로킹      │ 스레드만 블록│ 전체 블록    │ 스레드만 블록│
│ 최대 스레드 수  │ ~수천        │ ~수백만      │ ~수백만      │
│ 복잡도          │ 낮음         │ 중간         │ 높음         │
│ 예시            │ Java, C++,   │ 초기 Ruby    │ Go, Erlang,  │
│                 │ Rust          │              │ Java 21+     │
└─────────────────┴──────────────┴──────────────┴──────────────┘

package main

import (
    "fmt"
    "sync"
)

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

    urls := []string{
        "https://api.example.com/users",
        "https://api.example.com/orders",
        "https://api.example.com/products",
    }

    for _, url := range urls {
        wg.Add(1)
        go func(u string) {
            defer wg.Done()
            // HTTP 요청 시뮬레이션
            results <- fmt.Sprintf("Fetched: %s", u)
        }(url)
    }

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

    for result := range results {
        fmt.Println(result)
    }
}

import java.util.concurrent.*;
import java.util.List;

public class VirtualThreadExample {
    public static void main(String[] args) throws Exception {
        // Virtual Thread로 100만 동시 작업
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = List.of(
                executor.submit(() -> fetchURL("https://api.example.com/users")),
                executor.submit(() -> fetchURL("https://api.example.com/orders")),
                executor.submit(() -> fetchURL("https://api.example.com/products"))
            );

            for (var future : futures) {
                System.out.println(future.get());
            }
        }

        // Structured Concurrency (Preview)
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var user = scope.fork(() -> fetchUser(1));
            var order = scope.fork(() -> fetchOrder(1));

            scope.join();
            scope.throwIfFailed();

            System.out.println(user.get() + ", " + order.get());
        }
    }
}

import asyncio
import aiohttp

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        "https://api.example.com/users",
        "https://api.example.com/orders",
        "https://api.example.com/products",
    ]

    async with aiohttp.ClientSession() as session:
        # 동시에 모든 URL 요청
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)

        for url, result in zip(urls, results):
            print(f"Fetched {url}: {len(result)} bytes")

asyncio.run(main())

use tokio;
use reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let urls = vec![
        "https://api.example.com/users",
        "https://api.example.com/orders",
        "https://api.example.com/products",
    ];

    let mut handles = vec![];

    for url in urls {
        let handle = tokio::spawn(async move {
            let resp = reqwest::get(url).await?;
            let body = resp.text().await?;
            Ok::<String, reqwest::Error>(body)
        });
        handles.push(handle);
    }

    for handle in handles {
        match handle.await? {
            Ok(body) => println!("Fetched: {} bytes", body.len()),
            Err(e) => eprintln!("Error: {}", e),
        }
    }

    Ok(())
}

// Node.js 비동기 패턴
async function fetchAll() {
    const urls = [
        'https://api.example.com/users',
        'https://api.example.com/orders',
        'https://api.example.com/products',
    ];

    // Promise.all로 동시 실행
    const results = await Promise.all(
        urls.map(url => fetch(url).then(r => r.json()))
    );

    // Promise.allSettled로 실패 허용
    const settled = await Promise.allSettled(
        urls.map(url => fetch(url).then(r => r.json()))
    );

    settled.forEach((result, i) => {
        if (result.status === 'fulfilled') {
            console.log(`Success: ${urls[i]}`);
        } else {
            console.log(`Failed: ${urls[i]} - ${result.reason}`);
        }
    });
}

%% Erlang 프로세스 (경량 액터)
-module(counter).
-export([start/0, increment/1, get/1]).

start() ->
    spawn(fun() -> loop(0) end).

loop(Count) ->
    receive
        {increment, From} ->
            From ! {ok, Count + 1},
            loop(Count + 1);
        {get, From} ->
            From ! {value, Count},
            loop(Count);
        stop ->
            ok
    end.

increment(Pid) ->
    Pid ! {increment, self()},
    receive {ok, NewCount} -> NewCount end.

get(Pid) ->
    Pid ! {get, self()},
    receive {value, Count} -> Count end.

┌─────────────┬─────────────┬───────────────┬──────────────┬──────────────┐
│ 언어        │ 모델        │ 단위          │ 스케줄링     │ 특징         │
├─────────────┼─────────────┼───────────────┼──────────────┼──────────────┤
│ Go          │ CSP (M:N)   │ 고루틴        │ 런타임       │ 채널 통신    │
│ Java 21+    │ M:N         │ Virtual Thread│ JVM          │ 기존호환     │
│ Python      │ 이벤트루프  │ 코루틴        │ asyncio      │ GIL 제약     │
│ Rust        │ async/await │ Future/Task   │ tokio 등     │ 제로코스트   │
│ JavaScript  │ 이벤트루프  │ Promise       │ libuv/V8     │ 단일스레드   │
│ Erlang      │ Actor(M:N)  │ 프로세스      │ BEAM VM      │ 내결함성     │
│ Kotlin      │ 코루틴      │ Coroutine     │ Dispatcher   │ 구조적동시성 │
└─────────────┴─────────────┴───────────────┴──────────────┴──────────────┘

┌───────────────────────────┐
│         timers            │  ← setTimeout, setInterval
│    (타이머 콜백 실행)     │
├───────────────────────────┤
│     pending callbacks     │  ← 시스템 에러 콜백
│    (지연된 I/O 콜백)      │
├───────────────────────────┤
│       idle, prepare       │  ← 내부용
│    (내부 전용)            │
├───────────────────────────┤
│          poll             │  ← I/O 콜백 (대부분의 콜백)
│    (새 I/O 이벤트 대기)   │
├───────────────────────────┤
│          check            │  ← setImmediate 콜백
│    (setImmediate 실행)    │
├───────────────────────────┤
│     close callbacks       │  ← socket.on('close')
│    (종료 콜백)            │
└───────────────────────────┘
   각 단계 사이: 마이크로태스크 큐 처리
   (Promise.then, queueMicrotask, process.nextTick)

console.log('1: sync');

setTimeout(() => console.log('2: macro (setTimeout)'), 0);

Promise.resolve().then(() => console.log('3: micro (Promise)'));

queueMicrotask(() => console.log('4: micro (queueMicrotask)'));

console.log('5: sync');

// 출력 순서:
// 1: sync
// 5: sync
// 3: micro (Promise)
// 4: micro (queueMicrotask)
// 2: macro (setTimeout)

┌──────────────────────────────────────────┐
│              Node.js                     │
│  ┌─────────────────────────────────┐     │
│  │     JavaScript (V8 Engine)      │     │
│  │  ┌───────────┐  ┌────────────┐  │     │
│  │  │  Async    │  │ Event      │  │     │
│  │  │  APIs     │  │ Queue      │  │     │
│  │  └─────┬─────┘  └──────┬─────┘  │     │
│  └────────┼────────────────┼────────┘     │
│           │   Event Loop   │              │
│  ┌────────▼────────────────▼────────┐     │
│  │           libuv                   │     │
│  │  ┌──────────┐  ┌──────────────┐  │     │
│  │  │ Thread   │  │ epoll/kqueue │  │     │
│  │  │ Pool     │  │ /IOCP        │  │     │
│  │  │ (4 thds) │  │ (non-block)  │  │     │
│  │  └──────────┘  └──────────────┘  │     │
│  └───────────────────────────────────┘     │
│           │                │               │
│      File I/O          Network I/O         │
│      DNS lookup        TCP/UDP             │
│      Crypto            HTTP                │
└──────────────────────────────────────────┘

import asyncio

async def process_item(item: str) -> str:
    await asyncio.sleep(1)  # I/O 시뮬레이션
    return f"Processed: {item}"

async def main():
    items = ["a", "b", "c", "d", "e"]

    # 동시 실행
    tasks = [process_item(item) for item in items]
    results = await asyncio.gather(*tasks)
    print(results)  # 1초만에 모두 완료

    # 타임아웃
    try:
        result = await asyncio.wait_for(
            process_item("slow"),
            timeout=0.5
        )
    except asyncio.TimeoutError:
        print("Timeout!")

    # 세마포어로 동시 실행 수 제한
    semaphore = asyncio.Semaphore(3)

    async def limited_process(item):
        async with semaphore:
            return await process_item(item)

    results = await asyncio.gather(*[limited_process(i) for i in items])

asyncio.run(main())

import kotlinx.coroutines.*

suspend fun fetchUser(id: Int): User {
    delay(1000) // I/O 시뮬레이션
    return User(id, "User $id")
}

fun main() = runBlocking {
    // 구조적 동시성: 부모가 취소되면 자식도 취소
    coroutineScope {
        val user = async { fetchUser(1) }
        val orders = async { fetchOrders(1) }

        println("User: ${user.await()}")
        println("Orders: ${orders.await()}")
    } // 모든 자식 코루틴 완료까지 대기

    // SupervisorScope: 자식 실패가 다른 자식에 영향 안 줌
    supervisorScope {
        val job1 = launch {
            delay(100)
            throw RuntimeException("Failed!")
        }
        val job2 = launch {
            delay(200)
            println("Job2 completed") // 정상 실행
        }
    }
}

전통적 동시성:                구조적 동시성:
┌─────────────┐              ┌─────────────┐
│    Parent    │              │    Parent    │
│  ┌───┐ ┌───┐│              │  ┌───┐ ┌───┐│
│  │ A │ │ B ││              │  │ A │ │ B ││
│  └─┬─┘ └─┬─┘│              │  └─┬─┘ └─┬─┘│
└────┼─────┼───┘              └────┼─────┼───┘
     │     │ ← 누가 관리?          │     │ ← Parent가 관리
     ▼     ▼   누수 가능!          ▼     ▼   자동 정리!

규칙:
1. 모든 동시 작업은 스코프 내에서 시작
2. 스코프는 모든 자식 작업 완료까지 대기
3. 부모 취소 시 모든 자식도 취소
4. 자식 에러는 부모에게 전파

┌──────────┐     메시지     ┌──────────┐
│  Actor A │ ─────────────→ │  Actor B │
│          │                │          │
│ State: x │     메시지     │ State: y │
│ Mailbox  │ ←───────────── │ Mailbox  │
└──────────┘                └──────────┘
     │
     │ 메시지
     ▼
┌──────────┐
│  Actor C │
│ State: z │
│ Mailbox  │
└──────────┘

핵심: 공유 상태 없음, 락 없음, 메시지 전달만

                  ┌──────────────┐
                  │  Supervisor  │
                  │  (one_for_one)│
                  └──────┬───────┘
                    ┌────┼────┐
                    ▼    ▼    ▼
              ┌─────┐ ┌─────┐ ┌─────┐
              │ W1  │ │ W2  │ │ W3  │
              └─────┘ └─────┘ └─────┘

W2가 크래시하면:
1. Supervisor가 감지
2. W2만 재시작 (one_for_one 전략)
3. W1, W3는 영향 없음
4. 5분 안에 5번 이상 재시작하면 Supervisor도 종료

적합한 경우:
- 수백만 독립적 상태 관리 (채팅방, IoT 디바이스)
- 분산 시스템 (노드 간 통신)
- 내결함성이 필수인 시스템 (통신, 금융)
- 실시간 시스템 (게임 서버, 트레이딩)

부적합한 경우:
- 단순한 CRUD 애플리케이션
- 강한 일관성(strong consistency) 필요
- 트랜잭션 처리가 핵심
- 순서 보장이 중요한 파이프라인

// Go - Mutex
type SafeMap struct {
    mu   sync.Mutex
    data map[string]int
}

func (m *SafeMap) Set(key string, val int) {
    m.mu.Lock()
    defer m.mu.Unlock()
    m.data[key] = val
}

func (m *SafeMap) Get(key string) (int, bool) {
    m.mu.Lock()
    defer m.mu.Unlock()
    val, ok := m.data[key]
    return val, ok
}

// Java - ReentrantLock
import java.util.concurrent.locks.ReentrantLock;

public class SafeCounter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}

// 여러 고루틴이 동시에 읽기 가능
func (c *Cache) Get(key string) (string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    val, ok := c.data[key]
    return val, ok
}

// 쓰기는 배타적 잠금
func (c *Cache) Set(key, val string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = val
}

import asyncio

async def worker(name, semaphore):
    async with semaphore:
        print(f"{name} acquired semaphore")
        await asyncio.sleep(1)
        print(f"{name} released semaphore")

async def main():
    # 최대 3개 동시 실행
    semaphore = asyncio.Semaphore(3)

    tasks = [worker(f"Worker-{i}", semaphore) for i in range(10)]
    await asyncio.gather(*tasks)

asyncio.run(main())

type BoundedQueue struct {
    mu       sync.Mutex
    notEmpty *sync.Cond
    notFull  *sync.Cond
    items    []interface{}
    maxSize  int
}

func NewBoundedQueue(maxSize int) *BoundedQueue {
    q := &BoundedQueue{maxSize: maxSize}
    q.notEmpty = sync.NewCond(&q.mu)
    q.notFull = sync.NewCond(&q.mu)
    return q
}

func (q *BoundedQueue) Put(item interface{}) {
    q.mu.Lock()
    defer q.mu.Unlock()

    for len(q.items) == q.maxSize {
        q.notFull.Wait() // 공간이 생길 때까지 대기
    }
    q.items = append(q.items, item)
    q.notEmpty.Signal() // 소비자 깨우기
}

func (q *BoundedQueue) Take() interface{} {
    q.mu.Lock()
    defer q.mu.Unlock()

    for len(q.items) == 0 {
        q.notEmpty.Wait() // 아이템이 올 때까지 대기
    }
    item := q.items[0]
    q.items = q.items[1:]
    q.notFull.Signal() // 생산자 깨우기
    return item
}

import "sync/atomic"

type LockFreeCounter struct {
    value int64
}

func (c *LockFreeCounter) Increment() int64 {
    for {
        old := atomic.LoadInt64(&c.value)
        new := old + 1
        if atomic.CompareAndSwapInt64(&c.value, old, new) {
            return new
        }
        // CAS 실패 시 재시도 (다른 고루틴이 먼저 변경)
    }
}

func (c *LockFreeCounter) Get() int64 {
    return atomic.LoadInt64(&c.value)
}

스레드 A: 값 읽기 → A
                          스레드 B: A → B 변경
                          스레드 B: B → A 변경 (원래 값으로 복원)
스레드 A: CAS(A → C) 성공! (하지만 중간에 값이 변했었음)

해결책:
- 버전 번호 추가 (A,v1 → B,v2 → A,v3)
- 태그된 포인터 (AtomicStampedReference in Java)
- Hazard Pointer

Lock-Free가 적합한 경우:
- 매우 높은 경합(contention) 상황
- 실시간 시스템 (우선순위 역전 방지)
- 단순한 자료구조 (카운터, 스택, 큐)

Lock-Free를 피해야 하는 경우 (대부분의 경우):
- 일반적인 애플리케이션 (Mutex로 충분)
- 복잡한 자료구조 (트리, 그래프)
- 정확성 검증이 어려운 상황
- 팀원이 Lock-Free에 익숙하지 않은 경우

"Mutex가 작동하면 Mutex를 쓰세요."

// 버그: 여러 고루틴이 동시에 counter 수정
var counter int

func buggyIncrement() {
    for i := 0; i < 1000; i++ {
        go func() {
            counter++ // 읽기-수정-쓰기가 원자적이지 않음
        }()
    }
}

// 해결: atomic 또는 mutex 사용
var safeCounter int64

func safeIncrement() {
    for i := 0; i < 1000; i++ {
        go func() {
            atomic.AddInt64(&safeCounter, 1)
        }()
    }
}

4가지 필요조건 (모두 만족해야 데드락):
1. 상호 배제 (Mutual Exclusion): 리소스를 한 번에 하나만 사용
2. 점유와 대기 (Hold and Wait): 리소스 점유하면서 다른 리소스 대기
3. 비선점 (No Preemption): 점유된 리소스를 강제로 빼앗을 수 없음
4. 순환 대기 (Circular Wait): A→B→C→A 순환 대기

// 데드락 예시
var mu1, mu2 sync.Mutex

func goroutine1() {
    mu1.Lock()
    defer mu1.Unlock()
    time.Sleep(time.Millisecond)
    mu2.Lock()       // mu2 대기 (goroutine2가 점유)
    defer mu2.Unlock()
}

func goroutine2() {
    mu2.Lock()
    defer mu2.Unlock()
    time.Sleep(time.Millisecond)
    mu1.Lock()       // mu1 대기 (goroutine1이 점유)
    defer mu1.Unlock()
}

// 해결: 항상 같은 순서로 잠금 획득
func fixed1() {
    mu1.Lock()
    defer mu1.Unlock()
    mu2.Lock()
    defer mu2.Unlock()
}

func fixed2() {
    mu1.Lock()       // mu1을 먼저 (같은 순서)
    defer mu1.Unlock()
    mu2.Lock()
    defer mu2.Unlock()
}

A와 B가 좁은 복도에서 만남:
A: 왼쪽으로 비킴 ← → B: 오른쪽으로 비킴 (같은 방향!)
A: 오른쪽으로 비킴 ← → B: 왼쪽으로 비킴 (또 같은 방향!)
... (무한 반복, 아무도 진행 못함)

vs 데드락: 아무것도 안 함
vs 라이브락: 계속 움직이지만 진행 없음

1997년 화성 탐사선 Mars Pathfinder 사건:

Low-priority 태스크가 뮤텍스 점유
   ↓
Medium-priority 태스크가 Low를 선점 (뮤텍스 무관)
   ↓
High-priority 태스크가 뮤텍스 대기... 영원히!
(Low가 실행돼야 뮤텍스 해제되는데, Medium이 계속 선점)

해결: 우선순위 상속 프로토콜
Low가 뮤텍스를 점유하면 High의 우선순위를 일시적으로 상속

# Go: 레이스 디텍터
go test -race ./...
go run -race main.go

# Java: Thread Sanitizer
java -XX:+UseThreadSanitizer MyApp

# Rust: 컴파일러가 컴파일 타임에 감지!
# Send/Sync 트레잇 위반 시 컴파일 에러

# Python: ThreadSanitizer (C extension)
# 또는 asyncio.debug 모드
PYTHONASYNCIODEBUG=1 python app.py

# 일반: Helgrind (Valgrind 도구)
valgrind --tool=helgrind ./program

func producerConsumer() {
    ch := make(chan int, 100) // 버퍼 있는 채널

    // 생산자들
    var prodWg sync.WaitGroup
    for i := 0; i < 3; i++ {
        prodWg.Add(1)
        go func(id int) {
            defer prodWg.Done()
            for j := 0; j < 10; j++ {
                ch <- id*100 + j
            }
        }(i)
    }

    // 채널 닫기
    go func() {
        prodWg.Wait()
        close(ch)
    }()

    // 소비자들
    var consWg sync.WaitGroup
    for i := 0; i < 2; i++ {
        consWg.Add(1)
        go func(id int) {
            defer consWg.Done()
            for item := range ch {
                fmt.Printf("Consumer %d: %d\n", id, item)
            }
        }(i)
    }

    consWg.Wait()
}

import asyncio
from asyncio import Queue

async def worker(name: str, queue: Queue):
    while True:
        item = await queue.get()
        try:
            await process(item)
        finally:
            queue.task_done()

async def main():
    queue = Queue(maxsize=100)

    # 워커 5개 시작
    workers = [
        asyncio.create_task(worker(f"worker-{i}", queue))
        for i in range(5)
    ]

    # 작업 추가
    for item in range(50):
        await queue.put(item)

    # 모든 작업 완료 대기
    await queue.join()

    # 워커 종료
    for w in workers:
        w.cancel()

asyncio.run(main())

전통적 스레드 풀:           Work Stealing:
┌─────────────┐            ┌─────────────┐
│ 공유 큐     │            │ Worker 1    │
│ [T1|T2|T3]  │            │ 로컬큐:[T1] │
│             │            ├─────────────┤
│ 모든 워커가  │            │ Worker 2    │
│ 경합!       │            │ 로컬큐:[T2] │  ← 비면 Worker 1에서 훔침
│             │            ├─────────────┤
└─────────────┘            │ Worker 3    │
                           │ 로컬큐:[T3] │
                           └─────────────┘

장점: 캐시 지역성 향상, 경합 감소
사용: Java ForkJoinPool, Go 런타임, Tokio(Rust)

속도 향상 = 1 / ((1 - P) + P/N)

P = 병렬화 가능한 비율
N = 프로세서 수

예: 프로그램의 95%가 병렬화 가능, 64코어일 때
속도 향상 = 1 / (0.05 + 0.95/64) = 1 / 0.0648 = 15.4배

→ 아무리 코어를 늘려도 직렬 부분(5%)이 병목!
→ 최대 이론적 속도 향상 = 1/0.05 = 20배

속도 향상 = N - alpha * (N - 1)

alpha = 직렬 부분의 비율
N = 프로세서 수

핵심 차이:
- 암달: "문제 크기 고정, 코어를 늘리면?"
- 구스타프슨: "코어 고정, 문제 크기를 늘리면?"

→ 현실에서는 데이터가 늘어나면 병렬 부분도 늘어남
→ 구스타프슨이 더 낙관적이고 현실적

컨텍스트 스위치 비용 비교:
┌───────────────────────────┬──────────────┐
│ 스위치 유형               │ 대략적 비용  │
├───────────────────────────┼──────────────┤
│ 함수 호출                 │ ~1-5 ns      │
│ 고루틴 스위치             │ ~100-200 ns  │
│ 코루틴 스위치 (Python)    │ ~1-5 us      │
│ 스레드 스위치 (같은 프로세스)│ ~1-10 us   │
│ 프로세스 스위치            │ ~10-50 us    │
│ 가상머신 스위치            │ ~100+ us     │
└───────────────────────────┴──────────────┘

문제: 서로 다른 변수가 같은 캐시 라인에 위치

CPU Core 1          CPU Core 2
    │                   │
┌───▼───────────────────▼───┐
│ Cache Line (64 bytes)     │
│ [counter_A] [counter_B]   │  ← 서로 다른 변수인데
│                           │     같은 캐시 라인!
└───────────────────────────┘

Core 1이 counter_A 수정 → Cache Line 무효화 → Core 2도 재로드 필요
Core 2가 counter_B 수정 → Cache Line 무효화 → Core 1도 재로드 필요

해결: 패딩으로 캐시 라인 분리

// Go에서 False Sharing 방지
type PaddedCounter struct {
    value int64
    _pad  [56]byte // 64바이트 캐시 라인 패딩
}

type Counters struct {
    c1 PaddedCounter
    c2 PaddedCounter
}