我学会了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() 中，该函数包含另一个循环，该循环使用当前(最新)(以图形方式)连续更新屏幕) 字符串的内容？

最佳答案

线程间通信的一个不错的模式是消息队列——你可以用一个互斥体、一个列表和一个条件变量来实现一个——一个使用现成的变体。以下是您可以查看的一些实现:

• 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

然后您可以让线程将数据推送到队列 - 并从队列中主弹出数据。

编辑 1:响应 OP 的编辑。

如果你有一个字符串必须由线程编辑，然后由 main 渲染，最好只使用 std::string，用互斥锁保护所有对它的访问，然后使用条件变量来发出信号字符串更改时的主线程。稍后将尝试为您编写一些示例代码。

编辑 2: promise 的示例代码:

#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。

关于c++ - 如何从线程中取回数据？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17797835/