#include <thread>
#include <mutex>

std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock{mtx};  // 잠금 (범위 종료 시 자동 해제)
    ++counter;
}

int main() {
    std::thread t1{increment};
    std::thread t2{increment};
    t1.join();   // t1 완료 대기
    t2.join();   // t2 완료 대기
}

#include <thread>
#include <iostream>

void task(int id) {
    std::cout << "스레드 " << id << " 실행\n";
}

// 함수 포인터
std::thread t1{task, 1};

// lambda
std::thread t2{[](int id){ std::cout << id; }, 2};

// join — 스레드가 끝날 때까지 호출 스레드가 대기
t1.join();

// detach — 호출 스레드와 분리, 독립적으로 실행
// t2.detach();  // join 또는 detach 중 하나는 반드시 호출해야 함
t2.join();

#include <mutex>

std::mutex mtx;
int shared = 0;

void safeIncrement() {
    mtx.lock();
    ++shared;           // 한 번에 하나의 스레드만 진입
    mtx.unlock();
}

// ❌ lock/unlock 직접 호출 — 예외 발생 시 unlock 누락 위험

// lock_guard — 간단한 잠금, 범위 벗어나면 자동 해제
void safe1() {
    std::lock_guard<std::mutex> lock{mtx};
    ++shared;
}   // 여기서 자동 unlock

// unique_lock — 잠금/해제를 수동 제어하거나 조건 변수와 함께 사용
void safe2() {
    std::unique_lock<std::mutex> lock{mtx};
    ++shared;
    lock.unlock();      // 명시적 해제 가능
    // 잠금 없이 다른 작업...
    lock.lock();        // 다시 잠금
}

#include <condition_variable>
#include <queue>

std::mutex qmtx;
std::condition_variable cv;
std::queue<int> dataQueue;

// 생산자
void producer() {
    std::lock_guard<std::mutex> lock{qmtx};
    dataQueue.push(42);
    cv.notify_one();    // 대기 중인 스레드 하나 깨우기
}

// 소비자
void consumer() {
    std::unique_lock<std::mutex> lock{qmtx};
    cv.wait(lock, []{ return !dataQueue.empty(); });  // 조건 만족까지 대기
    int val = dataQueue.front();
    dataQueue.pop();
}

#include <atomic>

std::atomic<int> counter{0};

void increment() {
    ++counter;              // 원자적 증가 — 데이터 경쟁 없음
    counter.fetch_add(1);   // 동일, 이전 값 반환
    counter.fetch_sub(1);   // 원자적 감소

    // CAS (Compare-And-Swap) — lock-free 알고리즘의 핵심
    int expected = 5;
    bool ok = counter.compare_exchange_strong(expected, 10);
    // counter == expected(5)이면 10으로 교환, ok = true
    // 다르면 expected = counter 현재값, ok = false
}

// thread_local: 스레드마다 독립적인 인스턴스
thread_local int perThreadCounter = 0;

void worker() {
    ++perThreadCounter;   // 각 스레드의 자신만의 카운터
    std::cout << "스레드 카운터: " << perThreadCounter << "\n";
}

// t1과 t2는 각자의 perThreadCounter를 가짐 — 공유 없음
std::thread t1{worker};
std::thread t2{worker};
t1.join(); t2.join();
// 두 스레드 모두 "스레드 카운터: 1" 출력

#include <future>

int heavyWork(int n) {
    return n * n;
}

// async로 비동기 실행 후 future로 결과 수신
std::future<int> result = std::async(std::launch::async, heavyWork, 10);

// 다른 작업 수행...

int value = result.get();   // 완료까지 대기 후 값 반환 (100)