How to get back data from a thread? - c++

Question

I learned how to send additional parameters to a thread on a related post, but now i would like to know if i can get back the data(processed by the thread) back into the calling function!
I am writing a program in which i need to use a thread that continuously puts user input into a string variable. The problem is that i don't know how to get the string variable data back to the main() where it is displayed (graphically). And so (i prefer that) the getting of user input and the Displaying of the string be done independently (since they need to be looped at different rates : say...30 fps for user input and 16 fps for display)
i hope i am clear
Here is an ideal problematic situation(but not one that i need a solution to):
typedef struct
{
int a,b;
}ThreadData;
int avg(void* data)
{
ThreadData* tdata=(ThreadData*)data;
int processed_average=(tdata->a+tdata->b)/2.0;
//this is what i want to send back to the main()
return 0;
}
void main()
{
int a=10,b=20;
SDL_Thread* mythread=SDL_CreateThread(avg,myThreadData);
cout<<"The average of a and b is "; //i dont know what to put here!
}
Forgive me for any syntax errors in my demo
As a conclusive question :
How to get the current contents of a string that is continuously updated by a thread (using a loop) back into the main() which contains another loop that continuously updates the screen (graphically) with the current(latest) contents of the string?

Answer 1

A decent pattern for inter thread communication is a message queue - you can implement one with a mutex, a list and a condition variable - one use an off the shelf variant. Here are some implementations you can look at:
http://pocoproject.org/docs/Poco.NotificationQueue.html
http://gnodebian.blogspot.com.es/2013/07/a-thread-safe-asynchronous-queue-in-c11.html
http://docs.wxwidgets.org/trunk/classwx_message_queue_3_01_t_01_4.html
http://software.intel.com/sites/products/documentation/doclib/tbb_sa/help/reference/containers_overview/concurrent_queue_cls.htm
You would then have the thread push data onto the queue - and in main pop data from the queue.
Edit 1: in response to the OP's edit.
If you have a single string that has to be edited by the thread and then rendered by main it is best to just use std::string, protect all access to it with a mutex, and then use a condition variable to signal the main thread when the string changes. Will try and write some sample code for you in a minute.
Edit 2: Sample code as promised:
#include <SDL/SDL.h>
#include <SDL/SDL_thread.h>
#include <iostream>
#include <sstream>
#include <stdexcept>
class SdlMutex
{
public:
SdlMutex()
{
mutex = SDL_CreateMutex();
if ( !mutex ) throw std::runtime_error( "SDL_CreateMutex == NULL" );
}
~SdlMutex()
{
SDL_DestroyMutex( mutex );
}
void lock()
{
if( SDL_mutexP( mutex ) == -1 ) throw std::runtime_error( "SDL_mutexP == -1" );
// Note:
// -1 does not mean it was already locked - it means there was an error in locking -
// if it was locked it will just block - see SDL_mutexP(3)
}
void unlock()
{
if ( SDL_mutexV( mutex ) == -1 ) throw std::runtime_error( "SDL_mutexV == -1" );
}
SDL_mutex* underlying()
{
return mutex;
}
private:
SDL_mutex* mutex;
};
class SdlScopedLock
{
public:
SdlScopedLock( SdlMutex& mutex )
:
mutex( mutex )
{
mutex.lock();
}
~SdlScopedLock()
{
try
{
this->unlock();
}
catch( const std::exception& e )
{
// Destructors should never throw ...
std::cerr << "SdlScopedLock::~SdlScopedLock - caught : " << e.what() << std::endl;
}
}
void unlock()
{
mutex.unlock();
}
private:
SdlMutex& mutex;
};
class ThreadData
{
public:
ThreadData()
:
dataReady( false ),
done( false )
{
condition = SDL_CreateCond();
}
~ThreadData()
{
SDL_DestroyCond( condition );
}
// Using stringstream so I can just shift on integers...
std::stringstream data;
bool dataReady;
bool done;
SdlMutex mutex;
SDL_cond* condition;
};
int threadFunction( void* data )
{
try
{
ThreadData* threadData = static_cast< ThreadData* >( data );
for ( size_t i = 0; i < 100; i++ )
{
{
SdlScopedLock lock( threadData->mutex );
// Everything in this scope is now syncronized with the mutex
if ( i != 0 ) threadData->data << ", ";
threadData->data << i;
threadData->dataReady = true;
} // threadData->mutex is automatically unlocked here
// Its important to note that condition should be signaled after mutex is unlocked
if ( SDL_CondSignal( threadData->condition ) == -1 ) throw std::runtime_error( "Failed to signal" );
}
{
SdlScopedLock lock( threadData->mutex );
threadData->done = true;
}
if ( SDL_CondSignal( threadData->condition ) == -1 ) throw std::runtime_error( "Failed to signal" );
return 0;
}
catch( const std::exception& e )
{
std::cerr << "Caught : " << e.what() << std::endl;
return 1;
}
}
int main()
{
ThreadData threadData;
SDL_Thread* thread = SDL_CreateThread( threadFunction, &threadData );
while ( true )
{
SdlScopedLock lock( threadData.mutex );
while ( threadData.dataReady == false && threadData.done == false )
{
// NOTE: must call condition wait with mutex already locked
if ( SDL_CondWait( threadData.condition, threadData.mutex.underlying() ) == -1 ) throw std::runtime_error( "Failed to wait" );
}
// once dataReady == true or threadData.done == true we get here
std::cout << "Got data = " << threadData.data.str() << std::endl;
threadData.data.str( "" );
threadData.dataReady = false;
if ( threadData.done )
{
std::cout << "child done - ending" << std::endl;
break;
}
}
int status = 99;
SDL_WaitThread( thread, &status );
std::cerr << "Thread completed with : " << status << std::endl;
}
Edit 3: And then the cage comes down...
You should probbably not use SDL thread support in C++, or atleast wrap it in some RAII classes - for example, in the above code - if an exception is throw - you should ensure mutex is unlocked. I will update sample with RAII, but there are many better options to SDL thread helpers. (NOTE: Edit 4 adds RAII - so now mutex is unlocked when an exception is thrown)
Edit 4: Code is now safer - still make sure you do error checks - and basically: don't use SDL threads in C++ - use boost::thread or std::thread.

Answer 2

I think you want SDL_WaitThread.
void SDL_WaitThread(SDL_Thread *thread, int *status);
The return code for the thread function is placed in the area pointed
to by status, if status is not NULL.
Have your avg function return the average.