mutex の使用

次の例では、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 */
}

mutex は、 pthread_mutex_init サブルーチンを呼び出すことによって作成されます。 ユーザーは mutex 属性オブジェクトを指定することができます。 NULL ポインターを指定した場合、mutex はデフォルト属性を持ちます。 次のようなコード・フラグメントがあるとします。

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);

mutex が不要になった後で、 pthread_mutex_destroy サブルーチンを呼び出して破棄してください。 このサブルーチンを使用して、 pthread_mutex_init サブルーチンによって割り当てられたストレージを再利用することができます。 mutex を破棄した後、同じ pthread_mutex_t 変数を別の mutex の作成に再使用することができます。 例えば、あまり実用的ではありませんが、次のコード・フラグメントが有効です。

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);
}

mutex のタイプにより、 操作時に mutex がどのように振る舞うかが決定されます。 次のタイプの mutex があります。

PTHREAD_MUTEX_DEFAULT または PTHREAD_MUTEX_NORMAL

この場合、 最初にアンロックを行わずに 同じ pthread が pthread_mutex_lock サブルーチンを使用して 2 回目のロックを行おうとすると、デッドロックが発生します。 これがデフォルトのタイプです。

PTHREAD_MUTEX_ERRORCHECK

最初に mutex のアンロックを行わずに同じ thread が同じ mutex のロックを複数回試行した場合に、 ゼロ以外の値が戻されることにより、 デッドロックが回避されます。

PTHREAD_MUTEX_RECURSIVE

pthread_mutex_lock サブルーチンを使用して、 同じ pthread が mutex のロックを再帰的に行えるため、 デッドロックが発生したり、 pthread_mutex_lock からゼロ以外の値が戻されることはありません。 この同じ pthread は、pthread_mutex_lock サブルーチンに行ったのと同じ回数、 pthread_mutex_unlock サブルーチンを呼び出して、 他の pthread が使用できるように mutex をアンロックしなければなりません。

以下に、 再帰的な mutex タイプの作成および使用の例を示します。

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);
}

mutex は、データを並行アクセスから保護するために使用することができます。 例えば、 データベース・アプリケーションが、複数の要求を同時に扱うための複数のスレッドを作成する場合があります。 データベース自体は、db_mutex と呼ばれる 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 で作成された mutex は、 同じ pthread によって再ロックすると必ずデッドロックが発生します。
• mutex を逆の順序でロックした場合、 アプリケーションでデッドロックが発生する可能性があります。 例えば、次のコード・フラグメントは、 スレッド 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の 2 つのスレッドがあります。 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の獲得の試行もブロックするようになります。 この結果、デッドロックが発生します。

  このデッドロックを解決するには、 リソースを使用する前に、 必要とするすべてのリソース・ロックを各スレッドで獲得してください。 ロックを獲得できなければ、それらを解除して再度開始する必要があります。

例えば、 1 つのカウンター Xが、 A と B の 2 つのスレッドによって増分されるとします。 X が元々 1の場合、スレッド A と B がカウンターを増分するときには、 X は 3でなければなりません。 どちらのスレッドも独立エンティティーであり、相互に同期化されません。 ただし、C ステートメントは、X++以下の疑似アセンブラー・コードに示すように、アトミックであるにもかかわらず、生成されたアセンブリー・コードがそうでない可能性があります。

move    X, REG
inc     REG
move    REG, X