如何使用 pthread_mutex_destroy 在 Linux 中安全正确地销毁互斥锁​​?

我了解了 APUE 3rd，11.6.1 Mutexes，本章有一个关于锁定和解锁互斥锁的例子:

I read about APUE 3rd, 11.6.1 Mutexes, there is an example about lock and unlock a mutex in this chapter:

struct foo {
    int             f_count;
    pthread_mutex_t f_lock;
    int             f_id;
    /* ... more stuff here ... */
};

struct foo *
foo_alloc(int id) /* allocate the object */
{
    struct foo *fp;

    if ((fp = malloc(sizeof(struct foo))) != NULL) {
        fp->f_count = 1;
        fp->f_id = id;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
            free(fp);
            return(NULL);
        }
        /* ... continue initialization ... */
    }
    return(fp);
}

void
foo_hold(struct foo *fp) /* add a reference to the object */
{
    pthread_mutex_lock(&fp->f_lock);
    fp->f_count++;
    pthread_mutex_unlock(&fp->f_lock);
}

void
foo_rele(struct foo *fp) /* release a reference to the object */
{
    pthread_mutex_lock(&fp->f_lock);
    if (--fp->f_count == 0) { /* last reference */
        pthread_mutex_unlock(&fp->f_lock);
        pthread_mutex_destroy(&fp->f_lock);
        free(fp);
    } else {
        pthread_mutex_unlock(&fp->f_lock);
    }
}

在foo_rele中，pthread_mutex_unlock和pthread_mutex_destroy之间存在竞争条件:B线程可以调用线程中pthread_mutex_unlock和pthread_mutex_destroy之间的>pthread_mutex_lock，这将导致未定义的行为(尝试销毁锁定的互斥锁会导致未定义行为").

In foo_rele, there is a race condition between pthread_mutex_unlock and pthread_mutex_destroy: B thread can call pthread_mutex_lock between pthread_mutex_unlock and pthread_mutex_destroy in A thread which will cause undefined behavior ("Attempting to destroy a locked mutex results in undefined behavior").

我说得对吗?如果我是对的，那么，如何使其正常工作或如何使用 pthread_mutex_destroy 安全正确地销毁 Linux 中的互斥锁?

Am I right? If I'm right, then, how to make it work right or how to safely and correctly destroy a mutex in Linux using pthread_mutex_destroy?