考虑以下测试计划：
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <strings.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutexattr_t mattr;
pthread_t thread1;
pthread_t thread2;
pthread_t thread3;
void mutex_force_unlock(pthread_mutex_t *mutex, pthread_mutexattr_t *mattr)
{
int e;
e = pthread_mutex_destroy(mutex);
printf("mfu: %s\n", strerror(e));
e = pthread_mutex_init(mutex, mattr);
printf("mfu: %s\n", strerror(e));
}
void *thread(void *d)
{
int e;
e = pthread_mutex_trylock(&mutex);
if (e != 0)
{
printf("thr: %s\n", strerror(e));
mutex_force_unlock(&mutex, &mattr);
e = pthread_mutex_unlock(&mutex);
printf("thr: %s\n", strerror(e));
if (e != 0) pthread_exit(NULL);
e = pthread_mutex_lock(&mutex);
printf("thr: %s\n", strerror(e));
}
pthread_exit(NULL);
}
void * thread_deadtest(void *d)
{
int e;
e = pthread_mutex_lock(&mutex);
printf("thr2: %s\n", strerror(e));
e = pthread_mutex_lock(&mutex);
printf("thr2: %s\n", strerror(e));
pthread_exit(NULL);
}
int main(void)
{
/* Setup */
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_ERRORCHECK);
//pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_NORMAL);
pthread_mutex_init(&mutex, &mattr);
/* Test */
pthread_create(&thread1, NULL, &thread, NULL);
pthread_join(thread1, NULL);
if (pthread_kill(thread1, 0) != 0) printf("Thread 1 has died.\n");
pthread_create(&thread2, NULL, &thread, NULL);
pthread_join(thread2, NULL);
pthread_create(&thread3, NULL, &thread_deadtest, NULL);
pthread_join(thread3, NULL);
return(0);
}
现在，当这个程序运行时，我得到以下输出：
Thread 1 has died.
thr: Device busy
mfu: Device busy
mfu: No error: 0
thr: Operation not permitted
thr2: No error: 0
thr2: Resource deadlock avoided
现在我知道之前已经多次询问过了，但有没有办法强行解锁互斥锁？似乎实现只允许锁定它的线程解锁，因为它似乎主动检查，即使使用正常的互斥锁类型。
为什么我这样做？它与编码防弹网络服务器有关，该服务器能够从大多数错误中恢复，包括线程意外终止的错误。此时，我看不到从与锁定它的线程不同的线程解锁互斥锁的方法。所以我看到它的方式是我有几个选择：
答案 0 :(得分：6)
使用robust mutex，如果锁定线程死亡，请使用pthread_mutex_consistent()修复互斥锁。
如果互斥锁是一个处于不一致状态的强健互斥锁，那么 pthread_mutex_consistent（）函数可用于标记状态 受互斥引用的互斥锁保护再次保持一致。
如果固定互斥锁的所有者在持有互斥锁时终止，则 互斥体变得不一致，下一个获取互斥锁的线程 锁定应通过返回值[EOWNERDEAD]通知状态。 在这种情况下，互斥锁直到可以再次正常使用 国家标记一致。
如果获取互斥锁的线程具有返回值 [EOWNERDEAD]在调用前终止 pthread_mutex_consistent（）或pthread_mutex_unlock（），下一个主题 获取互斥锁的应通知有关状态 mutex的返回值[EOWNERDEAD]。
答案 1 :(得分：2)
好吧，你不能用正常的pthread互斥量做你想要的事情，因为正如你所说，你只能从锁定它的线程中解锁互斥锁。
你可以做的是包装锁定/解锁互斥锁，这样你就有了一个pthread取消处理程序，可以在线程终止时解锁互斥锁。给你一个想法：
void cancel_unlock_handler(void *p)
{
pthread_mutex_unlock(p);
}
int my_pthread_mutex_lock(pthread_mutex_t *m)
{
int rc;
pthread_cleanup_push(cancel_unlock_handler, m);
rc = pthread_mutex_lock(&m);
if (rc != 0) {
pthread_cleanup_pop(0);
}
return rc;
}
int my_pthread_mutex_unlock(pthread_mutex_t *m)
{
pthread_cleanup_pop(0);
return pthread_mutex_unlock(&m);
}
现在您需要使用my_pthread_mutex_lock / my_pthread_mutex_unlock而不是pthread锁定/解锁功能。
现在，线程并没有真正终止＆＃34;意外地＆＃34;，要么是调用pthread_exit，要么结束，或者你pthread_kill，在这种情况下上面就足够了（还要注意线程只在某些取消点，因此没有竞争条件，例如在推送清理处理程序和锁定互斥锁之间），但逻辑错误或未定义的行为可能会留下影响整个过程的错误状态，并且您最好不要开始整个过程。
答案 2 :(得分：0)
您可能知道，锁定互斥锁的线程拥有该资源的唯一所有权。所以它拥有解锁它的所有权利。至少到现在为止，没有办法强制一个线程，放弃它的资源，而不必在你的代码中做过一些回合。
然而，这将是我的方法。
拥有一个拥有互斥锁的线程，称为资源线程。确保，此主题收到＆amp;将事件响应给其他工作线程。
当一个工作线程想要进入临界区时，它会向Resource线程注册以代表它锁定一个互斥锁。完成后，工作线程假定，它具有对关键部分的独占访问权限。这个假设是有效的，因为任何其他需要访问临界区的工作线程都必须经历同样的步骤。
现在假设，有另一个线程，谁想要强制前工作线程，解锁，然后他可以进行特殊调用，可能是一个标志或具有高优先级线程来授予访问权限。资源线程在比较请求线程的标志/优先级时，将解锁互斥锁并再次锁定请求线程。
我完全不确定你的用例，但只是我的2美分。如果你喜欢它，不要忘记投票我的答案。
答案 3 :(得分：0)
您可以使用exec family中的函数重新启动崩溃线程的进程以更改进程映像。我假设重新加载进程比重启服务器更快。
答案 4 :(得分：0)
我想出了一种可行的方法来处理这种情况。正如我之前提到的，FreeBSD不支持强大的互斥锁，因此该选项已经完成。还有一个线程锁定了互斥锁，它无法以任何方式解锁。
所以我为解决这个问题所做的就是放弃互斥锁并将其指针放在列表中。由于锁包装器代码使用pthread_mutex_trylock然后在失败时放弃CPU，因此没有线程可以在等待永久锁定的互斥锁时卡住。在强健互斥锁的情况下，锁定互斥锁的线程如果将EOWNERDEAD作为返回码，则可以恢复它。
这里有一些定义的东西：
/* Checks to see if we have access to robust mutexes. */
#ifndef PTHREAD_MUTEX_ROBUST
#define TSRA__ALTERNATE
#define TSRA_MAX_MUTEXABANDON TSRA_MAX_MUTEX * 4
#endif
/* Mutex: Mutex Data Table Datatype */
typedef struct mutex_lock_table_tag__ mutexlock_t;
struct mutex_lock_table_tag__
{
pthread_mutex_t *mutex; /* PThread Mutex */
tsra_daclbk audcallbk; /* Audit Callback Function Pointer */
tsra_daclbk reicallbk; /* Reinit Callback Function Pointer */
int acbkstat; /* Audit Callback Status */
int rcbkstat; /* Reinit Callback Status */
pthread_t owner; /* Owner TID */
#ifdef TSRA__OVERRIDE
tsra_clnup_t *cleanup; /* PThread Cleanup */
#endif
};
/* ******** ******** Global Variables */
pthread_rwlock_t tab_lock; /* RW lock for mutex table */
pthread_mutexattr_t mtx_attrib; /* Mutex attributes */
mutexlock_t *mutex_table; /* Mutex Table */
int tabsizeentry; /* Table Size (Entries) */
int tabsizebyte; /* Table Size (Bytes) */
int initialized = 0; /* Modules Initialized 0=no, 1=yes */
#ifdef TSRA__ALTERNATE
pthread_mutex_t *mutex_abandon[TSRA_MAX_MUTEXABANDON];
pthread_mutex_t mtx_abandon; /* Abandoned Mutex Lock */
int mtx_abandon_count; /* Abandoned Mutex Count */
int mtx_abandon_init = 0; /* Initialization Flag */
#endif
pthread_mutex_t mtx_recover; /* Mutex Recovery Lock */
这里有一些锁恢复代码：
/* Attempts to recover a broken mutex. */
int tsra_mutex_recover(int lockid, pthread_t tid)
{
int result;
/* Check Prerequisites */
if (initialized == 0) return(EDOOFUS);
if (lockid < 0 || lockid >= tabsizeentry) return(EINVAL);
/* Check Mutex Owner */
result = pthread_equal(tid, mutex_table[lockid].owner);
if (result != 0) return(0);
/* Lock Recovery Mutex */
result = pthread_mutex_lock(&mtx_recover);
if (result != 0) return(result);
/* Check Mutex Owner, Again */
result = pthread_equal(tid, mutex_table[lockid].owner);
if (result != 0)
{
pthread_mutex_unlock(&mtx_recover);
return(0);
}
/* Unless the system supports robust mutexes, there is
really no way to recover a mutex that is being held
by a thread that has terminated. At least in FreeBSD,
trying to destory a mutex that is held will result
in EBUSY. Trying to overwrite a held mutex results
in a memory fault and core dump. The only way to
recover is to abandon the mutex and create a new one. */
#ifdef TSRA__ALTERNATE /* Abandon Mutex */
pthread_mutex_t *ptr;
/* Too many abandoned mutexes? */
if (mtx_abandon_count >= TSRA_MAX_MUTEXABANDON)
{
result = TSRA_PROGRAM_ABORT;
goto error_1;
}
/* Get a read lock on the mutex table. */
result = pthread_rwlock_rdlock(&tab_lock);
if (result != 0) goto error_1;
/* Perform associated data audit. */
if (mutex_table[lockid].acbkstat != 0)
{
result = mutex_table[lockid].audcallbk();
if (result != 0)
{
result = TSRA_PROGRAM_ABORT;
goto error_2;
}
}
/* Allocate New Mutex */
ptr = malloc(sizeof(pthread_mutex_t));
if (ptr == NULL)
{
result = errno;
goto error_2;
}
/* Init new mutex and abandon the old one. */
result = pthread_mutex_init(ptr, &mtx_attrib);
if (result != 0) goto error_3;
mutex_abandon[mtx_abandon_count] = mutex_table[lockid].mutex;
mutex_abandon[mtx_abandon_count] = mutex_table[lockid].mutex;
mtx_abandon_count++;
mutex_table[lockid].mutex = ptr;
#else /* Recover Mutex */
/* Try locking the mutex and see what we get. */
result = pthread_mutex_trylock(mutex_table[lockid].mutex);
switch (result)
{
case 0: /* No error, unlock and return */
pthread_unlock_mutex(mutex_table[lockid].mutex);
return(0);
break;
case EBUSY: /* No error, return */
return(0);
break;
case EOWNERDEAD: /* Error, try to recover mutex. */
if (mutex_table[lockid].acbkstat != 0)
{
result = mutex_table[lockid].audcallbk();
if (result != 0)
{
if (mutex_table[lockid].rcbkstat != 0)
{
result = mutex_table[lockid].reicallbk();
if (result != 0)
{
result = TSRA_PROGRAM_ABORT;
goto error_2;
}
}
else
{
result = TSRA_PROGRAM_ABORT;
goto error_2;
}
}
}
else
{
result = TSRA_PROGRAM_ABORT;
goto error_2;
}
break;
case EDEADLK: /* Error, deadlock avoided, abort */
case ENOTRECOVERABLE: /* Error, recovery failed, abort */
/* NOTE: We shouldn't get this, but if we do... */
abort();
break;
default:
/* Ambiguous situation, best to abort. */
abort();
break;
}
pthread_mutex_consistant(mutex_table[lockid].mutex);
pthread_mutex_unlock(mutex_table[lockid].mutex);
#endif
/* Housekeeping */
mutex_table[lockid].owner = pthread_self();
pthread_mutex_unlock(&mtx_recover);
/* Return */
return(0);
/* We only get here on errors. */
#ifdef TSRA__ALTERNATE
error_3:
free(ptr);
error_2:
pthread_rwlock_unlock(&tab_lock);
#else
error_2:
pthread_mutex_unlock(mutex_table[lockid].mutex);
#endif
error_1:
pthread_mutex_unlock(&mtx_recover);
return(result);
}
因为FreeBSD是一个像Linux这样不断发展的操作系统，所以我已经做出规定，允许将来使用强大的互斥体。由于没有健壮的互斥锁，如果支持强大的互斥锁，则无法进行增强的错误检查。
对于健壮的互斥锁，执行增强的错误检查以验证是否需要恢复互斥锁。对于不支持强健互斥锁的系统，我们必须信任调用者以验证需要恢复有问题的互斥锁。此外，还有一些检查以确保只有一个线程执行恢复。阻止互斥锁上的所有其他线程被阻止。我已经考虑过如何向其他线程发出恢复正在进行的信号，因此该例程的方面仍然需要工作。在恢复情况下，我正在考虑比较指针值以查看互斥锁是否被替换。
在这两种情况下，都可以将审计例程设置为回调函数。审计例程的目的是验证和更正受保护数据中的任何数据差异。如果审核无法更正数据，则会调用另一个回调例程 - 数据重新初始化例程。这样做的目的是重新初始化受互斥锁保护的数据。如果失败，则调用abort（）来终止程序执行并删除核心文件以进行调试。
对于废弃的互斥锁情况，指针不会被丢弃，而是放在列表中。如果放弃了太多的互斥锁，则程序将中止。如上所述，在互斥锁例程中，使用pthread_mutex_trylock而不是pthread_mutex_lock。这样，在死互斥锁上不会永久阻塞任何线程。因此，一旦在互斥量表中切换指针指向新的互斥锁，等待互斥锁的所有线程将立即切换到新的互斥锁。
我确信此代码中存在错误/错误，但这是一项正在进行的工作。虽然还没有完成和调试，但我觉得这里有足够的答案来保证回答这个问题。