C++ 带互斥锁的条件变量演示程序挂起
想法： 当线程A需要检查条件变量C++ 带互斥锁的条件变量演示程序挂起,c++,pthreads,mutex,C++,Pthreads,Mutex,想法： 当线程A需要检查条件变量x的状态时，它将首先持有互斥锁，然后检查变量的状态，如果发现无效，它将开始等待 线程B不会中断，因为线程A当前具有互斥锁。一旦线程A等待，它就会释放互斥锁。 线程B然后可以获取互斥锁并执行它想做的任何事情 #include <stdlib.h> #include <pthread.h> #include <iostream> pthread_mutex_t mutexLock = PTHREAD_MUTEX_INITIALI
x线程B然后可以获取互斥锁并执行它想做的任何事情
#include <stdlib.h>
#include <pthread.h>
#include <iostream>
pthread_mutex_t mutexLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void * functionOfThreadA (void * ptr);
void * functionOfThreadB (void * ptr);
int x = 0;
int main ()
{
pthread_t threadA;
pthread_t threadB;
char *messageA = (char *) "Thread A"; // TODO
char *messageB = (char *) "Thread B";
int returnValueA;
int returnValueB;
returnValueA = pthread_create (&threadA, NULL, functionOfThreadA, (void*) messageA);
returnValueB = pthread_create (&threadB, NULL, functionOfThreadB, (void*) messageB);
pthread_join (threadA, NULL);
pthread_join (threadB, NULL);
exit (0);
}
void * functionOfThreadA (void * ptr)
{
char * message;
message = (char *) ptr;
std :: cout << "\nA: " << message << "\n";
while (1)
{
pthread_mutex_lock (&mutexLock);
if (x == 10)
{
std :: cout << "\nx == 10 : true, functionOfThread A: " << message << "\n";
}
else
{
std :: cout << "\nThread waits." << "\n";
pthread_cond_wait (&cond, &mutexLock);
std :: cout << "\nA:++ " << message << "\n";
}
pthread_mutex_unlock (&mutexLock);
return 0;
}
}
void * functionOfThreadB (void * ptr)
{
while (1)
{
char * message;
message = (char *) ptr;
pthread_mutex_lock (&mutexLock);
x = x + 1;
if (x == 10)
{
std :: cout << "\nfunctionOfThread B: " << message << "\n";
pthread_cond_signal (&cond);
}
else
{
std :: cout << "\nB: Not signaled yet. Value of x: " << x << "\n";
}
pthread_mutex_unlock (&mutexLock);
return 0;
}
}
我需要在这里更正什么以及为什么？线程在这里等待
pthread\u cond\u wait（&cond，&mutexLock）独立，因为没有其他线程向它发送信号。线程B对锁和条件变量不执行任何操作，问题已被发现
发出信号后，我需要退出循环。但在此之前，我还需要解锁互斥锁。下面程序中的******突出显示了threadb#include <stdlib.h>
#include <pthread.h>
#include <iostream>
pthread_mutex_t mutexLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void * functionOfThreadA (void * ptr);
void * functionOfThreadB (void * ptr);
int x = 0;
int main ()
{
pthread_t threadA;
pthread_t threadB;
char *messageA = (char *) "Thread A";
char *messageB = (char *) "Thread B";
int returnValueA;
int returnValueB;
returnValueA = pthread_create (&threadA, NULL, functionOfThreadA, (void*) messageA);
returnValueB = pthread_create (&threadB, NULL, functionOfThreadB, (void*) messageB);
pthread_join (threadA, NULL);
pthread_join (threadB, NULL);
exit (0);
}
void * functionOfThreadA (void * ptr)
{
char * message;
message = (char *) ptr;
while (1)
{
pthread_mutex_lock (&mutexLock);
if (x == 1000)
{
std :: cout << "\nA: x is now 1000. Waiting period over."<< "\n";
return 0;
}
else
{
std :: cout << "\nNow, thread A will wait for value of `x` to reach 1000" << "\n";
pthread_cond_wait (&cond, &mutexLock);
}
pthread_mutex_unlock (&mutexLock);
}
}
void * functionOfThreadB (void * ptr)
{
while (1)
{
char * message;
message = (char *) ptr;
pthread_mutex_lock (&mutexLock);
x = x + 1;
if (x == 1000)
{
std :: cout << "\nB: Signaled. Value of x: " << x << "\n";
pthread_cond_signal (&cond);
*************pthread_mutex_unlock (&mutexLock);*************
*************return 0;*************
}
else
{
std :: cout << "\nB: Not signaled yet. Value of x: " << x << "\n";
}
pthread_mutex_unlock (&mutexLock);
}
}
#包括
#包括
#包括
pthread\u mutex\u t mutexLock=pthread\u mutex\u初始值设定项；
pthread_cond_t cond=pthread_cond_初始值设定项；
无效*ptr（无效*ptr）；
无效*ptr（无效*ptr）；
int x=0；
int main（）
{
pthread_t threadA；
pthread_t threadB；
char*messageA=（char*）“线程A”；
char*messageB=（char*）“线程B”；
int returnValueA；
int返回值b；
returnValueA=pthread_create（&threadA，NULL，functionOfThreadA，（void*）messageA）；
returnValueB=pthread_create（&threadB，NULL，functionOfThreadB，（void*）messageB）；
pthread_join（threadA，NULL）；
pthread_join（threadB，NULL）；
出口（0）；
}
void*fthrea（void*ptr）
{
字符*消息；
消息=（字符*）ptr；
而(1)
{
pthread_mutex_lock（&mutexLock）；
如果（x==1000）
{
std：：cout-Oh，我没有发送信号吗？：doh：这就是问题所在？将x=x+1；更改为x=10；这满足给定的示例代码，因为每个线程只循环一次。对于一般情况，让我想想。我正在为您提供一个工作解决方案。请检查它。如果它解决了您的问题，请让我知道。每个线程只循环一次。
但我有writ在那里有一个无限的while循环。那么为什么呢？因为在循环的末尾有返回0
，所以线程A中不需要无限循环：你只需要pthread\u mutex\u lock（&mutexLock）；while（x！=1000）pthread\u cond\u wait（&cond，&mutexLock）；phtread\u mutex\u unlock（&mutexLock）；
#include <stdlib.h>
#include <pthread.h>
#include <iostream>
pthread_mutex_t mutexLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void * functionOfThreadA (void * ptr);
void * functionOfThreadB (void * ptr);
int x = 0;
int main ()
{
pthread_t threadA;
pthread_t threadB;
char *messageA = (char *) "Thread A";
char *messageB = (char *) "Thread B";
int returnValueA;
int returnValueB;
returnValueA = pthread_create (&threadA, NULL, functionOfThreadA, (void*) messageA);
returnValueB = pthread_create (&threadB, NULL, functionOfThreadB, (void*) messageB);
pthread_join (threadA, NULL);
pthread_join (threadB, NULL);
exit (0);
}
void * functionOfThreadA (void * ptr)
{
char * message;
message = (char *) ptr;
while (1)
{
pthread_mutex_lock (&mutexLock);
if (x == 1000)
{
std :: cout << "\nA: x is now 1000. Waiting period over."<< "\n";
return 0;
}
else
{
std :: cout << "\nNow, thread A will wait for value of `x` to reach 1000" << "\n";
pthread_cond_wait (&cond, &mutexLock);
}
pthread_mutex_unlock (&mutexLock);
}
}
void * functionOfThreadB (void * ptr)
{
while (1)
{
char * message;
message = (char *) ptr;
pthread_mutex_lock (&mutexLock);
x = x + 1;
if (x == 1000)
{
std :: cout << "\nB: Signaled. Value of x: " << x << "\n";
pthread_cond_signal (&cond);
*************pthread_mutex_unlock (&mutexLock);*************
*************return 0;*************
}
else
{
std :: cout << "\nB: Not signaled yet. Value of x: " << x << "\n";
}
pthread_mutex_unlock (&mutexLock);
}
}