Como exatamente eu posso destruir uma variável mutex pthread?

Aqui está o que eu quero fazer. Eu quero ter objetos (variáveis ​​de estrutura) em cache, que são procurados pela chave. Eu quero ter granularidade mínima de bloqueios aqui. Então eu quero ter um bloqueio para cada objeto provavelmente incorporado na estrutura para que eu possa ter bloqueio de nível de objeto.

Agora o problema é como destruir com segurança esses objetos? Parece que o primeiro passo é remover o objeto da tabela de consulta para que o objeto não seja acessível no futuro.

Eu quero libertar o objeto do cache. Agora como destruir / mutex livre corretamente? O documento pthread_mutex_destroy diz que não devemos usar o pthread_mutex_destroy enquanto o mutex estiver bloqueado. Vamos dizer que um thread decide destruir o objeto que precisa para destruir o bloqueio, então ele libera o bloqueio e faz um pthread_mutex_destroy. O que acontece com os outros segmentos aguardando o bloqueio de objetos?

Aqui está o código para simular o acima, notei que usei o sleep (2) para ampliar o efeito da raça.

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

typedef struct exampleObj {
   pthread_mutex_t mutex;
   int key;
   int value1;
   int value2;
}exampleObj;

exampleObj sharedObj = {PTHREAD_MUTEX_INITIALIZER,0,0,0};

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 

exampleObj* Lookup(int key) {
   return &sharedObj;
}

void* thrFunc(void* id) {
   int i = (*((int*)id));
   char errBuf[1024];
   exampleObj * obj = Lookup(0);

   if (pthread_mutex_lock(&obj->mutex)) {
      printf("Locking failed %d \n",i);
      return NULL;
   }
   // Do something
   printf("My id %d will do some work for 2 seconds.\n",i);
   sleep(2);
   pthread_mutex_unlock(&obj->mutex);
   int errNum = pthread_mutex_destroy(&obj->mutex);
   strerror_r(errNum,errBuf,1024);
   printf("Destroying mutex from thread %d : %s\n ",errNum,errBuf);
   return NULL;
}

int main() {
   pthread_t thrds[10];
   int i;
   int args[10];
   char errBuf[1024];
   int errNum = 1;

   for (i=0;i<10;i++){
      args[i] = i;
      pthread_create(&thrds[i],NULL,thrFunc,args+i);
   }

   for (i=0;i<10;i++){
      pthread_join(thrds[i],NULL);
   }
   return 0;
}

Vários segmentos conseguem destruir o mutex. E os tópicos restantes ficam pendurados para sempre. O Gdb mostra que esses segmentos estão aguardando o bloqueio.