我已经实现了一个条件变量示例。但是，我看到一旦我在pthread_cond_wait收到信号后睡觉了。睡眠后的代码不会被执行。它直接跳转到else条件。据我所知，互斥锁现已解锁。我只有两个线程A和B.两个线程都有两个不同的启动例程。如果我在获得信号后在线程A中进行了休眠，那么它应该调度线程B.现在，一旦线程B完成。线程A应该从睡眠后的地方恢复。然而，它不是从睡眠中恢复的。它重新获得锁定。看看我的例子，它是输出。您将注意到以下行从未打印过 - 要快速解决我的问题 - 只需查看以下函数 - void * Thread_Function_A（void * thread_arg）和void * Thread_Function_B（void * thread_arg）。其他功能并不重要。
The cond_wait is unblocked now
The thread A proceeds
Thread A unlocked
现在是程序 -
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <iostream>
/** get pid **/
#include <sys/types.h>
#include <unistd.h>
/** kill signal **/
#include <signal.h>
using namespace std;
int shared_variable = 7;
pid_t pid_A;
pid_t pid_B;
class helium_thread
{
private:
pthread_t *thread_id;
pid_t process_pid;
public:
static pthread_mutex_t mutex_thread;
static pthread_cond_t cond_var;
void set_thread_id(pthread_t tid);
pthread_t *get_thread_id();
int create_thread(pthread_t *thread_ptr, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg );
helium_thread();
~helium_thread();
};
helium_thread thread_1, thread_2;
/** The definition of the static member can't be inside a function, You need to put it outside **/
/** When I tried using inside a function, I got the error - error: invalid use of qualified-name ‘helium_thread::mutex_thread **/
pthread_mutex_t helium_thread::mutex_thread = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t helium_thread::cond_var = PTHREAD_COND_INITIALIZER;
void helium_thread::set_thread_id( pthread_t tid)
{
*(this->thread_id) = tid;
}
pthread_t * helium_thread::get_thread_id( )
{
return (this->thread_id);
}
int helium_thread::create_thread(pthread_t *thread_ptr, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg )
{
int ret;
ret = pthread_create(thread_ptr,attr,start_routine,(void *)arg) ;
cout<<"Thread created "<<std::hex<<thread_ptr<<endl;
return ret;
}
helium_thread::helium_thread()
{
thread_id = new pthread_t;
cout<<"Constructor called "<<std::hex<<thread_id<<endl;
}
helium_thread::~helium_thread()
{
cout<<"Destructor called"<<std::hex<<thread_id<<endl;
delete thread_id;
}
/** While defining the methods of the class, Keywords static and virtual should not be repeated in the definition. **/
/** They should only be used in the class declaration. **/
void handler(int sig)
{
//do nothing
cout<<"Handler called"<<endl;
}
void *Thread_Function_A(void *thread_arg)
{
int rc = 0;
pid_A = getpid();
cout<<"The pid value of Thread A is"<< pid_A << endl;
while(1)
{
pthread_mutex_lock(&(helium_thread::mutex_thread));
cout<<"Thread A lock acquire first"<<endl;
if ( shared_variable != 5)
{
/** Now you put a sleep to introduce a race condition **/
/** You will find that there is no race condition here **/
cout<<"Going to conditional wait"<<endl;
//cout<<"Sleep thread A"<<endl;
//sleep(5);
pthread_cond_wait(&helium_thread::cond_var, &helium_thread::mutex_thread);
cout<<"Sleep after cond_wait"<<endl;
sleep(5);
cout<<"The cond_wait is unblocked now "<<endl;
cout<<"The thread A proceeds"<<endl;
cout<<"The shared_variable value = "<< std::dec<< shared_variable << endl;
pthread_mutex_unlock(&(helium_thread::mutex_thread));
cout<<"Thread A unlocked"<<endl;
}
else
{
cout<<"Else condition thread A..shared variable value is "<<shared_variable<<endl;
cout<<"The condition of thread A is met now"<<endl;
pthread_mutex_unlock(&(helium_thread::mutex_thread));
cout<<"Thread A unlocked in else condition"<<endl;
pthread_exit(NULL);
}
}
}
void *Thread_Function_B(void *thread_arg)
{
pthread_mutex_lock(&(helium_thread::mutex_thread));
pid_B = getpid();
cout<<"The pid value of Thread B is"<< pid_B << endl;
shared_variable = 5;
/** Now you put a sleep to introduce a race condition **/
/** You will find that there is no race condition here **/
//sleep(5);
cout<<"Signal the thread A now "<<endl;
pthread_cond_signal (&helium_thread::cond_var);
cout<<"Changed the shared_variable value now"<<endl;
pthread_mutex_unlock(&(helium_thread::mutex_thread));
cout<<"Return thread function b now"<<endl;
}
int main(int argc, char *argv[])
{
pid_t thread_pid_val = getpid();
thread_1.create_thread((thread_1.get_thread_id()),NULL,Thread_Function_A,&thread_pid_val);
thread_2.create_thread((thread_2.get_thread_id()),NULL,Thread_Function_B,&thread_pid_val);
pthread_join( *(thread_1.get_thread_id()), NULL);
pthread_join( *(thread_2.get_thread_id()), NULL);
return 0;
}
输出如下。
$ ./thread_basic.out
Constructor called 0x2012010
Constructor called 0x2012030
Thread created 0x2012010
The pid value of Thread A is5bfd
Thread created 0x2012030
Thread A lock acquire first
Going to conditional wait
The pid value of Thread B is5bfd
Signal the thread A now
Changed the shared_variable value now
Return thread function b now
Sleep after cond_wait
The cond_wait is unblocked now
The thread A proceeds
The shared_variable value = 5
Thread A unlocked
Thread A lock acquire first
Else condition thread A..shared variable value is 5
The condition of thread A is met now
Thread A unlocked in else condition
Destructor called0x2012030
Destructor called0x2012010
答案 0 :(得分：1)
线程Thread_Function_A，Thread_Function_B中运行的两个函数有所不同。
在Thread_Function_B中你做的第一件事就是获取锁定，而在Thread_Function_A中你先得到pid，然后开始一个while循环然后获取锁定。
因此，当创建2个线程时，B 1st获得锁定，A必须等待其获得锁定的机会。 B将共享变量的值设置为5，然后将信号条件变量设置为。虽然在这种情况下，现在没有线程在等待条件（因为A尚未获得锁定然后等待条件）。
当B释放锁定A获取时，它发现共享变量为5，因此进入其他条件。
理想情况下，您可能希望A到1st获得锁并等待条件，但在您当前的实现中，这不会发生。
尝试并首先获取A中的锁定，然后继续。
void *Thread_Function_A(void *thread_arg)
{
pthread_mutex_lock(&(helium_thread::mutex_thread));
//remaining logic
答案 1 :(得分：1)
我删除了大部分代码混乱，并将日志语句更改为更清晰一点。我没有看到你所看到的。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
using namespace std;
int shared_variable = 7;
pid_t pid_A;
pid_t pid_B;
class helium_thread
{
private:
pthread_t *thread_id;
pid_t process_pid;
public:
static pthread_mutex_t mutex_thread;
static pthread_cond_t cond_var;
void set_thread_id(pthread_t tid);
pthread_t *get_thread_id();
int create_thread(pthread_t *thread_ptr, const pthread_attr_t *attr,
void * (*start_routine)(void *), void *arg );
helium_thread();
~helium_thread();
};
helium_thread thread_1, thread_2;
pthread_mutex_t helium_thread::mutex_thread = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t helium_thread::cond_var = PTHREAD_COND_INITIALIZER;
void helium_thread::set_thread_id( pthread_t tid) {*(this->thread_id) = tid;}
pthread_t * helium_thread::get_thread_id() {return (this->thread_id);}
int helium_thread::create_thread(pthread_t *thread_ptr, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg )
{
int ret;
ret = pthread_create(thread_ptr, attr, start_routine, (void *)arg) ;
return ret;
}
helium_thread::helium_thread() {thread_id = new pthread_t; }
helium_thread::~helium_thread() {delete thread_id;}
void *Thread_Function_A(void *thread_arg)
{
while (1)
{
pthread_mutex_lock(&(helium_thread::mutex_thread));
cout << "TA lock acquired" << endl;
if ( shared_variable != 5)
{
cout << "TA Going to conditional wait" << endl;
pthread_cond_wait(&helium_thread::cond_var, &helium_thread::mutex_thread);
cout << "TA Sleep after cond_wait" << endl;
sleep(5);
cout << "TA The cond_wait is unblocked now " << endl;
cout << "TA The thread A proceeds" << endl;
cout << "TA The shared_variable value = " << shared_variable << endl;
pthread_mutex_unlock(&(helium_thread::mutex_thread));
cout << "TA unlocked" << endl;
}
else
{
cout << "TA Else condition thread A..shared variable value is " << shared_variable << endl;
cout << "TA The condition of thread A is met now" << endl;
pthread_mutex_unlock(&(helium_thread::mutex_thread));
cout << "TA unlocked in else condition" << endl;
pthread_exit(NULL);
}
}
return NULL;
}
void *Thread_Function_B(void *thread_arg)
{
pthread_mutex_lock(&(helium_thread::mutex_thread));
shared_variable = 5;
cout << "TB Signal the thread A now " << endl;
pthread_cond_signal (&helium_thread::cond_var);
cout << "TB the changed shared_variable is now" << endl;
pthread_mutex_unlock(&(helium_thread::mutex_thread));
cout << "TB Return thread now" << endl;
return NULL;
}
int main(int argc, char *argv[])
{
thread_1.create_thread((thread_1.get_thread_id()), NULL, Thread_Function_A, NULL);
thread_2.create_thread((thread_2.get_thread_id()), NULL, Thread_Function_B, NULL);
pthread_join( *(thread_1.get_thread_id()), NULL);
pthread_join( *(thread_2.get_thread_id()), NULL);
return 0;
}
以下是我一直看到的3个场景。没有涉及跳码。 sleep可能（或可能不会）在执行中引入一些可变性，但我没有看到任何意外的事情。
<强>一
TA lock acquired
TA Going to conditional wait
TB Signal the thread A now
TB the changed shared_variable is now
TA Sleep after cond_wait
TB Return thread now
TA The cond_wait is unblocked now
TA The thread A proceeds
TA The shared_variable value = 5
TA unlocked
TA lock acquired
TA Else condition thread A..shared variable value is 5
TA The condition of thread A is met now
TA unlocked in else condition
<强>两个
TA lock acquired
TA Going to conditional wait
TB Signal the thread A now
TB the changed shared_variable is now
TB Return thread now
TA Sleep after cond_wait
TA The cond_wait is unblocked now
TA The thread A proceeds
TA The shared_variable value = 5
TA unlocked
TA lock acquired
TA Else condition thread A..shared variable value is 5
TA The condition of thread A is met now
TA unlocked in else condition
<强>三
TB Signal the thread A now
TB the changed shared_variable is now
TB Return thread now
TA lock acquired
TA Else condition thread A..shared variable value is 5
TA The condition of thread A is met now
TA unlocked in else condition