在同一线程中多次锁定互斥锁

Question

我正在嵌入式 Linux 操作系统 (uClinux) 上开发一个应用程序，并且我需要能够多次锁定互斥体（通过同一线程）。

我有一个互斥锁和一个互斥锁，定义和初始化如下：

pthread_mutexattr_t waiting_barcode_mutexattr;
pthread_mutex_t waiting_barcode_mutex;

pthread_mutexattr_init(&waiting_barcode_mutexattr);
pthread_mutexattr_settype(&waiting_barcode_mutexattr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&waiting_barcode_mutex, &waiting_barcode_mutexattr);

但是当我尝试两次获取锁时，它会在第二个锁上阻塞：

pthread_mutex_lock(&waiting_barcode_mutex);
pthread_mutex_lock(&waiting_barcode_mutex);

我初始化它是错误的还是有更好的方法来完成相同的任务？

提前致谢。

结论：

• 显然 PTHREAD_MUTEX_RECURSIVE 或 PTHREAD_MUTEX_RECURSIVE_NP 不起作用，所以我无法创建可重入互斥体。
• try_lock 也不好。如果可以的话它会获取锁，如果无法获取锁则返回错误。不幸的是，该错误只是告诉我互斥体已在使用中，并且我无法确定当前线程是否已拥有该锁。
• 如果当前线程拥有锁，pthread_mutex_lock 可能会返回错误，但为此我需要创建一个 PTHREAD_MUTEX_ERRORCHECK 类型的互斥锁，但我也无法创建一个。

Answer 1

这不是你所期望的吗？

第一个调用获取锁，第二个调用将阻塞，直到第一个锁被释放 (pthread_mutex_unlock)。这就是锁的作用。

从文档中可以看出：

“如果互斥体已经被锁定，则调用线程会阻​​塞，直到互斥体变得可用。”

也许您想要pthread_mutex_trylock？除非我们知道您想要实现什么目标，否则很难说。

更正：

我没有看到您正在设置 PTHREAD_MUTEX_RECURSIVE...让我再考虑一下。

思考后：

通过谷歌代码搜索，看起来 PTHREAD_MUTEX_RECURSIVE 并未在所有库中实现。您可以尝试 PTHREAD_MUTEX_RECURSIVE_NP，或者您可能做了一些奇特的事情来解决这个问题。

Answer 2

听起来 pthread 互斥锁不可重入。您可以使用一个标志来解决这个问题，该标志指示您的线程是否已经锁定了互斥体：

bool haveLock = false;// thread variable
pthread_mutex_t waiting_barcode_mutex; // also thread var

mylock()
{
   if( haveLock ) return; // no need to lock twice
   pthread_mutex_lock(&waiting_barcode_mutex);
   haveLock = true;
}

myunlock()
{
   haveLock = false;
   pthread_mutex_unlock(&waiting_barcode_mutex); // or whatever the unlock call is
}

Answer 3

（刚刚意识到我没有将此问题标记为已回答）

取自问题中的结论：

• 显然 PTHREAD_MUTEX_RECURSIVE 或 PTHREAD_MUTEX_RECURSIVE_NP 不起作用，因此我无法创建可重入互斥体。
• try_lock 也不好。如果可以的话它会获取锁，如果无法获取锁则返回错误。不幸的是，该错误只是告诉我互斥体已在使用中，并且我无法确定当前线程是否已拥有该锁。
• 如果当前线程拥有锁，pthread_mutex_lock 可能会返回错误，但为此我需要创建一个 PTHREAD_MUTEX_ERRORCHECK 类型的互斥锁，但我也无法创建一个。

Answer 4

以下是在我的 Dell m6300 上的 UBUNTU 12.04 LTS 上测试的工作代码：

  pthread_mutex_t mutex;
  pthread_mutexattr_t attr;
  int rc = pthread_mutexattr_init(&attr);
    if (rc != 0)
        throw (L"pthread_mutexattr_init returns " + rc);
    rc = pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE_NP);
    if (rc != 0)
        throw (L"pthread_mutexattr_settype returns " + rc);
    rc = pthread_mutex_init (&mutex, &attr);
    if (rc != 0)
        throw (L"pthread_mutex_init returns " + rc);
    rc = pthread_mutexattr_destroy(&attr);
    if (rc != 0)
        throw (L"pthread_mutexattr_destroy returns " + rc);

   //first lock
   rc = pthread_mutex_lock(&mutex);
    if (rc != 0)
        throw (L"pthread_mutex_lock returns " + rc);
   //second lock
   rc = pthread_mutex_lock(&mutex);
    if (rc != 0)
        throw (L"pthread_mutex_lock returns " + rc);

不要忘记在获取互斥体时多次释放它。

Answer 5

下面的代码表明，在pthread上调用unlock之前，锁定临界区两次或三次或N次是没有问题的。您可以在解锁之前连续对同一个线程进行多个锁定，而不必担心，但请注意，这不是一个好的程序员做法。正确的做法是调用lock()，让线程执行临界区，然后调用unlock()，这样其他线程就可以在lock和unlock之间执行同一段代码（称为，临界区）。下面的代码可以防止任何程序员在 pthread 上使用 ATTRIBUTES 时发生意外。

继续阅读！

// Example program using a thread locking multiple times sequentially before unlocking
#include <iostream>

using namespace std;

pthread_mutexattr_t     _attr;
pthread_mutex_t         _mutex;

///
/// Initialize mutex with error return locking mechanism (does not block
/// its own thread if multiple locks occurs.
///
void InitMutex()
{
   // Initialize mutex
   int ret=0;
   ret = pthread_mutexattr_settype(&_attr, PTHREAD_MUTEX_ERRORCHECK_NP);   // PTHREAD_MUTEX_ERRORCHECK_NP avoids double locking on same thread.
   if(ret != 0)
   {
      printf("Mutex attribute not initialized!!\n");
   }
   ret = pthread_mutex_init(&_mutex, &_attr);
   if(ret != 0)
   {
      printf("Mutex not initialized!!\n");
   }
}

///
/// Locks the critical section
///
int lock_me()
{
   return pthread_mutex_lock(&_mutex);
}

///
/// Unlocks the critical section
///
int unlock_me()
{
   return pthread_mutex_unlock(&_mutex);
}

int main()
{
  InitMutex(); // Very important
  int ret = 0;
  
  ret = lock_me();    // return value of 0 - OK
  cout << "First lock returns: "<< ret<< endl;
  ret = lock_me();    // returns a value like 35 - ERROR, but ignores locking again
  cout << "Second lock returns: "<< ret<< endl;
  
  // Do something in this critical section. No other thread can execute this at this time before unlock. Other threads (if any) wait at lock() waiting for main function to unlock() first.

  ret = unlock_me();  // unlocks the critical section. All is OK
  cout << "First unlock returns: "<< ret<< endl;
  ret = unlock_me();  // returns error value of 1, nothing to lock
  cout << "Second unlock returns: "<< ret<< endl;
  ret = unlock_me();  // same as above, nothing to do. Ignore and move on!
  cout << "Third unlock returns: "<< ret << endl;

  // The main() thread will never have a race condition ;) All iz well!!

  pthread_mutexattr_destroy(&_attr);    // clean up the mutex attribute
  pthread_mutex_destroy(&_mutex);       // clean up the mutex itself

}

输出：

第一个锁返回：0

第二次锁定返回：35

首次解锁返回：0

第二次解锁返回：1

第三次解锁返回：1