使用互斥对象

在以下示例中，创建互斥属性对象并将其初始化为缺省值，然后使用该对象，最终删除它：

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

如果相同的线程试图不先解锁互斥对象而再一次锁定同一个互斥对象，可通过返回非零值避免死锁。

pthread_mutex_recursive

允许同一个 pthread 使用 pthread_mutex_lock 子例程递归锁定互斥对象，而不造成死锁，或者从 pthread_mutex_lock 获取非零返回值。 同一个 pthread 调用 pthread_mutex_unlock 子例程的次数必须与其调用 pthread_mutex_lock 子例程的次数相同，以解锁互斥对象供其他 pthread 使用。

下面是创建并使用递归互斥类型的示例：

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，那么当它尝试锁定 B.mutex时，它将阻塞，因为 thread B 已锁定它。 当 thread B 执行 functionB 并在 thread A 被阻止时发生 some_condition 时， thread B 现在还将阻止尝试获取 A.mutex(已被 thread A锁定)。 这将导致死锁。

  解决此死锁的方法是，每一个线程必须在使用资源之前获取所需的所有资源锁。 如果它无法获取锁，那么必须释放它们然后重新开始。

例如，考虑由两个线程 A 和 B 递增的单个计数器 X。 如果 X 最初是 1 ，那么按线程 A 和 B 递增计数器的时间， X 应该是 3。 这两个线程都是独立的实体，它们之间没有同步。 虽然 C 语句X++看起来简单到原子，生成的组装代码可能不是，如以下伪汇编程序代码所示:

move    X, REG
inc     REG
move    REG, X