互斥锁的robust属性的介绍和使用

一个具体的场景：在多线程中，当一个线程获得锁之后异常退出后，应该怎么处理？

方案一 使用锁的robust特性

简单地讲，就是当拥有这个锁的线程挂了后，下一个尝试去获得锁的线程会得到EOWNWERDEAD的返回值，新的拥有者应该再去调用pthread_mutex_consistent_np（）来保持锁状态的一致性，并解锁。

直接上代码看示例：

 /*================================================================
  *   Copyright (C) 2019 Ltd. All rights reserved.
  *
  *   File Name ：robust_mutex.c
  *   Author    ：Hamilton
  *   Date      ：2019-07-30
  *   Descriptor：
  *
  ================================================================*/
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 
 #define handle_error_en(en, msg) \
     do { errno = en; perror(msg); exit(EXIT_FAILURE); } while ()
 
 static pthread_mutex_t mtx;
 
 static void *original_owner_thread(void *ptr)
 {
     printf("\n[original owner] Setting lock...\n");
     pthread_mutex_lock(&mtx);
     printf("[original owner] Locked. Now exiting without unlocking.\n");
     pthread_exit(NULL);
 }
 static void *bad_thread(void *ptr)
 {
     printf("\n[bad owner] Setting lock...\n");
     pthread_mutex_lock(&mtx);
     printf("[bad owner] Locked. Now exiting without unlocking.\n");
     pthread_exit(NULL);
 }
 static void *second_thread(void *ptr)
 {
     int i = ;
 
     while (i--)
     {
         int s = pthread_mutex_lock(&mtx);
 
         if (s == EOWNERDEAD)
         {
             printf("\n[second thread] pthread_mutex_lock() returned EOWNERDEAD\n");
 
             printf("[second thread] Now make the mutex consistent\n");
             s = pthread_mutex_consistent(&mtx);
             if (s != )
                 handle_error_en(s, "pthread_mutex_consistent");
 
             printf("[second thread] Mutex is now consistent; unlocking\n");
             s = pthread_mutex_unlock(&mtx);
             if (s != )
                 handle_error_en(s, "pthread_mutex_unlock");
 
         }
         else if (s < )
         {
             printf("\n[second thread] pthread_mutex_lock() unexpectedly failed\n");
             handle_error_en(s, "pthread_mutex_lock");
         }
         else
         {
             printf("\n[second thread] pthread_mutex_lock success.\n");
             printf("do somthing.... \n");
             s = pthread_mutex_unlock(&mtx);
             if (s != )
                 handle_error_en(s, "pthread_mutex_unlock");
         }
         sleep();
     }
 
     pthread_exit(NULL);
 }
 
 int main(int argc, char *argv[])
 {
     pthread_t thr;
     pthread_mutexattr_t attr;
     int s;
 
     pthread_mutexattr_init(&attr);
     /* initialize the attributes object */
     pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);
     /* set robustness */
 
     pthread_mutex_init(&mtx, &attr);   /* initialize the mutex */
 
     pthread_create(&thr, NULL, original_owner_thread, NULL);
 
     sleep();
     pthread_create(&thr, NULL, second_thread, NULL);
     sleep();
     pthread_create(&thr, NULL, bad_thread, NULL);
 
     /* "original_owner_thread" should have exited by now */
 
     int i = ;
     while(i--)
     {
         s = pthread_mutex_lock(&mtx);
 
         if (s == EOWNERDEAD)
         {
             printf("\n[main thread] pthread_mutex_lock() returned EOWNERDEAD\n");
 
             printf("[main thread] Now make the mutex consistent\n");
             s = pthread_mutex_consistent(&mtx);
             if (s != )
                 handle_error_en(s, "pthread_mutex_consistent");
 
             printf("[main thread] Mutex is now consistent; unlocking\n");
             s = pthread_mutex_unlock(&mtx);
             if (s != )
                 handle_error_en(s, "pthread_mutex_unlock");
 
         }
         else if (s < )
         {
             printf("\n[main thread] pthread_mutex_lock() unexpectedly failed\n");
             handle_error_en(s, "pthread_mutex_lock");
         }
         else
         {
             printf("\n[main thread] pthread_mutex_lock success.\n");
             printf("do somthing.... \n");
             s = pthread_mutex_unlock(&mtx);
             if (s != )
                 handle_error_en(s, "pthread_mutex_unlock");
         }
 
         sleep();
     }
     exit(EXIT_SUCCESS);
 }

示例中总共包含四个线程，original_owner_thread() 和 bad_thread() 两个线程获得锁后立马退出不释放，其它两个线程main thread 及 second_thread() 轮流抢占锁，并对锁的异常进行恢复处理，看下打印结果：

是不是很简单，通过设置robust特性，并在每次获取锁时判断锁的异常状态，便能很好的处理锁异常退出的情况。

关于锁的robust特性及consistent设定，可参考以下更多资料：

https://docs.oracle.com/cd/E19455-01/806-5257/6je9h032m/index.html

http://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_mutex_consistent.html

本文示例改编自：http://manpages.ubuntu.com/manpages/bionic/man3/pthread_mutexattr_setrobust.3.html

后记：再看看进程间有没有类似的机制，但是google并没有找到相关介绍，便想看看pthreas_mutex_lock这套机制在process下工作是否正常，先看示例代码：

 /*================================================================
  *   Copyright (C) 2019 Ltd. All rights reserved.
  *
  *   File Name ：robust_mutex.c
  *   Author    ：Hamilton
  *   Date      ：2019-07-30
  *   Descriptor：
  *
  ================================================================*/
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 #include <sys/mman.h>
 #include <fcntl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
 #define SHM_NAME    "fasdfasfasfas"
 
 #define handle_error_en(en, msg) \
     do { errno = en; perror(msg); exit(EXIT_FAILURE); } while ()
 
 static pthread_mutex_t *mtx;
 static int fd_shm;
 
 void shm_mutex_init(pthread_mutex_t  **mutex)
 {
     pthread_mutexattr_t attr;
 
     pthread_mutexattr_init(&attr);
     /* initialize the attributes object */
     pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);
     /* set robustness */
 
     // Get shared memory
     if ((fd_shm = shm_open (SHM_NAME, O_RDWR | O_CREAT, )) == -)
         perror ("shm_open");
 
     if (ftruncate (fd_shm, sizeof (pthread_mutex_t)) == -)
         perror ("ftruncate");
 
     if ((*mutex = mmap (NULL, sizeof (pthread_mutex_t), PROT_READ | PROT_WRITE, MAP_SHARED,
                     fd_shm, )) == MAP_FAILED)
         perror ("mmap");
 
     pthread_mutex_init(*mutex, &attr);   /* initialize the mutex */
 }
 int main(int argc, char *argv[])
 {
     int s;
 
     shm_mutex_init(&mtx);
 
     if ((s = fork()) < )
     {
         perror("fork.");
     }
     else if (s == ) // child
     {
         sleep();
             printf("\n[bad owner] Setting lock...\n");
             pthread_mutex_lock(mtx);
             printf("[bad owner] Locked. Now exiting without unlocking.\n");
     }
     else
     {
         int i = ;
         while(i--)
         {
             s = pthread_mutex_lock(mtx);
 
             if (s == EOWNERDEAD)
             {
                 printf("\n[main thread] pthread_mutex_lock() returned EOWNERDEAD\n");
 
                 printf("[main thread] Now make the mutex consistent\n");
                 s = pthread_mutex_consistent(mtx);
                 if (s != )
                     handle_error_en(s, "pthread_mutex_consistent");
 
                 printf("[main thread] Mutex is now consistent; unlocking\n");
                 s = pthread_mutex_unlock(mtx);
                 if (s != )
                     handle_error_en(s, "pthread_mutex_unlock");
 
             }
             else if (s < )
             {
                 printf("\n[main thread] pthread_mutex_lock() unexpectedly failed\n");
                 handle_error_en(s, "pthread_mutex_lock");
             }
             else
             {
                 printf("\n[main thread] pthread_mutex_lock success.\n");
                 printf("do somthing.... \n");
                 s = pthread_mutex_unlock(mtx);
                 if (s != )
                     handle_error_en(s, "pthread_mutex_unlock");
             }
 
             sleep();
         }
     }
     exit(EXIT_SUCCESS);
 }

编译执行下看看：

进程间通信的锁得放在共享内存中，编译运行OK，也能正常工作。