C++ 等待互斥锁时的进程

在等待互斥锁锁定时，是否有办法执行代码段

对我的应用程序性能的唯一真正内部影响是数据库交互，有时我需要严格的同步，因为数据库交互可能会导致争用，所以我想用等待锁从数据库获取数据的时间

例如，我希望代码看起来像，在pseudo中：

boost::unique_lock<boost::mutex> process_lock(process_mutex, work_while_contending);
//code to execute while lock contending
process_lock.proceed_after_lock();

boost:：唯一锁定进程锁定（进程锁定互斥，在竞争时工作）；
//锁竞争时要执行的代码
进程锁定。在锁定（）后继续；

我已经检查了boost，虽然

未来

和

递归

听起来我的意图是可以实现的，但我不知道如何实现我的意图

---

如何实现我的意图？

这其实很容易。您可以为锁调用另一个构造函数，该构造函数请求延迟互斥锁上的实际锁。然后可以调用try_lock（）方法尝试获取锁，这是一个非阻塞调用，返回一个布尔值，指示是否成功获取了锁。在您的情况下，您可以这样使用此方法：

boost::unique_lock<boost::mutex> process_lock(process_mutex, boost::defer_lock_t);
while(!process_lock.try_lock())
{
    ...do some work
}

boost:：unique\u lock process\u lock（process\u mutex，boost:：defer\u lock\t）；
而（！process_lock.try_lock（））
{
…做些工作
}

一旦锁成功获得互斥锁，它将负责像正常情况一样再次解锁互斥锁，因此在异常处理方面没有引入任何问题

编辑：刚刚对这个问题有了另一个想法。如果每次锁尝试失败时都要运行一个任务，那么我给出的答案非常好，但是如果第一次尝试时无法获得锁，则只需要执行一次您想要执行的工作，那么以下方法更合适：

boost::unique_lock<boost::mutex> process_lock(process_mutex, boost::try_to_lock_t);
if(!process_lock.owns_lock())
{
    ...do some work
    process_lock.lock();
}

boost:：unique\u lock进程\u lock（进程\u互斥，boost:：try\u to\u lock\t）；
如果（！process_lock.owns_lock（））
{
…做些工作
进程_lock.lock（）；
}

这其实很简单。您可以为锁调用另一个构造函数，该构造函数请求延迟互斥锁上的实际锁。然后可以调用try_lock（）方法尝试获取锁，这是一个非阻塞调用，返回一个布尔值，指示是否成功获取了锁。在您的情况下，您可以这样使用此方法：

boost::unique_lock<boost::mutex> process_lock(process_mutex, boost::defer_lock_t);
while(!process_lock.try_lock())
{
    ...do some work
}

boost:：unique\u lock process\u lock（process\u mutex，boost:：defer\u lock\t）；
而（！process_lock.try_lock（））
{
…做些工作
}

一旦锁成功获得互斥锁，它将负责像正常情况一样再次解锁互斥锁，因此在异常处理方面没有引入任何问题

编辑：刚刚对这个问题有了另一个想法。如果每次锁尝试失败时都要运行一个任务，那么我给出的答案非常好，但是如果第一次尝试时无法获得锁，则只需要执行一次您想要执行的工作，那么以下方法更合适：

boost::unique_lock<boost::mutex> process_lock(process_mutex, boost::try_to_lock_t);
if(!process_lock.owns_lock())
{
    ...do some work
    process_lock.lock();
}

boost:：unique\u lock进程\u lock（进程\u互斥，boost:：try\u to\u lock\t）；
如果（！process_lock.owns_lock（））
{
…做些工作
进程_lock.lock（）；
}

在大多数情况下，您并不想这样做。如果你真的想这样做，你可能想使用期货，比如：

auto f = std::async(std::launch::async, [&]() {
   // do work in another thread here.
});

boost::unique_lock<boost::mutex> process_lock(process_mutex);
auto result = f.get();

// proceed here the work is done and you have the lock

auto f=std:：async（std:：launch:：async，[&]（）{
//在这里做另一个线程的工作。
});
boost：：唯一的锁进程锁（进程锁互斥）；
自动结果=f.get（）；
//继续，工作完成了，你有锁了

。。。这允许您在原始线程等待互斥时在另一个线程中工作。一旦完成这两项工作并获取互斥锁，线程将继续。如果工作在获取互斥体之前完成，那么工作线程将离开，原始线程将空闲等待互斥体

下面是您不想这样做的原因：如果您在工作完成之前获取互斥体，那么其他线程将无法获取互斥体，程序将在等待“后台”工作完成时暂停

---

一种可能的解决方案是使用具有非阻塞

try\u lock

的忙等待循环。这里潜在的问题是线程没有等待互斥体，因此不能保证线程会得到互斥体。如果有很多争论，其他人都在积极等待，那么你永远也得不到它。如果您等待它，那么操作系统通常会保证某种顺序，以便您最终获得它。如果您不等待，则无法做出保证。

在大多数情况下，您并不真正希望这样做。如果你真的想这样做，你可能想使用期货，比如：

auto f = std::async(std::launch::async, [&]() {
   // do work in another thread here.
});

boost::unique_lock<boost::mutex> process_lock(process_mutex);
auto result = f.get();

// proceed here the work is done and you have the lock

auto f=std:：async（std:：launch:：async，[&]（）{
//在这里做另一个线程的工作。
});
boost：：唯一的锁进程锁（进程锁互斥）；
自动结果=f.get（）；
//继续，工作完成了，你有锁了

。。。这允许您在原始线程等待互斥时在另一个线程中工作。一旦完成这两项工作并获取互斥锁，线程将继续。如果工作在获取互斥体之前完成，那么工作线程将离开，原始线程将空闲等待互斥体

下面是您不想这样做的原因：如果您在工作完成之前获取互斥体，那么其他线程将无法获取互斥体，程序将在等待“后台”工作完成时暂停

一种可能的解决方案是使用具有非阻塞

try\u lock

的忙等待循环。这里潜在的问题是线程没有等待互斥体，因此不能保证线程会得到互斥体。如果有很多争论，其他人都在积极等待，那么你永远也得不到它。如果你等着它，那么泰迪