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

  このアプリケーションにはスレッド A と スレッド B という 2 つのスレッドがあります。 まずスレッド A の実行が開始されてから、 その少し後でスレッド B が開始されます。スレッド A が use_all_buffers() を実行し、 A.mutex が正常にロックされると、 次に B.mutex のロックを試行したときに、 これがスレッド B によって既にロックされているためブロックされます。 スレッド B が functionB を実行しており、かつ、スレッド A がブロックされている間に some_condition が発生すると、スレッド B は、A.mutex の獲得試行もブロックします。それがスレッド A によって既にロックされているためです。この結果、デッドロックが生じます。

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

例えば、1 つのカウンター、X (2 つのスレッド A と B によって増分される) を考えてみましょう。 最初に X が 1 であるとすると、スレッド A と B がカウンターを増分する時までに、X は 3 になっているはずです。両方のスレッドは独立したエンティティーで、これらの間に同期はありません。 C ステートメント X++ は非常に単純でアトミックであるように見えますが、次の疑似アセンブラー・コードに示すように、 生成されたアセンブリー・コードは単純ではない場合があります。

move    X, REG
inc     REG
move    REG, X