뮤텍스(mutex) 사용

다음 예제에서는 뮤텍스 속성 오브젝트가 디폴트 값으로 작성 및 초기화되어 사용된 다음 마지막으로 제거됩니다.

pthread_mutexattr_t attributes;
                /* the attributes object is created */
...
if (!pthread_mutexattr_init(&attributes)) {
                /* the attributes object is initialized */
        ...
                /* using the attributes object */
        ...
        pthread_mutexattr_destroy(&attributes);
                /* the attributes object is destroyed */
}

뮤텍스는 pthread_mutex_init 서브루틴을 호출하여 작성됩니다. 사용자가 뮤텍스 속성 오브젝트를 지정할 수 있습니다. 널(null) 포인터를 지정할 경우 뮤텍스는 디폴트 속성을 가집니다. 따라서,

pthread_mutex_t mutex;
pthread_mutexattr_t attr;
...
pthread_mutexattr_init(&attr);
pthread_mutex_init(&mutex, &attr);
pthread_mutexattr_destroy(&attr);

코드 프래그먼트는 다음과 같습니다.

pthread_mutex_t mutex;
...
pthread_mutex_init(&mutex, NULL);

뮤텍스가 더 이상 필요하지 않으면 pthread_mutex_destroy 서브루틴을 호출하여 이를 삭제하십시오. 이 서브루틴은 pthread_mutex_init 서브루틴에서 할당된 스토리지를 교정할 수 있습니다. 뮤텍스를 영구 삭제한 후 같은 pthread_mutex_t 변수를 다시 사용하여 다른 뮤텍스를 작성할 수 있습니다. 예를 들어, 다음 코드 프래그먼트는 실제로 사용되지는 않지만 유효합니다.

pthread_mutex_t mutex;
...
for (i = 0; i < 10; i++) {
 
        /* creates a mutex */
        pthread_mutex_init(&mutex, NULL);
 
        /* uses the mutex */
 
        /* destroys the mutex */
        pthread_mutex_destroy(&mutex);
}

뮤텍스의 유형은 뮤텍스가 작업을 시작할 때의 작동 방법을 판별합니다. 다음과 같은 뮤텍스 유형이 존재합니다.

PTHREAD_MUTEX_DEFAULT 또는 PTHREAD_MUTEX_NORMAL

동일한 pthread가 먼저 잠금을 해제하지 않고 pthread_mutex_lock 서브루틴을 사용하여 두 번째로 잠금을 시도할 경우 교착 상태가 됩니다. 이것이 디폴트 유형입니다.

PTHREAD_MUTEX_ERRORCHECK

동일한 스레드가 먼저 뮤텍스를 잠금 해제하지 않고 두 번 이상 동일한 뮤텍스의 잠금을 시도할 경우 0이 아닌 값을 리턴하여 교착 상태를 예방합니다.

PTHREAD_MUTEX_RECURSIVE

pthread_mutex_lock 서브루틴에서 0이 아닌 리턴 값을 가져오거나 교착 상태가 되지 않고도 같은 pthread가 pthread_mutex_lock을 사용하여 뮤텍스를 반복적으로 잠글 수 있습니다. 다른 pthread가 사용할 수 있도록 뮤텍스를 잠금 해제하려면 pthread_mutex_lock 서브루틴을 호출한 횟수만큼 같은 pthread가 pthread_mutex_unlock 서브루틴을 호출해야 합니다.

다음은 순환적 뮤텍스 유형을 작성 및 사용하는 예제입니다.

pthread_mutexattr_t    attr;
pthread_mutex_t         mutex;

pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&mutex, &attr);

struct {
        int a;
        int b;
        int c;
} A;

f()
{
        pthread_mutex_lock(&mutex);
        A.a++;
        g();
        A.c = 0;
        pthread_mutex_unlock(&mutex);
}

g()
{
        pthread_mutex_lock(&mutex);
        A.b += A.a;
        pthread_mutex_unlock(&mutex);
}

뮤텍스는 동시 액세스로부터 데이터를 보호하는 데 사용될 수 있습니다. 예를 들어, 데이터베이스 애플리케이션은 여러 스레드를 작성하여 여러 요청을 동시에 처리할 수 있습니다. 데이터베이스 자체는 db_mutex라는 뮤텍스를 사용하여 보호합니다. 예를 들면, 다음과 같습니다.

/* the initial thread */
pthread_mutex_t mutex;
int i;
...
pthread_mutex_init(&mutex, NULL);    /* creates the mutex      */
for (i = 0; i < num_req; i++)        /* loop to create threads */
        pthread_create(th + i, NULL, rtn, &mutex);
...                                  /* waits end of session   */
pthread_mutex_destroy(&mutex);       /* destroys the mutex     */
...

/* the request handling thread */
...                                  /* waits for a request  */
pthread_mutex_lock(&db_mutex);       /* locks the database   */
...                                  /* handles the request  */
pthread_mutex_unlock(&db_mutex);     /* unlocks the database */
...

멀티스레드 애플리케이션이 교착 상태가 될 수 있는 방법에는 여러 가지가 있습니다. 예를 들면 다음과 같습니다.

• 디폴트 유형 PTHREAD_MUTEX_NORMAL로 작성된 뮤텍스는 교착 상태를 발생하지 않고는 같은 pthread에 의해 다시 잠길 수 없습니다.
• 역순으로 뮤텍스를 잠그면 애플리케이션이 교착 상태가 될 수 있습니다. 예를 들어, 다음 코드 프래그먼트는 스레드 A와 B 사이에서 교착 상태를 만들 수 있습니다.

  /* Thread A */
  pthread_mutex_lock(&mutex1);
  pthread_mutex_lock(&mutex2);
  
  /* Thread B */
  pthread_mutex_lock(&mutex2);
  pthread_mutex_lock(&mutex1);

• 애플리케이션은 자원 교착 상태에서 교착 상태가 됩니다. 예를 들면, 다음과 같습니다.

  struct {
                  pthread_mutex_t mutex;
                  char *buf;
          } A;
  
  struct {
                  pthread_mutex_t mutex;
                  char *buf;
          } B;
  
  struct {
                  pthread_mutex_t mutex;
                  char *buf;
          } C;
  
  use_all_buffers()
  {
          pthread_mutex_lock(&A.mutex);
          /* use buffer A */
  
          pthread_mutex_lock(&B.mutex);
          /* use buffers B */
  
          pthread_mutex_lock(&C.mutex);
          /* use buffer C */
  
          /* All done */
          pthread_mutex_unlock(&C.mutex);
          pthread_mutex_unlock(&B.mutex);
          pthread_mutex_unlock(&A.mutex);
  }
  
  use_buffer_a()
  {
          pthread_mutex_lock(&A.mutex);
          /* use buffer A */
          pthread_mutex_unlock(&A.mutex);
  }
  
  functionB()
  {
          pthread_mutex_lock(&B.mutex);
          /* use buffer B */
          if (..some condition)
          { 
            use_buffer_a();
          }
          pthread_mutex_unlock(&B.mutex);
  }
  
  /* Thread A */
  use_all_buffers();
  
  /* Thread B */
  functionB();

  이 애플리케이션에는 두 개의 스레드 ( thread A 및 thread B) 가 있습니다. Thread B 가 먼저 실행되기 시작하면 thread A 이 곧 시작됩니다. thread A 가 use_all_buffers () 를 실행하고 A.mutex를 성공적으로 잠금하면 thread B 이 (가) 이미 잠갔기 때문에 B.mutex을 (를) 잠그려고 할 때 블록이 블록됩니다. thread B 가 functionB 를 실행하고 thread A 가 차단되는 동안 some_condition 가 실행되는 동안 thread B 도 thread A에 의해 이미 잠겨 있는 A.mutex를 획득하려고 시도하는 것을 차단합니다. 이로 인해 교착 상태가 됩니다.

  이 교착 상태에 대한 해결책은 자원을 사용하기 전에 각 스레드에서 필요한 자원 잠금을 모두 확보하는 것입니다. 잠금을 확보할 수 없으면 잠금을 해제한 후 다시 시작해야 합니다.

예를 들어, 두 개의 스레드인 A및 B에 의해 증가되는 단일 카운터 X를 고려하십시오. X 가 원래 1이면, 스레드 A및 B가 카운터를 증가시키면 X 는 3이어야 합니다. 두 스레드는 독립 엔터티이며 서로에 대해 동기화되지 않습니다. C문이긴 하지만X++다음 의사 어셈블러 코드에 표시된 대로 생성된 어셈블리 코드가 아닐 수 있습니다.

move    X, REG
inc     REG
move    REG, X