Let's have the following class definition:
CThread::CThread ()
{
this->hThread = NULL;
this->hThreadId = 0;
this->hMainThread = ::GetCurrentThread ();
this->hMainThreadId = ::GetCurrentThreadId ();
this->Timeout = 2000; //milliseconds
}
CThread::~CThread ()
{
//waiting for the thread to terminate
if (this->hThread) {
if (::WaitForSingleObject (this->hThread, this->Timeout) == WAIT_TIMEOUT)
::TerminateThread (this->hThread, 1);
::CloseHandle (this->hThread);
}
}
//*********************************************************
//working method
//*********************************************************
unsigned long CThread::Process (void* parameter)
{
//a mechanism for terminating thread should be implemented
//not allowing the method to be run from the main thread
if (::GetCurrentThreadId () == this->hMainThreadId)
return 0;
else {
m_pMyPointer = new MyClass(...);
// my class successfully works here in another thread
return 0;
}
}
//*********************************************************
//creates the thread
//*********************************************************
bool CThread::CreateThread ()
{
if (!this->IsCreated ()) {
param* this_param = new param;
this_param->pThread = this;
this->hThread = ::CreateThread (NULL, 0, (unsigned long (__stdcall *)(void *))this->runProcess, (void *)(this_param), 0, &this->hThreadId);
return this->hThread ? true : false;
}
return false;
}
//*********************************************************
//creates the thread
//*********************************************************
int CThread::runProcess (void* Param)
{
CThread* thread;
thread = (CThread*)((param*)Param)->pThread;
delete ((param*)Param);
return thread->Process (0);
}
MyClass* CThread::getMyPointer() {
return m_pMyPointer;
}
In the main program, we have the following:
void main(void) {
CThread thread;
thread.CreateThread();
MyClass* myPointer = thread.getMyPointer();
myPointer->someMethod(); // CRASH, BOOM, BANG!!!!
}
At the moment the myPointer is used ( in the main thread ) it crashes. I don't know how to get the pointer, which points to memory, allocated in another thread. Is this actually possible?
The memory space for your application is accessible to all threads. By default any variable is visible to any thread regardless of context (the only exception would be variables declared __delcspec(thread) )
You are getting a crash due to a race condition. The thread you just created hasn't started running yet at the point where you call getMyPointer. You need to add some kind of synchronization between the newly created thread and the originating thread. In other words, the originating thread has to wait until the new thread signals it that it has created the object.
I'm trying to get my head around what you are trying to do. It looks overly complicated for something like a thread-class. Would you mind post the class-definition as well?
Start by removing the C-style cast of the process-argument to CreateThread():
this->hThread = ::CreateThread (NULL, 0,&runProcess, (void *)(this_param), 0, &this->hThreadId);
If this doesn't compile you're doing something wrong! Never ever cast a function pointer! If the compiler complains you need to change your function, not try to cast away the errors! Really! You'll only make it worse for yourself! If you do it again they* will come to your home and do ... Let's see how you like that! Seriously, don't do it again.
Btw, in Process() I think it would be more appropriate to do something like:
assert(::GetCurrentThreadId() == hThreadId);
But if you declare it private it should only be accessible by your CThread-class anyway and therefor it shouldn't be a problem. Asserts are good though!
*It's not clear who they are but it's clear whatever they do it won't be pleasant!
As Rob Walker pointed out - I really missed the race condition. Also the crash is not when getting the pointer, but when using it.
A simple wait did the job:
MyClass* myPointer = thread.getMyPointer();
while (myPointer == 0)
{
::Sleep(1000);
}
myPointer->someMethod(); // Working :)
Related
Hello =D I am kinda stuck with a problem, I am trying to use pthread with mutex and cond variables to implement a garage. Normally I would just do it in main, but because I want to expand my C++ skills with OOP I want to implement it as a class.
First of all, I have some method that is called with threads. However, because of the way void* work in classes I have to implement them as static or functions outside of the class.
The problem is that it seems that the mutexes and condition variables wont communicate
void garage::start()
{
refresh = false;
pthread_create(&entryThread, nullptr, entryGuardThread, this);
for_each(carsThread.begin(), carsThread.end(), [&,this](pthread_t thread)
{
pthread_create(&thread, nullptr, &carThread, this);
});
}
This is in the class
void* carThread(void* in)
{
garage * temp = (garage*)in;
pthread_t uniqueThread = pthread_self();
while(!temp->refresh)
{
pthread_mutex_lock(&temp->entryLock);
temp->carWaitingAtEntry = true;
pthread_cond_signal(&temp->atEntry);
while(!temp->entryOpen)
pthread_cond_wait(&temp->atEntry, &temp->entryLock);
temp->carWaitingAtEntry = false;
pthread_mutex_unlock(&temp->entryLock);
temp->waiting(1);
}
return nullptr;
}
void* entryGuardThread(void* in)
{
garage * temp = (garage*)in;
while(!temp->refresh) {
pthread_mutex_lock(&temp->entryLock);
while(!temp->carWaitingAtEntry)
pthread_cond_wait(&temp->atEntry, &temp->entryLock);
temp->entryOpen = true;
pthread_cond_signal(&temp->atEntry);
while(temp->carWaitingAtEntry)
pthread_cond_wait(&temp->atEntry, &temp->entryLock);
temp->entryOpen = false;
pthread_mutex_unlock(&temp->entryLock);
}
return nullptr;
}
Do note that the reason that the functions are implemented as friends of the class so that I can access the private variable (I know it is stupid, but I gotta get it to work first). I have tested it and both functions refer to the same garage object....
All help is appreciated.
The Thread freezes at
while(!temp->entryOpen)
pthread_cond_wait(&temp->atEntry, &temp->entryLock);
I need help to implement an asynchonous funtion call in C++. I am new to multithreading in C++.
There sould be two funtions: one to get the work started in another thread and one to check progress and if work has been finished.
I tried it with some code from different answers on this site, but it doesn't work.
int __stdcall Test::asyncStartWork()
{
asyncReady = false;
std::thread workThread = std::thread(&Test::doWork, this);
return 0;
}
int __stdcall Test::asyncGetProgress()
{
if (asyncReady = true)
{
workThread.join();
return 100;
}
else
{
return asyncProgress;
}
}
int __stdcall Test::doWork()
{
//do work and write progress to asyncProgress
//at the end
asyncReady = true
}
When calling asyncStartWork I get the following error:
In method Test::asyncStartWork(), you are defining a local variable workThread which is hiding your class member.
So in asyncGetProgress(), when calling workThread.join(), you're calling it for a thread object which does not represent a thread (see here).
This results in a std::system_error being thrown with error condition no_such_process. If your program is not catching exceptions, this would result in the process aborting.
Try removing the std::thread part in asyncStartWork(), e.g.
int __stdcall Test::asyncStartWork()
{
asyncReady = false;
workThread = std::thread(&Test::doWork, this);
return 0;
}
Also, the __stdcall's seem unnecessary.
I have a classA which creates a thread and I want the thread running until a variable is set to false.
I create the thread like:
ClassA::ClassA():
m_bContinue(true),
{
pthread_mutex_init(&m_mutex, NULL);
pthread_create(&m_thWorkThread, NULL, &ClassA::ThreadProc, this);
}
I want thread running as long as pClassA->Continue() returns true.
void* ClassA::ThreadProc(void *p) //ThreadProc defined as static member function
{
ClassA *pClassA = reinterpret_cast<ClassA*>(p);
if(pClassA != NULL)
{
while(pClassA->Continue())
{
printf("in the while \n ");
}
}
else
printf("pClassA null \n");
}
Continue is returning m_bcontinue which set to true in the constructor.
bool ClassA::Continue()
{
return bContinue;
}
When I run it, it only enters while loop once and prints "in the while" and program stops. When I do strace, I saw the message +++ killed by SIGSEGV +++.
And when I change the while loop like:
while(1){}
it is working properly. What am I missing?
You cannot launch member functions using pthread_create. Instead, use normal function, pass this to it and call the needed function:
void *ThreadProc (void *p)
{
reinterpret_cast<ClassA*>(p)->ThreadProc (p);
return 0;
}
...
pthread_create(&m_thWorkThread, NULL, &ThreadProc, this);
Or, instead you can use c++11 and its std::thread that allows launching class member functions.
Could the object of type A have a shorter lifetime than the thread ? It seems object A dies too soon. Using while(1), you are no longer referencing A.
Quick question. Where is pthread_join here. I hope you havent missed it. Just curious.
I have to create an application where I'll have to make multiple threads. SoI thought to try making one function and passing it to different threads. Initially I've created two threads and have declared one function to be passed to both of them. All I am trying to do is to pass different integers to those threads and display it in the thread function,here is my code:
DWORD WINAPI Name(LPVOID lpParam)
{
int *Ptr=(int*)lpParam;
for(int j=0;j<2;j++)
{
cout<<"Thread"<<endl;
cout<<*Ptr<<endl;
}
return 0;
}
int main()
{
int a=10,b=15,c=25;
HANDLE thread1,thread2;
DWORD threadID,threadID2;
thread2= CreateThread(NULL,0,Name,LPVOID(a),0,&threadID2);
thread1= CreateThread(NULL,0,Name,LPVOID(b),0,&threadID);
for(int i=0;i<5;i++)
{
cout<<"Main Thread"<<endl;
}
if(thread1==NULL)
{
cout<<"Couldn't Create Thread:("<<endl;
exit(0);
}
if(thread2==NULL)
{
cout<<"Couldn't Create Thread:("<<endl;
exit(0);
}
return 0;
}
but this code is not running properly,i.e compliles fine,starts fine but afterwards gives a debugging error.
Could someone let let me know of my mistake and how I could correct it coz being able to utilize one function for multiple threads will be really helpful for me.
Wait for your child threads to return. Do this:
int main()
{
int a=10,b=15,c=25;
HANDLE thread[2];
DWORD threadID,threadID2;
thread[1]= CreateThread(NULL,0,Name,LPVOID(a),0,&threadID2);
thread[0]= CreateThread(NULL,0,Name,LPVOID(b),0,&threadID);
for(int i=0;i<5;i++)
{
cout<<"Main Thread"<<endl;
}
if(thread[0]==NULL)
{
cout<<"Couldn't Create Thread:("<<endl;
exit(0);
}
if(thread[1]==NULL)
{
cout<<"Couldn't Create Thread:("<<endl;
CloseHandle(thread[0]);
exit(0);
}
WaitForMultipleObjects(2, thread, TRUE, INFINITE);
CloseHandle(thread[0]);
CloseHandle(thread[1]);
return 0;
}
The handle of a thread is signaled when the thread is terminated (refer CreateThread).
You are passing the address of a local variable in the function into your thread. By the time the thread gets around to running your function has probably exited main already. So the thread will try to access a variable that no longer exists on the stack so will be reading some random value which when you try to dereference it as a pointer will likely crash.
You main needs to wait. For a simple test just put in a Sleep(10000) or something before it exits. Obviously that's no use for a real program.
To summarize the comments: There are two ways you can pass data. Either directly inside the void pointer, because "void pointer" is an integral type and thus can represent integers (but it doesn't necessarily have the same width as int), or indirectly by passing an actual address of the thing you care about.
Method 1 (pass the value):
DWORD WINAPI Name(LPVOID lpParam)
{
intptr_t n = reinterpret_cast<intptr_t>(lpParam);
// ...
}
int main()
{
intptr_t a = 10;
thread1 = CreateThread(NULL, 0, Name, reinterpret_cast<void *>(a), 0, &threadID);
// ... ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
For this method, we use the integral type intptr_t, which has the same width as void *. We use reinterpret-casts to store and retrieve arbitrary integral values.
Method 2 (pass a pointer):
DWORD WINAPI Name(LPVOID lpParam)
{
T * p = static_cast<T *>(lpParam);
// ... use *p ...
}
int main()
{
T thing_I_care_about;
thread1 = CreateThread(NULL, 0, Name, &thing_I_care_about, 0, &threadID);
// ... ^^^^^^^^^^^^^^^^^^^
}
This is the more general method, but requires that thing_I_care_about remain alive, and it becomes a brittle shared state, so lifetime management and synchronisation become issues. Note that any object pointer is implicitly convertible to void *, so there's no need for the cast at the call site.
Finally, as others have commented, don't forget to join or detach your threads.
I'm using the method 'pthread_create' in my program, and get a segmentation fault INSIDE THIS METHOD.
What can possibly cause this? I'm calling this function with the correct arguments' types!
this is the code:
pthread_t* _daemon;
void* writer(void* arg){
// stuff that dont involve "arg"...
}
int initdevice(){
if(pthread_create(_daemon, NULL, &writer, NULL) != 0) //seg in this line
{
cerr << "system error\n";
return ERR_CODE;
}
return SUCCESS;
}
int main () {
initdevice();
return 0;
}
Note: I've tried to run it also without the '&' before the calling to writer in pthread_create, and also - we've tried sending to this method some void* argument instead of the last NULL argument.
Your probelem is here:
pthread_t* _daemon;
This should be:
pthread_t daemon;
Then change the call to pthread_create:
if(pthread_create(&daemon, NULL, &writer, NULL) != 0)
The idea is that pthread_create takes a pointer to an existing pthread_t object so that it can fill in the details. You can think of it as the C version of a constructor. Initially the pthread_t object is uninitialized this initializes it.
In addition your code is still probably not going to always work as you do not wait for the thread to finish. Make sure your main thread does not finish before all the children:
int main ()
{
initdevice();
pthread_join(daemon, NULL); // wait for the thread to exit first.
return 0;
}
you must allocate _daemon variable with new or malloc function, because you have use of a pointer. like bellow :
pthread_t* _daemon;
_daemon = new pthread_t;