[C++] 21. 스레드 경쟁 상태(Race condition), 뮤텍스(mutex), 데드락, std::conditional_variable, std::async

 

 

지난 포스팅에서는 멀티스레드와 멀티 프로세스, std::thread에 대해 살펴봤습니다. [C++] 20. 멀티 스레드 프로그래밍(Multi-Threads)

오늘은 이어서 스레드끼리의 충돌 문제와 lock 문제를 살펴보고, 스레드들(workers)이 wait상태에서 대기하다가 작업이 있을 때 알아서 처리하는 스마트한 운영방식에 대해 알아보고자 합니다.

 

 

 

공유자원(Shared Resources)과 임계영역(Critical Section)

스레드(Thread)는 프로세스 내에서 실행되는 작은 실행 단위로, 하나의 프로세스 안에 여러 개의 스레드가 존재할 수 있습니다. 이때 스레드 간에는 공유자원(Shared Resource)과 관련된 문제가 발생할 수 있습니다. 이러한 공유자원을 안전하게 사용하기 위해 임계영역(Critical Section)이라는 개념이 등장합니다.

공유자원은 여러 스레드가 동시에 접근하거나 수정할 수 있는 데이터나 자원을 말합니다. 예를 들어, 메모리 공간, 파일, 데이터베이스 등이 공유자원에 해당할 수 있습니다. 스레드들은 이러한 공유자원에 접근하거나 수정하는 작업을 수행할 수 있습니다.

그러나 여러 스레드가 동시에 공유자원을 접근하거나 수정하려고 할 때 문제가 발생할 수 있습니다. 이때 임계영역이란, 공유자원에 대한 접근을 동기화하여 한 번에 하나의 스레드만이 임계영역에 진입하여 작업을 수행하도록 하는 부분을 말합니다. 이는 다수의 스레드가 공유자원을 안전하게 사용하기 위해 필요한 메커니즘입니다.

임계영역을 관리하기 위한 기법에는 뮤텍스(Mutex), 세마포어(Semaphore), 스레드-로컬 저장소(Thread-Local Storage) 등이 있습니다. 이러한 동기화 기법을 사용하여 스레드들이 임계영역에 접근할 때 서로의 작업이 겹치지 않도록 보장할 수 있습니다. 이로써 데이터 일관성과 안정성을 유지하면서 공유자원을 사용할 수 있게 됩니다.

요약하자면, 스레드 간에 공유하는 자원에 접근할 때 발생할 수 있는 문제를 해결하기 위해 임계영역이라는 개념이 등장합니다. 임계영역은 동기화 기법을 통해 여러 스레드가 안전하게 공유자원을 사용할 수 있도록 보장합니다.

 

 

 

경쟁상태(Race Condition)

스레드의 경쟁상태(Race Condition)는 여러 개의 스레드가 공유자원에 접근하거나 수정하려고 할 때, 스레드들의 실행 순서에 의존하여 예상치 못한 결과가 발생하는 상황을 말합니다. 이러한 상황은 스레드 간의 경쟁으로 인해 발생하며, 프로그램의 실행 결과가 일관되지 않거나 잘못된 결과가 나올 수 있습니다.

경쟁상태는 주로 공유자원에 대한 접근이나 수정이 동기화 없이 이루어지는 경우에 발생합니다. 예를 들어, 여러 스레드가 동시에 같은 변수를 읽거나 수정하려고 할 때 발생할 수 있습니다. 만약 이러한 작업이 잘못된 순서로 이루어지면, 예상치 못한 값이나 오작동이 발생할 수 있습니다.

경쟁상태는 다양한 문제를 야기할 수 있는데, 그 중 일반적인 문제들은 다음과 같습니다.

1. 데이터 일관성 문제: 여러 스레드가 동시에 같은 데이터를 수정하는 경우, 스레드 간에 데이터가 일관성 없이 변경되어 예상치 못한 결과를 초래할 수 있습니다.

2. 교착상태(Deadlock): 두 개 이상의 스레드가 서로 상대방이 접근하고 있는 자원을 기다리며 무한히 대기하는 상태로, 프로그램이 멈추는 문제가 발생합니다.

3. 쓰기 후 읽기 문제: 한 스레드가 데이터를 수정하는 도중에 다른 스레드가 같은 데이터를 읽으면, 데이터의 일관성이 깨질 수 있습니다.

4. 인터럽트 문제: 인터럽트나 타이머 등의 외부 요인으로 인해 스레드의 실행이 중단될 때, 공유자원의 상태가 일관되지 않을 수 있습니다.

이러한 문제를 해결하기 위해서는 스레드 간의 동기화 메커니즘을 사용하여 경쟁상태를 방지하거나 제어해야 합니다. 뮤텍스(Mutex), 세마포어(Semaphore), 임계영역(Critical Section) 등의 기법을 활용하여 공유자원의 접근을 조절함으로써 경쟁상태를 피하고 프로그램의 안정성을 확보할 수 있습니다.

 

 

 

데드락(Dead Lock)

데드락(Deadlock)은 멀티스레드 환경에서 발생하는 동기화 문제 중 하나로, 두 개 이상의 스레드나 프로세스가 서로가 가진 자원을 점유하고 있어서 계속해서 상대방이 점유하고 있는 자원을 기다리며 아무 동작도 수행하지 못하는 상태를 말합니다. 이러한 상황에서는 각 스레드나 프로세스가 다음 단계로 진행하지 못하므로, 프로그램이 무한히 멈춘 것처럼 보일 수 있습니다.

데드락이 발생하려면 아래의 네 가지 조건이 모두 충족되어야 합니다.

1. 상호 배제(Mutual Exclusion): 자원은 한 번에 하나의 스레드나 프로세스만이 사용할 수 있어야 합니다. 즉, 한 자원은 동시에 여러 스레드나 프로세스에 의해 사용될 수 없습니다.

2. 점유와 대기(Hold and Wait): 최소한 하나의 자원을 점유한 상태에서 다른 자원을 기다리는 스레드나 프로세스가 있어야 합니다.

3. 비선점(No Preemption): 다른 스레드나 프로세스에 의해 점유된 자원을 강제로 빼앗을 수 없어야 합니다. 자원은 해당 스레드나 프로세스가 반납하기 전까지 점유되어야 합니다.

4. 순환 대기(Circular Wait): 각 스레드나 프로세스는 다음 스레드나 프로세스가 점유한 자원을 기다리며 원형으로 대기하는 상황이어야 합니다.

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

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

void threadFunction1() {
    std::lock_guard<std::mutex> lock1(mtx1);
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 잠시 대기
    std::cout << "Thread 1 locked mtx1" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 잠시 대기

    std::lock_guard<std::mutex> lock2(mtx2);
    std::cout << "Thread 1 locked mtx2" << std::endl;
}

void threadFunction2() {
    std::lock_guard<std::mutex> lock2(mtx2);
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 잠시 대기
    std::cout << "Thread 2 locked mtx2" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 잠시 대기

    std::lock_guard<std::mutex> lock1(mtx1);
    std::cout << "Thread 2 locked mtx1" << std::endl;
}

int main() {
    std::thread t1(threadFunction1);
    std::thread t2(threadFunction2);

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

    return 0;
}

 

위 예제에서는 두 개의 스레드가 각자 함수를 실행하면서 두 개의 뮤텍스(mtx1, mtx2)를 사용하고 있습니다. Function1에서는 mtx1을 점유한 채로 mtx2를 점유하려고 하고, Function2에서는 mtx2를 점유한 채로 mtx1을 점유하려고 합니다. 데드락이 걸린 상황입니다. 

실제 프로그래밍에서는 이러한 데드락 상황을 피하고자 뮤텍스를 올바르게 사용하고, 순서대로 점유하거나 획득하는 등의 방법을 사용하여 데드락을 예방해야 합니다.

 

 

 

뮤텍스(Mutex)

뮤텍스(Mutex)는 상호 배제(Mutual Exclusion)를 구현하기 위한 동기화 기법 중 하나로, 여러 개의 스레드나 프로세스가 공유 자원에 동시에 접근하는 것을 막는 역할을 합니다. 뮤텍스는 한 번에 하나의 스레드만이 특정 자원을 사용할 수 있도록 제어하는 데 사용됩니다.

뮤텍스는 크게 두 가지 상태를 가집니다.

1. 잠금(Locked) 상태: 뮤텍스가 다른 스레드에 의해 잠겨져 있는 상태로, 해당 자원에 접근할 수 없습니다.
2. 잠금 해제(Unlocked) 상태: 뮤텍스가 다른 스레드에 의해 잠금 해제되어 해당 자원에 접근할 수 있는 상태입니다.

뮤텍스를 사용하는 일반적인 패턴은 스레드가 자원에 접근하기 전에 뮤텍스를 통해 Lock을 걸고, 자원을 사용한 후에 잠금 해제(Unlock) 상태로 만듭니다.

이러한 접근 방식으로 뮤텍스를 사용하면 한 번에 하나의 스레드만이 자원에 접근하게 되므로 경쟁상태(Race Condition)나 데드락(Deadlock) 등의 문제를 방지할 수 있습니다.

 

 

조건변수(condition_variable)

std::condition_variable은 C++ 표준 라이브러리의 동기화 기능 중 하나로, 스레드 간의 상호작용과 동기화를 위해 사용되는 클래스입니다. 주로 특정 조건이 만족될 때까지 스레드의 대기(wait) 및 통지(notify) 기능을 제공하여 스레드들이 효율적으로 협력하고 조정할 수 있게 해줍니다.

std::condition_variable을 사용하면 스레드가 특정 조건을 기다리며 대기하는 동안, 다른 스레드가 그 조건이 만족되면 대기 중인 스레드를 깨우고 통지할 수 있습니다. 이는 스레드 간의 효율적인 작업 분배와 협력을 가능하게 합니다.

std::condition_variable을 사용하려면 주로 두 가지 동작을 수행합니다:

1. 대기(wait)하기: 스레드가 특정 조건을 만족할 때까지 대기하는 상태로 들어갑니다. std::condition_variable 객체와 함께 std::unique_lock을 사용하여 뮤텍스와 연계하여 대기 상태로 들어갑니다.

2. 통지(notify)하기: 특정 조건이 만족되었을 때, 다른 스레드를 대기 상태에서 깨우고 작업을 계속하도록 합니다. notify_one 또는 notify_all 함수를 사용하여 대기 중인 스레드를 깨울 수 있습니다.

아래는 std::condition_variable을 사용한 간단한 예제 코드입니다:

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void workerThread() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    {
        std::unique_lock<std::mutex> lock(mtx);
        ready = true;
        std::cout << "Worker thread is ready." << std::endl;
    }
    
    cv.notify_one();
}

int main() {
    std::thread t(workerThread);

    {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return ready; });
        std::cout << "Main thread received notification." << std::endl;
    }

    t.join();

    return 0;
}

이 예제에서 workerThread는 2초 후에 ready 변수를 true로 설정하고, cv.notify_one()을 호출하여 대기 중인 스레드를 깨우는 역할을 합니다. main 함수에서는 cv.wait()을 호출하여 ready 변수의 변경을 기다린 후 통지를 받아 처리합니다.

 

아래는 condition_variable의 wait_for(대기 시간 지정)를 사용한 예제입니다.

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void workerThread() {
    std::this_thread::sleep_for(std::chrono::seconds(2));

    {
        std::unique_lock<std::mutex> lock(mtx);
        ready = true;
        std::cout << "Worker thread is ready." << std::endl;
    }

    cv.notify_one();
}

int main() {
    std::thread t(workerThread);

    {
        std::unique_lock<std::mutex> lock(mtx);
        if (cv.wait_for(lock, std::chrono::seconds(1), [] { return ready; })) {
            std::cout << "Main thread received notification." << std::endl;
        } else {
            std::cout << "Main thread timed out waiting for notification." << std::endl;
        }
    }

    t.join();

    return 0;
}

cv.wait_for() 함수는 대기 중인 스레드가 ready 변수가 true로 변경되거나 최대 1초가 경과할 때까지 대기합니다. 경과한 시간이 대기 시간을 초과하면 cv.wait_for()는 false를 반환하고, 그렇지 않은 경우에는 true를 반환하면서 대기 중인 스레드를 깨우게 됩니다.

 

 

 

std::async

std::async는 C++ 표준 라이브러리에서 제공하는 비동기 작업을 생성하고 관리하기 위한 함수입니다. 이를 통해 함수나 함수 객체를 비동기적으로 실행하며, 별도의 스레드에서 작업을 처리하거나 백그라운드에서 실행할 수 있습니다. std::async는 간단한 비동기 작업을 처리하고 결과를 반환받을 때 유용하게 사용됩니다.

std::async 함수의 기본 형식은 다음과 같습니다.

template <class Function, class... Args>
std::future<typename std::result_of<Function(Args...)>::type>
std::async(std::launch policy, Function&& f, Args&&... args);

std::async 함수를 사용하는 방법은 다음과 같습니다.

1. std::launch 열거형을 이용하여 실행 정책을 지정합니다. 주로 std::launch::async나 std::launch::deferred를 사용합니다.
   - std::launch::async: 새로운 스레드에서 비동기 작업을 실행합니다.
   - std::launch::deferred: 작업을 호출하지 않고 결과를 요청할 때까지 지연시킵니다.

2. 비동기로 실행할 함수나 함수 객체를 전달합니다.

3. 함수에 필요한 인자들을 전달합니다.

std::async는 반환값으로 std::future 객체를 반환하는데, 이 객체를 통해 비동기 작업의 상태를 확인하고 결과를 얻을 수 있습니다.

간단한 예제 코드를 통해 std::async를 사용하는 방법을 보여드리겠습니다.

#include <iostream>
#include <future>

int add(int a, int b) {
    return a + b;
}

int main() {
    // 비동기 작업을 실행하고 결과를 std::future로 받음
    std::future<int> result = std::async(std::launch::async, add, 3, 5);

    // 결과를 얻기 위해 wait 및 get을 사용
    result.wait();
    int sum = result.get();

    std::cout << "Sum: " << sum << std::endl;

    return 0;
}

 std::async를 사용하여 add 함수를 비동기적으로 실행하고, 결과를 얻기 위해 std::future의 wait와 get 함수를 사용합니다. std::launch::async를 사용하면 새로운 스레드에서 작업을 실행하게 됩니다.

 

좀더 복잡한 예제를 보시죠.

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <future>

int parallelSum(const std::vector<int>& data, size_t chunkSize) {
    std::vector<std::future<int>> futures;

    // 벡터를 chunkSize만큼 나누어 병렬로 합산 작업 수행
    for (size_t i = 0; i < data.size(); i += chunkSize) {
        auto chunkBegin = data.begin() + i;
        auto chunkEnd = chunkBegin + chunkSize;

        futures.push_back(std::async(std::launch::async,
                                     [](std::vector<int>::const_iterator begin, std::vector<int>::const_iterator end) {
                                         return std::accumulate(begin, end, 0);
                                     },
                                     chunkBegin, chunkEnd));
    }

    // 개별 작업 결과를 모두 합산
    int totalSum = 0;
    for (auto& future : futures) {
        totalSum += future.get();
    }

    return totalSum;
}

int main() {
    std::vector<int> data(10000);
    std::iota(data.begin(), data.end(), 1); // 1부터 10000까지의 수로 채움

    const size_t chunkSize = 1000;
    int sum = parallelSum(data, chunkSize);

    std::cout << "Parallel Sum: " << sum << std::endl;

    return 0;
}

벡터의 원소들을 병렬로 합산하는 작업입니다. 벡터를 여러 개의 청크(chunk)로 나누어 각 청크를 별도의 스레드에서 합산하고, 그 결과를 모두 합산하여 병렬 합산을 수행합니다. 각 청크를 별도의 std::async 작업으로 실행하며, std::accumulate를 사용하여 각 청크의 합을 계산합니다. 마지막으로 모든 작업의 결과를 합산하여 최종 결과를 얻습니다.

 

std::async는 작업(task)기반 접근이며 std::thread는 스레드(thread)기반 접근 방식입니다. 저 같은 경우, 범용적인 경우에는 std::async를 사용하며, 스레드의 작업을 특수하고 세세하게 조정하거나 스레드풀을 만들 경우에는 std::thread를 사용합니다.

Effective c++에서도 std::async를 권장합니다. 그 이유는, std::async는 OS 내부에서 Thread Pool을 만들어 사용하기 때문에 많은 리소스를 요구하지 않습니다. 또한 thread와 달리 return값이 있어서 이를 활용할 수 있다는 점과 예외처리가 더 효율적이라는 것이 장점입니다.

 

 

 

마무리

현업에서는 모든 C++로 구성된 서버 프로그램 & 데몬 프로그램은 멀티스레드 환경입니다. 멀티스레드를 이해하고 다룰 수 있는 능력이 고급 개발자로 가기 위한 판별 중 하나입니다. 멀티스레드 프로그래밍은 디버깅도 쉽지 않으며 직관적이지 않기 때문에 코드를 작성하더라도 어떻게 흘러가는지 이해하기 쉽지 않습니다. 각각의 스레드의 동작과 공유자원 관리, 스레드끼리의 충돌상황 등을 운영체제와 메모리 관점에서 이해하려고 노력해야 합니다.

 

멀티스레드를 사용하는 이유는 대부분 병렬처리를 하기 위함입니다. 한꺼번에 많은 양의 이벤트 or 작업이 있을 때 여러 개의 스레드에게 별도의 작업 처리를 맡깁니다. 만약 스레드끼리 공유해야 하는 자원이 있을 경우 적절한 위치에 mutex lock을 사용하여 자원의 독점권을 가지도록 합니다. mutex lock으로 스레드가 자원을 점유하는 시간이 짧을 수록 처리속도는 증가합니다. 물론 lock을 안쓰는 것이 제일 좋겠죠.

 

여러 개의 스레드에게 작업 처리를 맡길 때 condition_variable의 notify()를 사용합니다. 스레드들은 작업이 없을 때 wait상태로 대기하고 있다가 작업이 몰렸을 때, notify()를 통해 wait상태에서 벗어나고 정해진 로직을 수행하고 다시 wait상태로 돌아가는 프로세스가 일반적입니다.

 

 

다음 포스팅에 나올 "프로듀서 컨슈머 패턴"과 "스레드풀"에서 모든 과정의 예제를 볼 수 있습니다.

 

---