为什么睡眠在我的程序中忽略了几个顺序指令？

Question

我已经实现了一个条件变量示例。然而，我看到，一旦我睡觉后，信号是接收到pthread_cond_wait。睡眠后的代码不执行。它直接跳转到其他条件。我知道互斥锁现在解锁了。我只有两个线程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

Answer 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;
}

下面是我经常看到的三个场景。没有一个涉及跳码。sleep可能(或不可能)在执行中引入一些可变性，但我没有看到任何出乎意料的东西。

One

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

2

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

Answer 2

在线程Thread_Function_A、Thread_Function_B中运行的两个函数是不同的。

在Thread_Function_B中，您所做的第一件事是获取锁，而在Thread_Function_A中，您首先获得pid，然后启动一个while循环，然后获得锁。

因此，当创建了2个线程时，B第一次获得锁，而A必须等待它获得锁的机会。B将共享变量的值设置为5，然后设置信号条件变量。虽然在这种情况下，到目前为止没有线程在条件下等待(因为A还没有获得锁，然后等待条件)。

当B释放锁A时，它会发现共享变量为5，因此进入了其他条件。

理想情况下，您希望A第一次获得锁并在条件下等待，但在当前的实现中，这种情况不会发生。

试着第一次锁定A，然后继续。

  void *Thread_Function_A(void *thread_arg)
  {
    pthread_mutex_lock(&(helium_thread::mutex_thread));
    //remaining logic