Question

我有这样的要求： - 1）有两个类，比如Wrapper和Wrapper2。 2）Wrapper2包含类Wrapper的引用对象。 3）线程将数据写入类Wrapper的变量，该变量应该基本上是调用Wrapper的成员函数。 4）另一个线程可以读取和写入Wrapper的类成员的数据，这个线程基本上是通过Wrapper2调用的。

基于Stackoverflow上旧问题的一些答案，我创建了一个示例代码来检查我的生产代码失败的原因，我无法弄清楚问题。一旦创建了thread2，它就会收到SIGSEG信号。代码如下： -

    #include <thread>
    #include <iostream>
    #include <chrono>
    #include <unistd.h>
    #include <stdlib.h>
    #include <signal.h>
    #include <stdio.h>
    #include <signal.h>
    #include <pthread.h>
    #include <wait.h>
    #include <string.h>

    pthread_mutex_t mt1;

    void thread_signal(int signum)
    {
      pthread_exit(0);
    }

    void sig_func(int sig)
    {
     write(1, "Caught signal 11\n", 17);
     std::cout<<"Caught signal :"<<sig<<std::endl;
     signal(SIGSEGV,sig_func);
     thread_signal(sig);
    }

    class Wrapper {
       public:
        Wrapper():i(10)
       {
            std::cout<<"Wrapper Constructor Called. "<<this<<" \n";
       }
        ~Wrapper()
       {
            std::cout<<"Wrapper Destructor Called. "<<this<<"\n";
       }
          void member1() {
              std::cout << "i am member1" << std::endl;
          }
          void member2(const char *arg1, unsigned arg2) {
              std::cout << "i am member2 and my first arg is (" << arg1 << ") and second arg is (" << arg2 << ")" << std::endl;
          }
        void setI(int i)
        {
            pthread_mutex_lock(&mt1);
            this->i=i;
            std::cout<<"set: "<< this->i<<std::endl;
            pthread_mutex_unlock(&mt1);
        }
        int getI()
        {
            pthread_mutex_lock(&mt1);
            std::cout<<"get: "<< this->i<<std::endl;
            pthread_mutex_unlock(&mt1);
            return 0;
        }
        int i;
    };

    class Wrapper2
    {
    public:
        Wrapper2(Wrapper & wp):wp2(wp)
    {
            std::cout<<"Wrapper2 Constructor Called. "<<this<<" \n";
    }

        ~Wrapper2()
       {
            std::cout<<"Wrapper2 Destructor Called. "<<this<<" \n";
       }
        Wrapper & wp2;
    };


    struct ThreadWrapper {
        Wrapper & wr1;
        Wrapper2 & wr2;

        ThreadWrapper( Wrapper & wr1,Wrapper2& wr2):
                    wr1(wr1),wr2(wr2)
        {

        }

    };

    extern "C" void* wrapper1Fun ( void* wr1)
    {
        std::auto_ptr< Wrapper > wrp1 ( static_cast< Wrapper* >( wr1 ) );
        std::cout<<"Thread 1 created. \n";
        while(1)
        {
            wrp1->setI(rand()%100);
            usleep(50);
        }

        return 0;
    }

    extern "C" void* wrapper2Fun ( void* wr2)
    {
        std::auto_ptr< Wrapper2 > wrp2 ( static_cast< Wrapper2* >( wr2 ) );
        std::cout<<"Thread 2 created. \n";
        while(1)
        {
            wrp2->wp2.getI();
            usleep(50);
        }

        return 0;
    }

    int main(int argc, char **argv) {
      struct sigaction sa;
      memset(&sa, 0, sizeof(sa));
      sa.sa_handler = thread_signal;
      sa.sa_flags = 0;
      sigaction(SIGTERM, &sa, 0);
      bool mainRunning= true;
       Wrapper w;
       Wrapper2 w1(w);

       sleep(1);
       ThreadWrapper * myWrap = new ThreadWrapper(w,w1);
       sleep(1);
       pthread_t pt1;
       pthread_t pt2;
       pthread_attr_t attr;
       signal(SIGSEGV,sig_func); // Register signal handler before going multithread
       pthread_attr_init(&attr);
       int i = pthread_create(&pt1, NULL,wrapper1Fun, myWrap);
       std::cout<<"First thread status "<<i<<std::endl;
       sleep(1);
       int j = pthread_create(&pt2, &attr,wrapper2Fun, myWrap);
       std::cout<<"Second thread status "<<j<<std::endl;
       sleep(1);
       while(1);
       fprintf(stderr, "kill thread\n");
       //pthread_kill(pt1, SIGTERM);
       fprintf(stderr, "join thread\n");
       pthread_join(pt1, NULL);
       pthread_join(pt1, NULL);

       return 0;
    }

Answer 1

期望

wrapper1Fun传递指向Wrapper的指针，wrapper2Fun期望传递指向Wraper2的指针。但是你实际上是在向每个ThreadWrapper传递一个指针，这是一个完全不同的类型，所以它出错了。

使用void *和强制转换会阻止编译器指出您的类型错误。我建议使用类型安全的C ++线程库而不是原始的pthread。 Boost有一个，C ++ 11的标准库也是如此。

您对auto_ptr的使用充其量也是值得怀疑的。它被弃用，容易出错，表达所有权的方式很差 - 更喜欢unique_ptr或shared_ptr。

在这里，您构造了两个拥有相同指针的auto_ptr值，因此它将被释放两次，这是未定义的行为。

在任何情况下都没有明显的理由将任何这些对象放在堆上。如果这样做，您需要确定内存所有权所在的位置。

Pthread for C ++类函数，它使用对类对象的引用

1 个答案: