ฟังก์ชัน pthread จากคลาส

Question 1

สมมติว่าฉันมีคลาสเช่น

class c { 
    // ...
    void *print(void *){ cout << "Hello"; }
}

แล้วผมก็มีเวกเตอร์ของ c

vector<c> classes; pthread_t t1;
classes.push_back(c());
classes.push_back(c());

ตอนนี้ฉันต้องการสร้างเธรดบน c.print();

และสิ่งต่อไปนี้ทำให้ฉันมีปัญหาด้านล่าง: pthread_create(&t1, NULL, &c[0].print, NULL);

ข้อผิดพลาด Ouput: ไม่สามารถแปลง 'void * (tree_item ::) (void )' เป็น 'void * ( ) (void )' สำหรับอาร์กิวเมนต์ '3' ถึง 'int pthread_create (pthread_t *, const pthread_attr_t *, void * ( ) (โมฆะ ), เป็นโมฆะ *) '

Question 2

คุณไม่สามารถทำได้อย่างที่เขียนไว้เนื่องจากฟังก์ชันสมาชิกคลาส C ++ มีthisพารามิเตอร์ที่ซ่อนอยู่ส่งผ่านมา pthread_create()ไม่รู้ว่าthisจะใช้ค่าใดดังนั้นหากคุณพยายามที่จะใช้คอมไพเลอร์โดยการส่งเมธอดไปยังฟังก์ชัน ตัวชี้ประเภทที่เหมาะสมคุณจะได้รับความผิดพลาดในการวัดค่า คุณต้องใช้เมธอดคลาสแบบคงที่ (ซึ่งไม่มีthisพารามิเตอร์) หรือฟังก์ชั่นธรรมดาธรรมดาในการบูตคลาส:

class C
{
public:
    void *hello(void)
    {
        std::cout << "Hello, world!" << std::endl;
        return 0;
    }

    static void *hello_helper(void *context)
    {
        return ((C *)context)->hello();
    }
};
...
C c;
pthread_t t;
pthread_create(&t, NULL, &C::hello_helper, &c);

Question 3

วิธีที่ฉันชอบที่สุดในการจัดการเธรดคือการห่อหุ้มไว้ในวัตถุ C ++ นี่คือตัวอย่าง:

class MyThreadClass
{
public:
   MyThreadClass() {/* empty */}
   virtual ~MyThreadClass() {/* empty */}

   /** Returns true if the thread was successfully started, false if there was an error starting the thread */
   bool StartInternalThread()
   {
      return (pthread_create(&_thread, NULL, InternalThreadEntryFunc, this) == 0);
   }

   /** Will not return until the internal thread has exited. */
   void WaitForInternalThreadToExit()
   {
      (void) pthread_join(_thread, NULL);
   }

protected:
   /** Implement this method in your subclass with the code you want your thread to run. */
   virtual void InternalThreadEntry() = 0;

private:
   static void * InternalThreadEntryFunc(void * This) {((MyThreadClass *)This)->InternalThreadEntry(); return NULL;}

   pthread_t _thread;
};

ในการใช้งานคุณจะต้องสร้างคลาสย่อยของ MyThreadClass ด้วยเมธอด InternalThreadEntry () ที่ใช้เพื่อให้มีการวนซ้ำเหตุการณ์ของเธรดของคุณ คุณต้องเรียก WaitForInternalThreadToExit () บนวัตถุเธรดก่อนที่จะลบวัตถุเธรดแน่นอน (และมีกลไกบางอย่างเพื่อให้แน่ใจว่าเธรดออกจริงมิฉะนั้น WaitForInternalThreadToExit () จะไม่กลับมา)

Question 4

คุณจะต้องให้pthread_createฟังก์ชันที่ตรงกับลายเซ็นที่ต้องการ สิ่งที่คุณผ่านจะไม่ได้ผล

คุณสามารถใช้ฟังก์ชันคงที่ที่คุณต้องการทำสิ่งนี้และสามารถอ้างอิงอินสแตนซ์ของcและดำเนินการสิ่งที่คุณต้องการในเธรด pthread_createได้รับการออกแบบมาเพื่อไม่เพียง แต่ใช้ตัวชี้ฟังก์ชันเท่านั้น cในกรณีนี้คุณก็ผ่านมันชี้ไปยังตัวอย่างของ

ตัวอย่างเช่น:

static void* execute_print(void* ctx) {
    c* cptr = (c*)ctx;
    cptr->print();
    return NULL;
}


void func() {

    ...

    pthread_create(&t1, NULL, execute_print, &c[0]);

    ...
}

Question 5

คำตอบข้างต้นเป็นสิ่งที่ดี แต่ในกรณีของฉันวิธีที่ 1 ที่แปลงฟังก์ชันเป็นแบบคงที่ไม่ได้ผล ฉันพยายามแปลงรหัสที่ออกเพื่อย้ายไปยังฟังก์ชันเธรด แต่รหัสนั้นมีการอ้างอิงถึงสมาชิกคลาสที่ไม่คงที่อยู่แล้ว โซลูชันที่สองของการห่อหุ้มลงในวัตถุ C ++ ใช้งานได้ แต่มีการห่อหุ้ม 3 ระดับเพื่อรันเธรด

ฉันมีโซลูชันทางเลือกที่ใช้โครงสร้าง C ++ ที่มีอยู่ - ฟังก์ชั่น 'เพื่อน' และมันก็ทำงานได้อย่างสมบูรณ์แบบสำหรับกรณีของฉัน ตัวอย่างวิธีที่ฉันใช้ 'เพื่อน' (จะใช้ตัวอย่างข้างต้นสำหรับชื่อที่แสดงว่าสามารถแปลงเป็นรูปแบบกะทัดรัดโดยใช้เพื่อนได้อย่างไร)

    class MyThreadClass
    {
    public:
       MyThreadClass() {/* empty */}
       virtual ~MyThreadClass() {/* empty */}

       bool Init()
       {
          return (pthread_create(&_thread, NULL, &ThreadEntryFunc, this) == 0);
       }

       /** Will not return until the internal thread has exited. */
       void WaitForThreadToExit()
       {
          (void) pthread_join(_thread, NULL);
       }

    private:
       //our friend function that runs the thread task
       friend void* ThreadEntryFunc(void *);

       pthread_t _thread;
    };

    //friend is defined outside of class and without any qualifiers
    void* ThreadEntryFunc(void *obj_param) {
    MyThreadClass *thr  = ((MyThreadClass *)obj_param); 

    //access all the members using thr->

    return NULL;
    }

แน่นอนเราสามารถใช้ boost :: thread และหลีกเลี่ยงสิ่งเหล่านี้ได้ แต่ฉันพยายามแก้ไขโค้ด C ++ เพื่อไม่ใช้ boost (โค้ดเชื่อมโยงกับ boost เพื่อจุดประสงค์นี้เท่านั้น)

Question 6

คำตอบแรกของฉันด้วยความหวังว่าจะเป็นประโยชน์กับใครบางคน: ตอนนี้ฉันเป็นคำถามเก่า แต่ฉันพบข้อผิดพลาดเดียวกันกับคำถามข้างต้นขณะที่ฉันเขียนคลาส TcpServer และฉันพยายามใช้ pthreads ฉันพบคำถามนี้และฉันเข้าใจแล้วว่าทำไมมันถึงเกิดขึ้น ฉันลงเอยด้วยการทำสิ่งนี้:

#include <thread>

วิธีการรันเธรด -> void* TcpServer::sockethandler(void* lp) {/*code here*/}

และฉันเรียกมันด้วยแลมด้า -> std::thread( [=] { sockethandler((void*)csock); } ).detach();

นั่นดูเหมือนเป็นแนวทางที่สะอาดสำหรับฉัน

Question 7

หลายครั้งเกินไปที่ฉันพบวิธีแก้ปัญหาสิ่งที่คุณต้องการในความคิดของฉันซับซ้อนเกินไป ตัวอย่างเช่นคุณต้องกำหนดประเภทคลาสใหม่ลิงค์ไลบรารีเป็นต้นดังนั้นฉันจึงตัดสินใจเขียนโค้ดสองสามบรรทัดเพื่อให้ผู้ใช้ปลายทางสามารถ "thread-ize" a "void :: method (void)" ของ ชั้นเรียนอะไรก็ได้ แน่นอนว่าโซลูชันนี้ที่ฉันนำมาใช้สามารถขยายปรับปรุงและอื่น ๆ ได้ดังนั้นหากคุณต้องการวิธีการหรือคุณสมบัติที่เฉพาะเจาะจงมากขึ้นให้เพิ่มเข้าไปและโปรดกรุณาให้ฉันอยู่ในวง

นี่คือไฟล์ 3 ไฟล์ที่แสดงสิ่งที่ฉันทำ

    // A basic mutex class, I called this file Mutex.h
#ifndef MUTEXCONDITION_H_
#define MUTEXCONDITION_H_

#include <pthread.h>
#include <stdio.h>

class MutexCondition
{
private:
    bool init() {
        //printf("MutexCondition::init called\n");
        pthread_mutex_init(&m_mut, NULL);
        pthread_cond_init(&m_con, NULL);
        return true;
    }

    bool destroy() {
        pthread_mutex_destroy(&m_mut);
        pthread_cond_destroy(&m_con);
        return true;
    }

public:
    pthread_mutex_t m_mut;
    pthread_cond_t m_con;

    MutexCondition() {
        init();
    }
    virtual ~MutexCondition() {
        destroy();
    }

    bool lock() {
        pthread_mutex_lock(&m_mut);
        return true;
    }

    bool unlock() {
        pthread_mutex_unlock(&m_mut);
        return true;
    }

    bool wait() {
        lock();
        pthread_cond_wait(&m_con, &m_mut);
        unlock();
        return true;
    }

    bool signal() {
        pthread_cond_signal(&m_con);
        return true;
    }
};
#endif
// End of Mutex.h

// คลาสที่รวมงานทั้งหมดไว้ใน thread-ize a method (test.h):

#ifndef __THREAD_HANDLER___
#define __THREAD_HANDLER___

#include <pthread.h>
#include <vector>
#include <iostream>
#include "Mutex.h"

using namespace std;

template <class T> 
class CThreadInfo
{
  public:
    typedef void (T::*MHT_PTR) (void);
    vector<MHT_PTR> _threaded_methods;
    vector<bool> _status_flags;
    T *_data;
    MutexCondition _mutex;
    int _idx;
    bool _status;

    CThreadInfo(T* p1):_data(p1), _idx(0) {}
    void setThreadedMethods(vector<MHT_PTR> & pThreadedMethods)
    {
        _threaded_methods = pThreadedMethods;
      _status_flags.resize(_threaded_methods.size(), false);
    }
};

template <class T> 
class CSThread {
  protected:
    typedef void (T::*MHT_PTR) (void);
    vector<MHT_PTR> _threaded_methods;
    vector<string> _thread_labels;
    MHT_PTR _stop_f_pt;
    vector<T*> _elements;
    vector<T*> _performDelete;
    vector<CThreadInfo<T>*> _threadlds;
    vector<pthread_t*> _threads;
    int _totalRunningThreads;

    static void * gencker_(void * pArg)
    {
      CThreadInfo<T>* vArg = (CThreadInfo<T> *) pArg;
      vArg->_mutex.lock();
      int vIndex = vArg->_idx++;
      vArg->_mutex.unlock();

      vArg->_status_flags[vIndex]=true;

      MHT_PTR mhtCalledOne = vArg->_threaded_methods[vIndex];
      (vArg->_data->*mhtCalledOne)();
      vArg->_status_flags[vIndex]=false;
        return NULL;
    }

  public:
    CSThread ():_stop_f_pt(NULL), _totalRunningThreads(0)  {}
    ~CSThread()
    {
      for (int i=_threads.size() -1; i >= 0; --i)
          pthread_detach(*_threads[i]);

      for (int i=_threadlds.size() -1; i >= 0; --i)
        delete _threadlds[i];

      for (int i=_elements.size() -1; i >= 0; --i)
         if (find (_performDelete.begin(), _performDelete.end(), _elements[i]) != _performDelete.end())
              delete _elements[i];
    }
    int  runningThreadsCount(void) {return _totalRunningThreads;}
    int  elementsCount()        {return _elements.size();}
    void addThread (MHT_PTR p, string pLabel="") { _threaded_methods.push_back(p); _thread_labels.push_back(pLabel);}
    void clearThreadedMethods() { _threaded_methods.clear(); }
    void getThreadedMethodsCount() { return _threaded_methods.size(); }
    void addStopMethod(MHT_PTR p)  { _stop_f_pt  = p; }
    string getStatusStr(unsigned int _elementIndex, unsigned int pMethodIndex)
    {
      char ch[99];

      if (getStatus(_elementIndex, pMethodIndex) == true)
        sprintf (ch, "[%s] - TRUE\n", _thread_labels[pMethodIndex].c_str());
      else 
        sprintf (ch, "[%s] - FALSE\n", _thread_labels[pMethodIndex].c_str());

      return ch;
    }
    bool getStatus(unsigned int _elementIndex, unsigned int pMethodIndex)
    {
      if (_elementIndex > _elements.size()) return false;
      return _threadlds[_elementIndex]->_status_flags[pMethodIndex];
    }

    bool run(unsigned int pIdx) 
    {
      T * myElem = _elements[pIdx];
      _threadlds.push_back(new CThreadInfo<T>(myElem));
      _threadlds[_threadlds.size()-1]->setThreadedMethods(_threaded_methods);

      int vStart = _threads.size();
      for (int hhh=0; hhh<_threaded_methods.size(); ++hhh)
          _threads.push_back(new pthread_t);

      for (int currentCount =0; currentCount < _threaded_methods.size(); ++vStart, ++currentCount)
      {
                if (pthread_create(_threads[vStart], NULL, gencker_, (void*) _threadlds[_threadlds.size()-1]) != 0)
        {
                // cout <<"\t\tThread " << currentCount << " creation FAILED for element: " << pIdx << endl;
                    return false;
                }
        else
        {
            ++_totalRunningThreads;
             // cout <<"\t\tThread " << currentCount << " creation SUCCEDED for element: " << pIdx << endl;
                }
      }
      return true;
    }

    bool run() 
    {
            for (int vI = 0; vI < _elements.size(); ++vI) 
            if (run(vI) == false) return false;
          // cout <<"Number of currently running threads: " << _totalRunningThreads << endl;
        return true;
    }

    T * addElement(void)
    {
      int vId=-1;
      return addElement(vId);
    }

    T * addElement(int & pIdx)
    {
      T * myElem = new T();
      _elements.push_back(myElem);
      pIdx = _elements.size()-1;
      _performDelete.push_back(myElem);
      return _elements[pIdx];
    }

    T * addElement(T *pElem)
    {
      int vId=-1;
      return addElement(pElem, vId);
    }

    T * addElement(T *pElem, int & pIdx)
    {
      _elements.push_back(pElem);
      pIdx = _elements.size()-1;
      return pElem;
    }

    T * getElement(int pId) { return _elements[pId]; }

    void stopThread(int i)  
    {
      if (_stop_f_pt != NULL) 
      {
         ( _elements[i]->*_stop_f_pt)() ;
      }
      pthread_detach(*_threads[i]);
      --_totalRunningThreads;
    }

    void stopAll()  
    {
      if (_stop_f_pt != NULL) 
        for (int i=0; i<_elements.size(); ++i) 
        {
          ( _elements[i]->*_stop_f_pt)() ;
        }
      _totalRunningThreads=0;
    }
};
#endif
// end of test.h

// ไฟล์ตัวอย่างการใช้งาน "test.cc" ที่บน linux ฉันได้รวบรวมด้วยคลาสที่รวบรวมงานทั้งหมดไว้ใน thread-ize a method: g ++ -o mytest.exe test.cc -I -lpthread -lstdc ++

#include <test.h>
#include <vector>
#include <iostream>
#include <Mutex.h>

using namespace std;

// Just a class for which I need to "thread-ize" a some methods
// Given that with OOP the objecs include both "functions" (methods)
// and data (attributes), then there is no need to use function arguments,
// just a "void xxx (void)" method.
// 
class TPuck
{
  public:
   bool _go;
   TPuck(int pVal):_go(true)
   {
     Value = pVal;
   }
   TPuck():_go(true)
   {
   }
   int Value;
   int vc;

   void setValue(int p){Value = p; }

   void super()
   {
     while (_go)
     {
      cout <<"super " << vc << endl;
            sleep(2);
         }
      cout <<"end of super " << vc << endl;
   }

   void vusss()
   {
     while (_go)
     {
      cout <<"vusss " << vc << endl;
      sleep(2);
     }
      cout <<"end of vusss " << vc << endl;
   }

   void fazz()
   {
     static int vcount =0;
     vc = vcount++;
     cout <<"Puck create instance: " << vc << endl;
     while (_go)
     {
       cout <<"fazz " << vc << endl;
       sleep(2);
     }
     cout <<"Completed TPuck..fazz instance "<<  vc << endl;
   }

   void stop()
   {
      _go=false;
      cout << endl << "Stopping TPuck...." << vc << endl;
   }
};


int main(int argc, char* argv[])
{
  // just a number of instances of the class I need to make threads
  int vN = 3;

  // This object will be your threads maker.
  // Just declare an instance for each class
  // you need to create method threads
  //
  CSThread<TPuck> PuckThreadMaker;
  //
  // Hera I'm telling which methods should be threaded
  PuckThreadMaker.addThread(&TPuck::fazz, "fazz1");
  PuckThreadMaker.addThread(&TPuck::fazz, "fazz2");
  PuckThreadMaker.addThread(&TPuck::fazz, "fazz3");
  PuckThreadMaker.addThread(&TPuck::vusss, "vusss");
  PuckThreadMaker.addThread(&TPuck::super, "super");

  PuckThreadMaker.addStopMethod(&TPuck::stop);

  for (int ii=0; ii<vN; ++ii)
  {
    // Creating instances of the class that I need to run threads.
    // If you already have your instances, then just pass them as a
    // parameter such "mythreadmaker.addElement(&myinstance);"
    TPuck * vOne = PuckThreadMaker.addElement();
  }

  if (PuckThreadMaker.run() == true)
  {
    cout <<"All running!" << endl;
  }
  else
  {
    cout <<"Error: not all threads running!" << endl;
  }

  sleep(1);
  cout <<"Totale threads creati: " << PuckThreadMaker.runningThreadsCount()  << endl;
  for (unsigned int ii=0; ii<vN; ++ii)
  {
    unsigned int kk=0;
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
  }

  sleep(2);
  PuckThreadMaker.stopAll();
  cout <<"\n\nAfter the stop!!!!" << endl;
  sleep(2);

  for (int ii=0; ii<vN; ++ii)
  {
    int kk=0;
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
    cout <<"status for element " << ii << " is " << PuckThreadMaker.getStatusStr(ii, kk++) << endl; 
  }

  sleep(5);
  return 0;
}

// End of test.cc

Question 8

นี่เป็นคำถามเก่าไปหน่อย แต่เป็นปัญหาที่พบบ่อยมากซึ่งหลายคนต้องเผชิญ ต่อไปนี้เป็นวิธีที่ง่ายและสวยงามในการจัดการสิ่งนี้โดยใช้ std :: thread

#include <iostream>
#include <utility>
#include <thread>
#include <chrono>

class foo
{
    public:
        void bar(int j)
        {
            n = j;
            for (int i = 0; i < 5; ++i) {
                std::cout << "Child thread executing\n";
                ++n;
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
            }
        }
        int n = 0;
};

int main()
{
    int n = 5;
    foo f;
    std::thread class_thread(&foo::bar, &f, n); // t5 runs foo::bar() on object f
    std::this_thread::sleep_for(std::chrono::milliseconds(20));
    std::cout << "Main Thread running as usual";
    class_thread.join();
    std::cout << "Final value of foo::n is " << f.n << '\n';
}

โค้ดด้านบนยังดูแลการส่งอาร์กิวเมนต์ไปยังฟังก์ชันเธรด

อ้างอิงเอกสารstd :: threadสำหรับรายละเอียดเพิ่มเติม

Question 9

ฉันเดาว่านี่คือ b / c มันถูกทำให้ยุ่งเหยิงเล็กน้อยโดย C ++ b / c ของคุณส่งตัวชี้ C ++ ไม่ใช่ตัวชี้ฟังก์ชัน C มีความแตกต่างอย่างเห็นได้ชัด ลองทำ

(void)(*p)(void) = ((void) *(void)) &c[0].print; //(check my syntax on that cast)

แล้วส่ง p.

ฉันได้ทำสิ่งที่คุณทำกับฟังก์ชันสมาชิกแล้ว แต่ฉันทำในคลาสที่ใช้มันและด้วยฟังก์ชันคงที่ซึ่งฉันคิดว่าสร้างความแตกต่าง

Question 10

C ++: จะส่งฟังก์ชันสมาชิกคลาสไปยัง pthread_create () ได้อย่างไร?

http://thispointer.com/c-how-to-pass-class-member-function-to-pthread_create/

typedef void * (*THREADFUNCPTR)(void *);

class C { 
   // ...
   void *print(void *) { cout << "Hello"; }
}

pthread_create(&threadId, NULL, (THREADFUNCPTR) &C::print, NULL);