C++ 类中的pthread函数
假设我有一门课，比如C++ 类中的pthread函数,c++,pthreads,C++,Pthreads,假设我有一门课，比如 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，
class c {
// ...
void *print(void *){ cout << "Hello"; }
}
vector<c> classes; pthread_t t1;
classes.push_back(c());
classes.push_back(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]);
...
}
我猜这是B/C，它被C++ B/C弄得有点混乱，你把它发送到C++指针，而不是C函数指针。有一个明显的问题。试着做一个测试
(void)(*p)(void) = ((void) *(void)) &c[0].print; //(check my syntax on that cast)
我已经用一个成员函数完成了你的工作，但是我在使用它的类中做了，并且用了一个静态函数——我觉得它与众不同。
< P>我最喜欢处理线程的方法是把它封装在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方法以包含线程的事件循环。当然，在删除thread对象之前，需要在thread对象上调用WaitForInternalThreadToExit，并使用某种机制确保线程实际退出，否则，WaIfFieldTyReToTeX将永远不会返回 < P>不能像你写的那样做，因为C++类成员函数有一个隐藏的参数。pthread_create不知道该使用什么值，因此如果您试图通过将该方法强制转换为适当类型的函数指针来绕过编译器，则会出现segmetation错误。必须使用没有此参数的静态类方法或普通函数来引导类：
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);
上面的答案很好，但在我的例子中，第一种将函数转换为静态函数的方法不起作用。我试图将现有代码转换为线程函数，但该代码已经有很多对非静态类成员的引用。封装到C++对象中的第二种解决方案是工作的，但是有3级包装器来运行线程。
我有一个替代的解决方案，它使用了现有的C++构造-“朋友”函数，它对我的情况来说是完美的。 我如何使用“friend”的一个示例将使用上面相同的名称示例，显示如何使用friend将其转换为紧凑形式
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;
}
当然，我们可以使用Booo:：线程并避免所有这些，但是我试图修改C++代码，不使用Boost代码，因为它是为了促进这个目的而连接的，
< P>我的第一个答案是希望它对某人有用： 我现在知道这是一个老问题，但我在编写TcpServer类和尝试使用pthreads时遇到了与上述问题完全相同的错误。我发现了这个问题，现在我明白了为什么会这样。我最终做了这样的事：#include <thread>
很多次我都想办法解决你的问题，我认为这些问题太复杂了。 例如，您必须定义新的类类型、链接库等。 所以我决定写几行代码，让最终用户 基本上能够线程化任何类的void:：methodvoid。 确保我实施的这个解决方案可以扩展、改进等， 如果您需要更具体的方法或功能，请添加它们，并请让我参与其中 这里有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
#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
#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
这是一个有点老的问题，但却是许多人面临的一个非常普遍的问题。 下面是使用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';
}
有关更多详细信息，请参阅文档。ooo我明白你的意思。。把c的指针传给它，明白了。。将实现并尝试我尝试了上述方法，但它给了我语法错误。。也试图改变它。。。如果您愿意展示一下使用pthread_create。。。这可能会有帮助，这是一个很好的方式，我可以理解上述虚拟类的使用，但我有很多deaper pr
问题..我有一些线程产生了其他线程，这些线程需要全部放在一个向量中。然后是一个递归循环，用于连接所有线程。我相信我也可以通过在适当的地方调用wait来实现上述功能，但是我会尝试一下，看看我的解决方案在哪里。这个解决方案非常优雅。从现在起我将使用它。谢谢你，杰里米·弗里斯纳+1你好，Jeremy Friesner，如何传递对InternalThreadEntryaclass_ref&refobj的引用？我应该做什么更改？@sree将MyThreadClass的引用或指针添加为成员变量；然后InternalThreadEntry可以直接访问它，而不必担心通过void*参数传递它。上面的方法是否可以使用向量：pthread_create&t、NULL、&C:：hello_helper、&vector_C[0]？以上所有评论都是有用的，我使用了所有评论的组合来解决一个问题。。它仍然像我想做的那样简单。。。但不幸的是，我只能将其中一个标记为正确，否则每个人都会获得荣誉。谢谢，我想对这个答案进行投票，但它使用了C风格的类型转换，必须以极端偏见来终止。这个答案在其他方面是正确的。@Chris：我不想卷入一场关于演员风格的圣战，但在这个例子中使用C风格演员在语义上是完全正确的。@AdamRosenfield将副词连在一起在语义上也是完全正确的，但这并不能成为一种好的风格！除息的
#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';
}