4

我在相关帖子上学习了如何向线程发送附加参数,但现在我想知道我是否可以将数据(由线程处理)返回到调用函数中!

我正在编写一个程序,在该程序中我需要使用一个将用户输入连续放入字符串变量的线程。问题是我不知道如何将字符串变量数据返回到显示它的 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() 中,该循环使用字符串的当前(最新)内容不断更新屏幕(以图形方式)?

4

2 回答 2

2

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

然后,您将让线程将数据推送到队列中 - 并在队列中的主弹出数据中。


编辑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。

于 2013-07-22T21:51:31.730 回答
1

我想你想要SDL_WaitThread

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

如果status不是,则线程函数的返回码放置在 status 指向的区域NULL

让你的avg函数返回平均值。

于 2013-07-22T21:39:19.803 回答