"mutex"和"lock"有什么区别？

Question

我对锁和互斥之间的区别感到非常困惑。在Boost文档中，它说

锁定类型

• 类模板lock_guard
• 类模板unique_lock
• 类模板shared_lock
• 类模板upgrade_lock
• 类模板upgrade_to_unique_lock
• 互斥特定类scoped_try_lock

互斥类型

• 类互斥
• Typedef try_mutex
• 类timed_mutex
• 类递归_mutex
• Typedef recursive_try_tmutex
• 类recursive_timed_mutex
• 类shared_mutex

在另一篇文章中，我看到了这样的函数，

boost::shared_mutex _access;
void reader()
{
  boost::shared_lock< boost::shared_mutex > lock(_access);
  // do work here, without anyone having exclusive access
}    
void conditional_writer()
{
  boost::upgrade_lock< boost::shared_mutex > lock(_access);
  // do work here, without anyone having exclusive access
  if (something) {
    boost::upgrade_to_unique_lock< boost::shared_mutex > uniqueLock(lock);
    // do work here, but now you have exclusive access
  }
  // do more work here, without anyone having exclusive access
}

更新的问题

1. 有人能澄清一下"互斥"one_answers"锁"吗
2. 是否需要为shared_mutex创建共享锁？如果我为shared_mutex创建unique_lock，会发生什么
3. 或者，如果我为mutex创建一个shared_lock，这是否意味着mutex可以不能在多个线程之间共享

Answer 1

mutex是一个同步对象。在代码段的开头获取互斥锁，并在末尾释放它，以确保没有其他线程同时访问相同的数据。互斥锁的生存期通常与它所保护的数据的生存期相等，并且一个互斥锁由多个线程访问。

锁对象是封装该锁的对象。当对象被构造时，它获取互斥锁上的锁。当它被破坏时，锁被释放。通常，每次访问共享数据时都会创建一个新的锁定对象。

Answer 2

互斥是一个可以锁定的对象。锁是指保持锁定。要创建一个锁，您需要向它传递一个互斥锁。

Answer 3

锁可以提供互斥，但不能提供条件同步。与信号量不同，锁有一个所有者，所有权起着重要作用锁定行为中的角色

示例-

class lockableObject { public void F() {
mutex.lock(); ...; mutex.unlock();
}
public void G() {
mutex.lock(); ...; F(); ...; mutex.unlock();
}
private mutexLock mutex; }
// method G() calls method F()

类lockableObject中的锁互斥用于将方法F（）和G（）转换为关键部分。因此，一次只能在lockableObject的方法内部执行一个线程。当线程调用方法G（）时，互斥锁被锁定。当方法G（）调用方法F（）时，互斥锁.lock（）在F（）中执行，但调用线程没有被阻塞，因为它已经拥有互斥锁。如果互斥是一个二进制信号量而不是锁，那么当互斥时，从G（）到F（）的调用将阻塞调用线程。在F（）中执行了P（）。（回想一下，二进制信号量上的P（）和V（）运算必须交替完成。）这将创建死锁，因为没有其他线程能够在F（）或G（）内执行。

锁和二进制信号量之间存在以下差异：1对于二进制信号量，如果对P（）进行两次调用而没有对V（）进行任何干预调用，则第二次调用将阻塞。但是，拥有锁并再次请求所有权的线程不会被阻止。（注意锁并不总是递归的，所以在使用锁之前请查看文档。）2连续调用lock（）和unlock（）的所有者必须是同一个线程。但是对P（）和V（）的连续调用可以由不同的线程进行。