如何从线程中获取数据？

Question

我在相关帖子上学到了how to send additional parameters to a thread，但现在我想知道我是否可以将数据（由线程处理）恢复回调用函数！

我正在编写一个程序，我需要使用一个不断将用户输入放入字符串变量的线程。问题是我不知道如何将字符串变量数据返回到main（）显示（图形）。所以（我更喜欢）获取用户输入和字符串显示是独立完成的（因为它们需要以不同的速率循环：比如......用户输入为30 fps，显示为16 fps）

我希望我很清楚

这是一个理想的问题情况（但不是我需要解决的问题）：

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!
}

请原谅我演示

中的语法错误

作为结论性问题：

如何获取由线程（使用循环）不断更新的字符串的当前内容返回main（），其中包含另一个循环，该循环使用当前（图形）连续更新屏幕（最新） ）字符串的内容？

Answer 1

线程间通信的一个合适模式是消息队列 - 您可以使用互斥锁，列表和条件变量实现一个 - 一个使用现成的变体。以下是您可以查看的一些实现：

• 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

然后，您可以将线程数据推送到队列中 - 以及队列中的主要pop数据。

---

编辑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类中 - 例如，在上面的代码中 - 如果抛出异常 - 你应该确保mutex被解锁。我将使用RAII更新示例，但SDL线程助手有许多更好的选择。 （注意：编辑4添加RAII - 所以现在当抛出异常时互斥锁被解锁）

---

编辑4：代码现在更安全 - 仍然确保你做错误检查 - 基本上：不要在C ++中使用SDL线程 - 使用boost :: thread或std :: thread。

Answer 2

我想你想要SDL_WaitThread。

  

void SDL_WaitThread(SDL_Thread *thread, int *status);

     

线程函数的返回码放在指向的区域中   状态，如果状态不是NULL。

让avg函数返回平均值。