线程间通信的一个不错的模式是消息队列 - 您可以使用互斥体、列表和条件变量来实现一个 - 一个使用现成的变体。以下是您可以查看的一些实现：
然后，您将让线程将数据推送到队列中 - 并在队列中的主弹出数据中。
编辑1：响应OP的编辑。
如果您有一个必须由线程编辑然后由 main 渲染的字符串，最好只使用 std::string，使用互斥锁保护对其的所有访问，然后使用条件变量向主线程发出信号当字符串改变时。将在一分钟内尝试为您编写一些示例代码。
编辑2：承诺的示例代码：
#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;
}
编辑3：然后笼子下来了……
您可能不应该在 C++ 中使用 SDL 线程支持，或者至少将其包装在某些 RAII 类中 - 例如，在上面的代码中 - 如果抛出异常 - 您应该确保互斥锁已解锁。我将使用 RAII 更新示例，但 SDL 线程助手有许多更好的选择。（注意：Edit 4 添加了 RAII - 所以现在互斥锁在抛出异常时被解锁）
编辑 4：代码现在更安全 - 仍然确保您进行错误检查 - 基本上：不要在 C++ 中使用 SDL 线程 - 使用 boost::thread 或 std::thread。