blocks|key|3740188|text|我敢打赌，它在这里失败了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3740189|while+(!condition_)+{
++++pthread_cond_wait(&cv_,+&mutex_);
}|code-block|syntax|javascript|3740190|假设条件为false。您进入while循环，在第一次运行中一切正常，即解锁互斥锁并等待决策变量。会不会发生条件变量改变而布尔条件不变的情况？在这种情况下，您将使用未初始化的互斥锁进入pthread_cond_wait，并且可能会发生未定义的行为...我想如果您也显示bar()方法会有所帮助。|3740191|另一种猜测是线程优先级。也许可以插入一个yield，让线程有更好的切换机会。|3740192|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

My bet is that it fails in here: 

<pre><code>while (!condition_) {
 pthread_cond_wait(&amp;cv_, &amp;mutex_);
}
</code></pre>

Let's assume, condition is false. You enter the while loop and in the first run everything goes fine, i.e. you unlock the mutex and wait on the decision variable. Can it happen that the condition variable changes but not the boolean condition ? In that case you would enter pthread_cond_wait with an uninitialized mutex and undefined behaviour can occur...
I guess it would help if you would show the bar() method as well. 

Another guess would be thread priorities. Maybe insert a yield to give the threads a better chance to switch.

blocks|key|3740218|text|我将查看您的构造函数和bar()函数，如果您无意中复制了一个有问题的对象，也可能会这样做。我已经复制了您提供的类，以及下面我对其馀部分如何操作的假设。下面的程序每秒都会被唤醒，并向线程发出信号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3740219|#include+<pthread.h>
#include+<iostream>

class+Foo+{
public:
++Foo()+{
++++condition_+=+false;
++++pthread_mutex_init(&mutex_,+NULL);
++++pthread_cond_init(&cv_,+NULL);
++++pthread_create(&monitor_,+NULL,
+++++++++++startFunc,+this);
++}

++void+bar()+{
++++pthread_mutex_lock(&mutex_);
++++std::cout+<<+"BAR"+<<+std::endl;
++++condition_+=+true;
++++pthread_cond_signal(&cv_);
++++pthread_mutex_unlock(&mutex_);
++}

private:
++Foo(const+Foo&)+{};
++Foo&+operator=(const+Foo&)+{+return+*this;+};

++static+void*+startFunc(void*+r)+{
++++Foo*+f+=+static_cast<Foo*>(r);
++++f->monitor();
++++return+NULL;
++}

++void+monitor()+{
++++pthread_mutex_lock(&mutex_);
++++while+(true)+{
++++++while+(!condition_)+{
++++pthread_cond_wait(&cv_,+&mutex_);
++++++}
++++++//+do+something
++++++//+and+then+setting+condition_+to+false
++++++std::cout+<<+"FOO"+<<+std::endl;
++++++condition_+=+false;
++++}
++++pthread_mutex_unlock(&mutex_);

++}

++bool+condition_;
++pthread_t+monitor_;
++pthread_mutex_t+mutex_;
++pthread_cond_t+cv_;
};


int+main()+{
++struct+timespec+tm+=+{1,0};
++Foo+f;

++while(true)+{
++++f.bar();
++++nanosleep(&tm,+NULL);
++}

}|code-block|syntax|javascript|3740220|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I would look at your constructor and the bar() function, and possibly if you've accidentally made a copy of the object in question. I've copied the classes you provided, and my assumptions on how the rest of it operates below. The program below wakes up every second, and signals the thread.

<pre><code>#include &lt;pthread.h&gt;
#include &lt;iostream&gt;

class Foo {
public:
 Foo() {
 condition_ = false;
 pthread_mutex_init(&amp;mutex_, NULL);
 pthread_cond_init(&amp;cv_, NULL);
 pthread_create(&amp;monitor_, NULL,
 startFunc, this);
 }

 void bar() {
 pthread_mutex_lock(&amp;mutex_);
 std::cout &lt;&lt; "BAR" &lt;&lt; std::endl;
 condition_ = true;
 pthread_cond_signal(&amp;cv_);
 pthread_mutex_unlock(&amp;mutex_);
 }

private:
 Foo(const Foo&amp;) {};
 Foo&amp; operator=(const Foo&amp;) { return *this; };

 static void* startFunc(void* r) {
 Foo* f = static_cast&lt;Foo*&gt;(r);
 f-&gt;monitor();
 return NULL;
 }

 void monitor() {
 pthread_mutex_lock(&amp;mutex_);
 while (true) {
 while (!condition_) {
 pthread_cond_wait(&amp;cv_, &amp;mutex_);
 }
 // do something
 // and then setting condition_ to false
 std::cout &lt;&lt; "FOO" &lt;&lt; std::endl;
 condition_ = false;
 }
 pthread_mutex_unlock(&amp;mutex_);

 }

 bool condition_;
 pthread_t monitor_;
 pthread_mutex_t mutex_;
 pthread_cond_t cv_;
};


int main() {
 struct timespec tm = {1,0};
 Foo f;

 while(true) {
 f.bar();
 nanosleep(&amp;tm, NULL);
 }

}
</code></pre>

blocks|key|3454897|text|如果您再次遇到这种情况，我遇到了一个非常类似的情况，我遇到了一个死锁，我期望cond_wait释放互斥锁，以便其他线程可以锁定互斥锁。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3454898|我的问题是我已经将互斥锁设置为递归的(使用settype->PTHREAD_+recursive+_NP)，并且在cond_wait调用之前错误地锁定了互斥锁两次。由于cond_wait只解锁了它一次，互斥锁仍然是锁定的。显而易见的解决方法是只锁定它一次。此外，作为一个教训，我不会使用递归互斥设置，除非我真的需要这样做。|3454899|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In case you run into this again, I ran into a very similar situation where I was running into a deadlock, where I was expecting cond_wait to release the mutex so that other threads could lock the mutex.

My issue was that I had set the mutex as recursive (with settype->PTHREAD_MUTEX_RECURSIVE_NP) and was mistakenly locking the mutex twice before the cond_wait call. Since the cond_wait only unlocked it once, the mutex was still locked. The obvious fix was to only lock it once. Also, as a lesson learned, I won't be using the recursive mutex setting unless I really need to.

My program is seemingly having a deadlock problem.

Basically I have a class that looks like this:

<pre><code>class Foo {
public:
 Foo();

 void bar();

private:
 void monitor();

 bool condition_;
 pthread_t monitor_;
 pthread_mutex_t mutex_;
 pthread_cond_t cv_;
};
</code></pre>

In <code>Foo</code>'s constructor, I invoke <code>monitor()</code> in a separate thread (namely <code>monitor_</code>). This <code>monitor()</code> function does the following:

<pre><code>pthread_mutex_lock(&amp;mutex_);
while (true) {
 while (!condition_) {
 pthread_cond_wait(&amp;cv_, &amp;mutex_);
 }
 // do something
 // and then setting condition_ to false
 condition_ = false;
}
pthread_mutex_unlock(&amp;mutex_);
</code></pre>

The <code>bar()</code> function is the only public interface (excluding ctor and dtor) of <code>Foo</code>. It also needs to acquire the mutex in its execution. My symptom is that <code>bar()</code> can never acquire <code>mutex_</code>. It looks like <code>pthread_cond_wait()</code> does not release the mutex as it is supposed to do. And if I disable the monitor thread (thus no racing condition), then <code>bar()</code> can run to its completion without any problem.

Of course, the above code is a stripped-down version of my real code. Actually I think there is no logic error in this code and I'm using pthread correctly. I'm suspecting if there are any other causes for this deadlock situation. Can anyone give a clue on this? Thanks!

Possible causes of pthread_cond_wait()'s not releasing a mutex?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我的程序似乎有一个死锁问题。基本上，我有一个如下所示的类：class Foo {public:  Foo();  void bar();private:  void monitor();  bool condition_;  pthread_t monitor_;  pthread_mutex_t mutex_;  p...

问Pthread_cond_wait()没有释放互斥锁的可能原因？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Pthread_cond_wait()没有释放互斥锁的可能原因？EN