第12章——《线程控制》（1）

绝地灬酷狼 2022-04-15 02:43 217阅读 0赞

### 实验环境介绍 ###

*  gcc：4.8.5
 *  glibc：glibc-2.17-222.el7.x86\_64
 *  os：Centos7.4
 *  kernel：3.10.0-693.21.1.el7.x86\_64

### 线程限制 ###

*  使用sysconf函数可以查看一些线程相关的限制

<table> 
 <thead> 
  <tr> 
   <th>限制名称</th> 
   <th align="center">描述</th> 
   <th align="right">name参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DESTRUCTOR_ITERATIONS</td> 
   <td align="center">线程退出时操作系统实现师徒小回县城特定数据的最大次数</td> 
   <td align="right">_SC_THREAD_DESTRUCTOR_ITERATIONS</td> 
  </tr> 
  <tr> 
   <td>KEYS_MAX</td> 
   <td align="center">进程可以创建的键的最大数目</td> 
   <td align="right">_SC_THREAD_KEYS_MAX</td> 
  </tr> 
  <tr> 
   <td>STACK_MIN</td> 
   <td align="center">一个线程的栈可用的最小字节数</td> 
   <td align="right">_SC_THREAD_STACK_MIN</td> 
  </tr> 
  <tr> 
   <td>THREADS_MAX</td> 
   <td align="center">进程可以创建的最大线程数</td> 
   <td align="right">_SC_THREAD_THREADS_MAX</td> 
  </tr> 
 </tbody> 
</table>

#include <unistd.h>
    #include <stdio.h>
    #include <limits.h>
    
    int
    main(void)
    {
        
        printf("DESTRUCTOR_ITERATIONS = %d\n", sysconf(_SC_THREAD_DESTRUCTOR_ITERATIONS));
        printf("KEYS_MAX = %d\n", sysconf(_SC_THREAD_KEYS_MAX));
        printf("STACK_MIN = %d\n", sysconf(_SC_THREAD_STACK_MIN));
        printf("THREADS_MAX = %d\n", sysconf(_SC_THREAD_THREADS_MAX));
    
        return 0;
    }
    
    result:
    DESTRUCTOR_ITERATIONS = 4
    KEYS_MAX = 1024
    STACK_MIN = 16384
    THREADS_MAX = -1

*  线程配置限制的实例

<table> 
 <thead> 
  <tr> 
   <th>限制名称</th> 
   <th align="center">freebsd 8.0</th> 
   <th align="center">Linux 3.2.0</th> 
   <th align="center">maxOS X 10.6.8</th> 
   <th align="center">Solaris 10</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DESTRUCTOR_ITERATIONS</td> 
   <td align="center">4</td> 
   <td align="center">4</td> 
   <td align="center">4</td> 
   <td align="center">没有确定的限制</td> 
  </tr> 
  <tr> 
   <td>KEYS_MAX</td> 
   <td align="center">256</td> 
   <td align="center">1024</td> 
   <td align="center">512</td> 
   <td align="center">没有确定的限制</td> 
  </tr> 
  <tr> 
   <td>STACK_MIN</td> 
   <td align="center">2048</td> 
   <td align="center">16384</td> 
   <td align="center">8192</td> 
   <td align="center">8192</td> 
  </tr> 
  <tr> 
   <td>THREADS_MAX</td> 
   <td align="center">没有确定的限制</td> 
   <td align="center">没有确定的限制</td> 
   <td align="center">没有确定的限制</td> 
   <td align="center">没有确定的限制</td> 
  </tr> 
 </tbody> 
</table>

### 线程属性 ###

*  pthread接口允许我们通过设置每个对象关联的不同属性来细调线程和同步对象的行为。
    
     *  如互斥量和互斥量属性，线程与线程属性
     *  有对应的初始化函数和销毁函数以及获取属性值的函数
     *  每个属性也有一个属性设置函数
     *  pthread\_attr\_init的实现是动态分配属性对象，所以使用pthread\_attr\_destroy可以释放该内存空间

#include <pthread.h>
    int pthread_attr_init(pthread_attr_t *attr);
    int pthread_attr_destroy(pthread_attr_t *attr);

*  posix.1线程属性
    
     *  如果对线程终止状态不感兴趣的话，可以使用pthread\_detach函数让操作系统在线程退出时收回它所占用的资源

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th align="center">描述</th> 
   <th align="center">freebsd 8.0</th> 
   <th align="center">Linux 3.2.0</th> 
   <th align="center">maxOS X 10.6.8</th> 
   <th align="center">Solaris 10</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>detachstate</td> 
   <td align="center">线程的分离状态属性</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
  </tr> 
  <tr> 
   <td>guardsize</td> 
   <td align="center">线程栈末尾的警戒缓冲区大小（字节数）</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
  </tr> 
  <tr> 
   <td>stackaddr</td> 
   <td align="center">线程栈的最低地址</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
  </tr> 
  <tr> 
   <td>stacksize</td> 
   <td align="center">线程栈的最小长度（字节数）</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
   <td align="center">支持</td> 
  </tr> 
 </tbody> 
</table>

*  设置线程分离状态
    
     *  如果想让线程一开始就处于分离状态，就将该属性设置为PTHREAD\_CREATE\_DETACHED，否则正常启动就是PTHREAD\_CREATE\_JOINABLE

#include <pthread.h>
    int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
    int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);
    
    
    #include <unistd.h>
    #include <stdio.h>
    #include <limits.h>
    #include <pthread.h>
    
    int makethread(void *(*fn)(void *), void *arg);
    void * f(void *arg);
    
    pthread_t g_tid = 0;
    int
    main(void)
    {
        
        int ret = makethread(f, NULL);
        if (ret) {
        
            printf("make thread error\n");
            exit(1);
        }
    
        sleep(3);
        pthread_join(g_tid, NULL);
        printf("join child_thread over\n");
        return 0;
    }
    
    int makethread(void *(*fn)(void *), void *arg)
    {
        
        int err;
        pthread_t tid;
        pthread_attr_t attr;
    
        err = pthread_attr_init(&attr);
        if (0 != err)
            return (err);
        err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
        if (0 == err)
            err = pthread_create(&tid, &attr, fn, arg);
        pthread_attr_destroy(&attr); // 这里应该检查线程属性销毁是否正常，如果不正常应该取消这个线程，否则会有少量的内存泄露
    
        g_tid = tid;
        return (err);
    }
    
    void *f(void *arg)
    {
        
        printf("thread_comming!!!\n");
        while (1)
            sleep(1);
    
        return (NULL);
    }
    
    result:
    [root@localhost 新建文件夹]# ./main
    thread_comming!!!
    join child_thread over

*  获取、设置线程栈属性
    
     *  对于posix标准的操作系统来说，并不一定要支持线程栈属性。但是尊徐single UNIX specification中xsi选项的E系统来说，需要支持线程栈属性。
     *  下面的代码将直接设置线程栈的大小，如果线程栈太小，会直接段错误

//先来讲说线程内存相关的东西，主要有下面几条：
    //进程中的所有的线程共享相同的地址空间。
    //任何声明为static/extern的变量或者堆变量可以被进程内所有的线程读写。
    //一个线程真正拥有的唯一私有储存是处理器寄存器。
    //线程栈可以通过暴露栈地址的方式与其它线程进行共享。
    // 有大数据量处理的应用中，有时我们有必要在栈空间分配一个大的内存块或者要分配很多小的内存块，但是线程的栈空间的最大值在线程创建的时候就已经定下来了，如果栈的大小超过个了个值，系统将访问未授权的内存块，毫无疑问，再来的肯定是一个段错误。可是没办法，你还是不得不分配这些内存，于是你开会为分配一个整数值而动用malloc这种超级耗时的操作。当然，在你的需求可以评估的情况下，你的需求还是可以通过修改线程的栈空间的大小来改变的。
    //
    //下面的我们用pthread_attr_getstacksize和pthread_attr_setstacksize的方法来查看和设置线程的栈空间。
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <limits.h>
    #include <pthread.h>
    #include <error.h>
    #include <string.h>
    
    //#ifndef _POSIX_THREAD_ATTR_STACKSIZE
    //define _POSIX_THREAD_ATTR_STACKSIZE
    //线程体，在栈中分配一个大小为8M的空间，并进行读写
    void * thread_stack(void *arg)
    {
        
        printf("The thread is here\n");
        //栈大小为8M,如果直接分配8M的栈空间，会出现段错误 ，因为栈中还有其它的
        //变量要放署
        char p[1024 * 1024 * 7];
        int i = 1024 * 1024 * 7;
        while (i--)
            p[i] = 3;
    
        printf("Get 7M Memory\n");
    
        //分配更多的内存(如果分配1024*1020*512的话就会出现段错误）
        char p2[1024 * 1020 + 256];
        memset(p2, 0, sizeof(char) * (1024 * 1020 + 256));
    
        printf("Get More Memory!!!\n");
        return NULL ;
    }
    
    int main(int argc, char ** argv)
    {
        
        pthread_t thread_id;
        pthread_attr_t thread_attr;
        size_t stack_size;
        int err;
    
        err = pthread_attr_init(&thread_attr);
        if (err != 0)
            perror("Create attr");
    
        //设置分离状态
        err = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
        if (err != 0)
            perror("Create attr");
    
        //通常出现的问题之一，下面的宏没有定义
        //#ifdef _POSIX_THREAD_ATTR_STACKSIZE
        //得到当前的线程栈大小
        err = pthread_attr_getstacksize(&thread_attr, &stack_size);
        if (err != 0)
            perror("Create attr");
    
        printf("Default stack size is %u; minimum is %u\n", stack_size,
                PTHREAD_STACK_MIN);
    
        //设置当前的线程的大小为16MB
        err = pthread_attr_setstacksize(&thread_attr, PTHREAD_STACK_MIN * 1024);
        if (err != 0)
            perror("Create attr");
    
        //得到当前的线程栈的大小
        err = pthread_attr_getstacksize(&thread_attr, &stack_size);
        if (err != 0)
            perror("Get stack size");
    
        printf("Default stack size is %u; minimum is %u\n", stack_size,
                PTHREAD_STACK_MIN);
        //#endif
        int i = 5;
        //分配5个具有上面的属性的线程体的属性的线程体
        while (i--) {
        
            err = pthread_create(&thread_id, &thread_attr, thread_stack, NULL );
            if (err != 0)
                perror("Create thread");
        }
    
        getchar();
        printf("Main exiting\n");
    
        pthread_exit(NULL );
        return 0;
    }
    
    result:
    [root@localhost 新建文件夹]# ./main
    Default stack size is 16785408; minimum is 16384
    Default stack size is 16777216; minimum is 16384
    The thread is here
    The thread is here
    The thread is here
    The thread is here
    The thread is here
    Get 7M Memory
    Get More Memory!!!
    Get 7M Memory
    Get More Memory!!!
    Get 7M Memory
    Get More Memory!!!
    Get 7M Memory
    Get More Memory!!!
    Get 7M Memory
    Get More Memory!!!
    
    Main exiting

*  线程属性guardsize控制着线程栈末尾之后用以避免栈溢出的扩展内存的大小。默认值得看具体实现，但通常是系统页的大小。如果设置为0，则不提供境界缓冲区。如果我们修改了线程属性stackaddr，系统会认为是我们自己管理栈，进而使警戒缓冲区机制无效，等同于guardsize线程属性设置为0
 *  如果guardsize被修改，操作系统会把它取为页大小的证书倍。如果线程的栈指针溢出到了警戒区域，应用程序就可能通过信号接收到出错信息

#include <pthread.h>
    
    int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize);
    int pthread_attr_getguardsize(pthread_attr_t *attr, size_t *guardsize);
    
    Compile and link with -pthread.
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <limits.h>
    #include <pthread.h>
    #include <error.h>
    #include <string.h>
    
    int main(int argc, char ** argv)
    {
        
        pthread_t thread_id;
        pthread_attr_t thread_attr;
        size_t stack_size;
        int err;
    
        err = pthread_attr_init(&thread_attr);
        if (err != 0)
            perror("Create attr");
    
        size_t guard_size = 0;
        err = pthread_attr_getguardsize(&thread_attr, &guard_size);
        if (0 != err) {
        
            printf("pthread_attr_getguardsize error\n");
            exit(1);
        }
    
        printf("pthread_attr_getguardsize: %d\n", guard_size);
    
        guard_size = 7999;
        err = pthread_attr_setguardsize(&thread_attr, guard_size);
        if (0 != err) {
        
            printf("pthread_attr_setguardsize6 error\n");
            exit(1);
        }
    
        err = pthread_attr_getguardsize(&thread_attr, &guard_size);
        if (0 != err) {
        
            printf("pthread_attr_getguardsize error\n");
            exit(1);
        }
    
        printf("after pthread_attr_setguardsize: %d\n", guard_size);
    
        return 0;
    }
    
    result：
    [root@localhost 新建文件夹]# ./main
    pthread_attr_getguardsize: 4096
    after pthread_attr_setguardsize: 7999

### 同步属性 ###

##### 互斥量属性 #####

*  互斥量有3个属性指的注意：进程共享属性、健壮属性和类型属性
    
     *  PTHREAD\_PROCESS\_SHARED、PTHREAD\_PROCESS\_PRIVATE
 *  进程共享属性测试代码：

#include <stdlib.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <string.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <sys/wait.h>
    
    
    #include <pthread.h>
    
    #ifndef _POSIX_THREAD_PROCESS_SHARED
    #error This system does not support process shared mutex
    #endif
    
    int shared_mem_id;
    int *shared_mem_ptr;
    
    pthread_mutexattr_t mutex_shared_attr;
    pthread_mutex_t *mptr;
    
    int
    main(void)
    {
        
        pid_t child_pid;
        int status, rtn;
    
        /* initialize shared memory segment */
        if ((shared_mem_id = shmget(IPC_PRIVATE, 1*sizeof(pthread_mutex_t), 0660)) < 0)
            perror("shmget"), exit(1) ;
    
        if ((shared_mem_ptr = (int *)shmat(shared_mem_id, (void *)0, 0)) == NULL)
            perror("shmat"), exit(1);
    
        mptr = (pthread_mutex_t *)shared_mem_ptr;
    
        if (( rtn = pthread_mutexattr_init(&mutex_shared_attr)) != 0)
            fprintf(stderr,"pthreas_mutexattr_init: %s",strerror(rtn)),exit(1);
    
        if (( rtn = pthread_mutexattr_setpshared(&mutex_shared_attr,PTHREAD_PROCESS_SHARED)) != 0)
            fprintf(stderr,"pthread_mutexattr_setpshared %s",strerror(rtn)),exit(1);
    
        if (( rtn = pthread_mutex_init(mptr, &mutex_shared_attr)) != 0)
            fprintf(stderr,"pthread_mutex_init %s",strerror(rtn)), exit(1);
    
    
        if ((child_pid = fork()) == 0) {
        
            /* first child */
            if ((rtn = pthread_mutex_lock(mptr)) != 0)
                fprintf(stderr,"child:pthread_mutex_lock %s",strerror(rtn)),exit(1);
            sleep(1);
    
            if ((rtn = pthread_mutex_unlock(mptr)) != 0)
                fprintf(stderr,"child:pthread_unmutex_lock %s",strerror(rtn)),exit(1);
            printf("child exit\n");
            exit(0);
        } else {
        
            /* parent */
            sleep(1);
            if ((rtn = pthread_mutex_lock(mptr)) != 0)
                fprintf(stderr,"parent:pthread_mutex_lock %d",strerror(rtn)),exit(1);
            if ((rtn = pthread_mutex_unlock(mptr)) != 0)
                fprintf(stderr,"child:pthread_unmutex_lock %d",strerror(rtn)),exit(1);
            wait(&status);
            printf("recycle child\n");
        }
        return 0;
    }
    
    result:
    [root@localhost 新建文件夹]# ./main
    child exit
    recycle child

*  互斥量健壮属性（与多个进程间共享的互斥量有关）：进程终止时，互斥量处于锁定状态，恢复起来很困难。
    
     *  PTHREAD\_MUTEX\_STALLED：当健壮属性取值为这个值的时，意味着持有互斥量的进程终止时不采取特别的动作，这样使用互斥量后的行为是未定义的
     *  PTHREAD\_MUTEX\_ROBUST：这个值会导致调用pthread\_mutex\_lock获取锁的进程a的线程当锁被另外一个进程b的线程占有，并且进程b线程终止时并没有对该锁进行解锁，此时a进程的线程会阻塞，从pthread\_mutex\_lock返回的值为EOWNERRERAD而不是0，进程a的线程通过这个特殊值获知。如果进程a的线程想继续获取锁，得使用pthread\_mutex\_consistent

// example1:
    #include <stdlib.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <string.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <sys/wait.h>
    #include <errno.h>
    
    #include <pthread.h>
    
    #ifndef _POSIX_THREAD_PROCESS_SHARED
    #error This system does not support process shared mutex
    #endif
    
    int shared_mem_id;
    int *shared_mem_ptr;
    
    pthread_mutexattr_t mutex_shared_attr;
    pthread_mutex_t *mptr;
    
    int
    main(void)
    {
        
        pid_t child_pid;
        int status, rtn;
    
        /* initialize shared memory segment */
        if ((shared_mem_id = shmget(IPC_PRIVATE, 1*sizeof(pthread_mutex_t), 0660)) < 0)
            perror("shmget"), exit(1) ;
    
        if ((shared_mem_ptr = (int *)shmat(shared_mem_id, (void *)0, 0)) == NULL)
            perror("shmat"), exit(1);
    
        mptr = (pthread_mutex_t *)shared_mem_ptr;
    
        if (( rtn = pthread_mutexattr_init(&mutex_shared_attr)) != 0)
            fprintf(stderr,"pthreas_mutexattr_init: %s",strerror(rtn)),exit(1);
    
        if (( rtn = pthread_mutexattr_setpshared(&mutex_shared_attr,PTHREAD_PROCESS_SHARED)) != 0)
            fprintf(stderr,"pthread_mutexattr_setpshared %s",strerror(rtn)),exit(1);
    
        if (( rtn = pthread_mutexattr_setrobust(&mutex_shared_attr, PTHREAD_MUTEX_ROBUST)) != 0)
            fprintf(stderr,"pthread_mutexattr_setrobust %s",strerror(rtn)),exit(1);
    
        if (( rtn = pthread_mutex_init(mptr, &mutex_shared_attr)) != 0)
            fprintf(stderr,"pthread_mutex_init %s",strerror(rtn)), exit(1);
    
    
        if ((child_pid = fork()) == 0) {
        
            /* first child */
            if ((rtn = pthread_mutex_lock(mptr)) != 0)
                fprintf(stderr,"child:pthread_mutex_lock %s",strerror(rtn)),exit(1);
            sleep(1);
    
            // if ((rtn = pthread_mutex_unlock(mptr)) != 0)
            // fprintf(stderr,"child:pthread_unmutex_lock %s",strerror(rtn)),exit(1);
            printf("child exit\n");
            exit(0);
        } else {
        
            /* parent */
            sleep(1);
            if ((rtn = pthread_mutex_lock(mptr)) != 0)
                fprintf(stderr,"parent:pthread_mutex_lock %d, %s",strerror(rtn), (EOWNERDEAD == rtn) ? "EOWNERDEAD" : "UNKNOWN"),exit(1);
    
            if ((rtn = pthread_mutex_unlock(mptr)) != 0)
                fprintf(stderr,"child:pthread_unmutex_lock %d",strerror(rtn)),exit(1);
            wait(&status);
            printf("recycle child\n");
        }
        return 0;
    }
    
    result:
    [root@localhost 新建文件夹]# ./main
    child exit
    parent:pthread_mutex_lock -853442408, EOWNERDEAD[root@localhost 新建文件夹]# 
    
    // example2：
    #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 (0)
    
    static pthread_mutex_t mtx;
    
    static void *
    original_owner_thread(void *ptr)
    {
        
       printf("[original owner] Setting lock...\n");
       pthread_mutex_lock(&mtx);
       printf("[original owner] Locked. Now exiting without unlocking.\n");
       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(2);
    
        /* "original_owner_thread" should have exited by now */
    
        printf("[main thread] Attempting to lock the robust mutex.\n");
        s = pthread_mutex_lock(&mtx);
        if (s == EOWNERDEAD) {
        
            printf("[main thread] pthread_mutex_lock() returned EOWNERDEAD\n");
            printf("[main thread] Now make the mutex consistent\n");
            s = pthread_mutex_consistent(&mtx);
            if (s != 0)
                handle_error_en(s, "pthread_mutex_consistent");
            printf("[main thread] Mutex is now consistent; unlocking\n");
            s = pthread_mutex_unlock(&mtx);
            if (s != 0)
                handle_error_en(s, "pthread_mutex_unlock");
    
            exit(EXIT_SUCCESS);
        } else if (s == 0) {
        
            printf("[main thread] pthread_mutex_lock() unexpectedly succeeded\n");
            exit(EXIT_FAILURE);
        } else {
        
            printf("[main thread] pthread_mutex_lock() unexpectedly failed\n");
            handle_error_en(s, "pthread_mutex_lock");
        }
    }
    
    result:
    [root@localhost 新建文件夹]# ./main
    [original owner] Setting lock...
    [original owner] Locked. Now exiting without unlocking.
    [main thread] Attempting to lock the robust mutex.
    [main thread] pthread_mutex_lock() returned EOWNERDEAD
    [main thread] Now make the mutex consistent
    [main thread] Mutex is now consistent; unlocking

*  类型属性：控制着互斥量的锁定类型
    
     *  PTHREAD\_MUTEX\_NORMAL：标准互斥量类型，不做任何特殊的错误检查或死锁检测
     *  PTHREAD\_MUTEX\_ERRORCHECK：此互斥量类型提供错误检查
     *  PTHREAD\_MUTEX\_RECURSIVE：此互斥量类型允许同一个线程在互斥量解锁之前进行多次加锁，加锁几次，就得释放几次。（不适合用于条件变量）
     *  PTHREAD\_MUTEX\_DEFAULT：此互斥量类型可以提供默认特性和行为。（具体看操作系统是把这种类型指定为上述三种中哪一种）
     *  行为如下：

<table> 
 <thead> 
  <tr> 
   <th>互斥量类型</th> 
   <th align="center">没有解锁时重新加锁？</th> 
   <th align="center">不占用时解锁？</th> 
   <th align="right">在已解锁时解锁？</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PTHREAD_MUTEX_NORMAL</td> 
   <td align="center">死锁</td> 
   <td align="center">未定义</td> 
   <td align="right">未定义</td> 
  </tr> 
  <tr> 
   <td>PTHREAD_MUTEX_ERRORCHECK</td> 
   <td align="center">返回错误</td> 
   <td align="center">返回错误</td> 
   <td align="right">返回错误</td> 
  </tr> 
  <tr> 
   <td>PTHREAD_MUTEX_RECURSIVE</td> 
   <td align="center">允许</td> 
   <td align="center">返回错误</td> 
   <td align="right">返回错误</td> 
  </tr> 
  <tr> 
   <td>PTHREAD_MUTEX_DEFAULT</td> 
   <td align="center">未定义</td> 
   <td align="center">未定义</td> 
   <td align="right">未定义</td> 
  </tr> 
 </tbody> 
</table>

##### 读写锁属性 #####

*  只有一种属性：进程共享属性

##### 条件变量属性 #####

*  两个属性：进程共享属性和时钟属性
    
     *  进程共享属性
     *  时钟属性：控制计算pthread\_cond\_timedwait函数超时参数tsptr时采用的是哪个时钟（CLOCK\_REALTIME、CLOCK\_MONOTONIC）

##### 屏障属性 #####

*  目前只有进程共享属性