뮤텍스와 락

#include <iostream>
#include <thread>
#include <vector>
#include <chrono>

volatile int counter = 0; // 여러 스레드가 공유할 전역 변수 (volatile은 동기화·원자성을 제공하지 않음)

void increment_counter() {
    for (int i = 0; i < 100000; ++i) {
        counter++; // 이 부분에서 경쟁 조건 발생
    }
}

int main() {
    std::cout << "Initial counter value: " << counter << std::endl;

    // 10개의 스레드를 생성하여 counter를 10만 번씩 증가
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment_counter);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Final counter value: " << counter << std::endl;
    // 예상 값: 10 * 100000 = 1,000,000
    // data race에 따른 정의되지 않은 동작: 출력값을 예측하거나 성공 조건으로 삼지 않음

    return 0;
}

#include <iostream>
#include <thread>
#include <vector>
#include <mutex> // std::mutex를 위해

int counter_mutex = 0; // 공유 변수
std::mutex mtx;        // 뮤텍스 객체

void increment_counter_safe() {
    for (int i = 0; i < 100000; ++i) {
        mtx.lock();    // 임계 영역 진입 전에 뮤텍스 잠금
        counter_mutex++; // 임계 영역 (오직 하나의 스레드만 접근 가능)
        mtx.unlock();  // 임계 영역 벗어난 후 뮤텍스 해제
    }
}

int main() {
    std::cout << "Initial counter_mutex value: " << counter_mutex << std::endl;

    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment_counter_safe);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Final counter_mutex value: " << counter_mutex << std::endl;
    // 이제 예상 값인 1,000,000이 정확히 출력될 것입니다.

    return 0;
}

#include <iostream>
#include <thread>
#include <vector>
#include <mutex> // std::mutex, std::lock_guard를 위해

int counter_lock_guard = 0;
std::mutex mtx_guard;

void increment_counter_lock_guard() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx_guard); // 생성 시 mtx_guard 잠금
        counter_lock_guard++;
        // 스코프를 벗어나면 lock 객체 소멸, 자동으로 mtx_guard 잠금 해제
    }
}

int main() {
    std::cout << "Initial counter_lock_guard value: " << counter_lock_guard << std::endl;

    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment_counter_lock_guard);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Final counter_lock_guard value: " << counter_lock_guard << std::endl;
    // 항상 1,000,000이 출력될 것입니다.

    return 0;
}

#include <chrono>
#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx_unique;

void process_data(int id) {
    std::unique_lock<std::mutex> lock(mtx_unique); // 생성 시 잠금
    std::cout << "Thread " << id << " acquired lock.\n";
    // 필요한 경우, 잠금을 일시적으로 해제하고 다른 작업을 수행할 수 있음
    lock.unlock(); // 수동으로 잠금 해제

    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 다른 스레드에게 기회

    lock.lock(); // 다시 잠금
    std::cout << "Thread " << id << " re-acquired lock.\n";
    // 스코프를 벗어나면 lock 객체 소멸, 자동으로 mtx_unique 잠금 해제
}

int main() {
    std::thread t1(process_data, 1);
    std::thread t2(process_data, 2);

    t1.join();
    t2.join();

    return 0;
}

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
#include <shared_mutex> // std::shared_mutex, std::shared_lock을 위해
#include <chrono>

int shared_data = 0;
std::shared_mutex shared_mtx; // 공유 뮤텍스

void reader(int id) {
    for (int i = 0; i < 5; ++i) {
        std::shared_lock<std::shared_mutex> lock(shared_mtx); // 읽기 락 획득 (여러 스레드 동시 가능)
        std::cout << "Reader " << id << ": " << shared_data << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
}

void writer(int id) {
    for (int i = 0; i < 2; ++i) {
        std::unique_lock<std::shared_mutex> lock(shared_mtx); // 쓰기 락 획득 (단독 접근)
        shared_data++;
        std::cout << "Writer " << id << ": Increment to " << shared_data << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

int main() {
    std::vector<std::thread> readers;
    for (int i = 0; i < 3; ++i) {
        readers.emplace_back(reader, i + 1);
    }

    std::vector<std::thread> writers;
    for (int i = 0; i < 2; ++i) {
        writers.emplace_back(writer, i + 1);
    }

    for (auto& t : readers) t.join();
    for (auto& t : writers) t.join();

    std::cout << "Final shared_data: " << shared_data << std::endl;
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

std::mutex mtx1;
std::mutex mtx2;

void thread_func1() {
    // std::lock(mtx1, mtx2)는 두 뮤텍스를 동시에 잠그려고 시도하며,
    // 데드락 없이 안전하게 잠금을 획득하거나 실패합니다.
    // unique_lock을 지연 잠금으로 만들고 획득 후 RAII로 해제합니다.
    std::unique_lock<std::mutex> lk1(mtx1, std::defer_lock);
    std::unique_lock<std::mutex> lk2(mtx2, std::defer_lock);

    std::lock(lk1, lk2); // 두 뮤텍스를 동시에 잠금 시도 (데드락 방지)

    std::cout << "Thread 1: Acquired mtx1 and mtx2.\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 작업
    std::cout << "Thread 1: Releasing mtx1 and mtx2.\n";
} // 스코프 벗어나면 lk1, lk2 소멸하며 자동 해제

void thread_func2() {
    std::unique_lock<std::mutex> lk2(mtx2, std::defer_lock);
    std::unique_lock<std::mutex> lk1(mtx1, std::defer_lock);

    std::lock(lk2, lk1); // 두 뮤텍스를 동시에 잠금 시도

    std::cout << "Thread 2: Acquired mtx2 and mtx1.\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 작업
    std::cout << "Thread 2: Releasing mtx2 and mtx1.\n";
} // 스코프 벗어나면 lk2, lk1 소멸하며 자동 해제

int main() {
    std::cout << "Starting threads...\n";
    std::thread t1(thread_func1);
    std::thread t2(thread_func2);

    t1.join();
    t2.join();

    std::cout << "Threads finished.\n";
    return 0;
}