Pthread:lock Pthread\u MUTEX\u error检查来自非所有者线程的互斥

经典问题； 我没有从代码中找到确认信息； C语言。 我正在Windows上运行以下代码

/* This is an implementation of the threads API of POSIX 1003.1-2001.*/
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

pthread_mutex_t mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
//equivalent to PTHREAD_MUTEX_ERRORCHECK

void* thread_function(void *args)
{
    int rc;
    rc = pthread_mutex_unlock( & mutex );
    printf( "[thread_function] pthread_mutex_unlock rc: %d \n", rc);
    return 0;
}

int main(int argc, char* argv[])
{
    int rc;
    pthread_t id;

    pthread_mutex_lock( &mutex );
    rc =  pthread_create(&id, NULL, thread_function, NULL);
    pthread_join(id, NULL);

    printf( "[main] completed\n");
}

/*这是POSIX 1003.1-2001的线程API的实现*/
#包括
#包括
#包括
pthread\u mutex\u t mutex=pthread\u ERRORCHECK\u mutex\u INITIALIZER\u NP；
//相当于PTHREAD_MUTEX_ERRORCHECK
void*thread_函数（void*args）
{
int rc；
rc=pthread\u mutex\u unlock（&mutex）；
printf（“[thread\u function]pthread\u mutex\u unlock rc:%d\n”，rc）；
返回0；
}
int main（int argc，char*argv[]）
{
int rc；
pthread_t id；
pthread_mutex_lock（&mutex）；
rc=pthread_create（&id，NULL，thread_函数，NULL）；
pthread_join（id，NULL）；
printf（“[main]已完成\n”）；
}

rc=pthread\u mutex\u unlock（&mutex）-返回与预期相同的rc等于1

但是当我将代码更改为
rc=pthread\u mutex\u lock（&mutex）时-未发生该错误。
但在许多Pthread API文档中提到：
如果互斥类型为PTHREAD\u mutex\u ERRORCHECK，则应提供错误检查。如果线程试图重新锁定已锁定的互斥，则应返回一个错误

但它没有为我返回，问题是为什么？
我唯一的猜测是——这取决于我正在使用的PThread实现。
它也可能依赖于操作系统；i、 相同的代码和相同版本的Pthread lib将在Linux上给出不同的结果

谁能澄清一下吗

谢谢
 当一个线程试图锁定被另一个线程锁定的互斥锁时，它会阻止。这当然是全部要点：如果它是一个错误，那将是无用的。错误检查适用于线程可能试图锁定其已锁定的互斥锁的程序。这通常是由逻辑错误导致的，尽管可以用它模拟递归互斥，或者可能使用互斥锁的锁定状态作为某种内存。
通常，当您在同一线程中第二次尝试锁定互斥锁（默认类型）时，您的代码已被阻止。为了防止这种阻塞情况，使用了错误检查互斥

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <errno.h>

#define IN_MAIN     ""
#define IN_THREAD   "\t"
#define START_MAIN  printf(IN_MAIN "\n-- Main Start -- \n");
#define END_MAIN    printf(IN_MAIN "-- Main End -- \n\n");  \
                    exit(EXIT_SUCCESS);

#define ERROR_HANDLER(en, msg) \
                do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void * thread_routine(void * arg)
{
    printf(IN_THREAD "-- Thread Start -- \n");
    int ret;

    pthread_mutex_lock(&mutex);
    printf(IN_THREAD " Thread acquire lock for first time \n");

    ret = pthread_mutex_lock(&mutex);
    if(ret)
    {
        switch(ret)
        {
            case EDEADLK:
                printf(IN_THREAD " A deadlock condition was detected \n");
                break;

            default:
                ERROR_HANDLER(ret, "pthread_mutex_lock");
        }
    }

    sleep(1);
    ret = pthread_mutex_unlock(&mutex);
    printf(IN_THREAD " Thread release lock first time -- %d \n", ret);

    sleep(1);
    ret = pthread_mutex_unlock(&mutex);
    printf(IN_THREAD " Thread release lock second time -- %d \n", ret);
    printf(IN_THREAD "-- Thread End --\n");
    pthread_exit(NULL);
}

int main(int argc, char ** argv)
{
    START_MAIN;
    pthread_t thread_id;
    pthread_mutexattr_t mutex_attr;
    int mutex_type, ret=0;

    pthread_mutexattr_init(&mutex_attr);
    ret = pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_ERRORCHECK);
    if(ret)
        ERROR_HANDLER(ret, "pthread_mutexattr_settype");

    pthread_mutex_init(&mutex, &mutex_attr);
    pthread_create(&thread_id, NULL, thread_routine, NULL);
    pthread_join(thread_id, NULL);
    END_MAIN;
}

然后执行代码。您会注意到，您的代码在第一次打印“线程获取锁”后被阻塞。
Posix规范中的一个错误是“默认”互斥类型的概念，它依赖于实现。“默认”互斥体的语义是任何人都能猜到的。令人困惑当然

我的建议是，如果您关心可移植性，就不要对互斥类型使用“默认值”。
为什么希望
pthread\u mutex\u lock（&mutex）返回错误？这是一个有效的调用，至少在您显示的上下文中是这样。
ret = pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_ERRORCHECK);