c++ - 多线程崩溃

Question

我目前正在使用SDL2进行游戏，并且开始使用计时器，并且将回调函数设置为调用SDL_CreateTextureFromSurface的函数。然后，我在网上看到只能从主线程调用SDL_CreateTextureFromSurface，因此我建立了一个队列系统，其中计时器线程可以将其请求添加到队列中以调用SDL_CreateTextureFromSurface，主线程经过队列并实际调用它。当我尝试为计时器线程和主线程上的队列添加功能创建互斥体时，我的问题就出现了，它遍历队列并处理条目。

我为SDL_CreateTextureFromSurface进行了包装，以将条目添加到队列中。

multithread_protection.cpp(从计时器线程调用的函数):

#include "multithread_protection.h"
#include <SDL.h>


#include <mutex>

std::mutex mutex;

bool bQueueCurrentlyProcessing = false;
std::vector<function_t> queue;

SDL_Texture * SDLCALL Queue_SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface)
{
mutex.lock();

function_t func;
func.renderer = renderer;
func.surface = surface;
func.pOutput = 0;

if (queue.size() == 0)
{
    func.id = 0;
}
else if (queue.size() > 0)
{
    func.id = queue[queue.size() - 1].id + 1;
}

queue.push_back(func);

mutex.unlock();

while (true)
{
    mutex.lock();

    for (int i = 0; i < queue.size(); i++)
    {
        if (queue[i].id == func.id)
        {
            // This entry is validated as the one that we put in.

            if (queue[i].pOutput)
            {
                SDL_Texture *pOutputCopy = queue[i].pOutput;
                ////bQueueCurrentlyProcessing = true;
                ////queue[i].acknowledged_completed = true;
                //if (!pOutputCopy)
                //{
                //  int a;
                //  a = 5;
                //}

                return pOutputCopy;
                return 0;
            }

            i = 0;
        }
    }
    mutex.unlock();
}


}

multithread_protection.h:

struct function_t
{
SDL_Renderer * renderer;
SDL_Surface * surface;
unsigned int id;

SDL_Texture *pOutput;
bool acknowledged_completed = false;
};

extern bool bQueueCurrentlyProcessing;
extern std::vector<function_t> queue;

extern std::mutex mutex;

SDL_Texture * SDLCALL Queue_SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface);

render.cpp(主线程):

void HandleMultithreadedFunctionQueue()
{
mutex.lock();

//bQueueCurrentlyProcessing = true;
for (int i = 0; i < queue.size(); i++)
{
    if (queue[i].pOutput == 0) // This entry hasn't been processed yet.
    {
        queue[i].pOutput = SDL_CreateTextureFromSurface(queue[i].renderer, queue[i].surface);
    }
    if (queue[i].acknowledged_completed)
    {
        //queue.erase(queue.begin() + i); // Erase entry from queue since it finished, and we don't need it anymore.
    }
}
//bQueueCurrentlyProcessing = false;

mutex.unlock();
}

互斥锁不断使程序崩溃，有时会导致奇怪的阻塞。如果有人可以告诉我如何更好地处理这种多线程情况，那就太好了。谢谢!

编辑:
我尝试使用std::lock_guard，std::unique_lock和std::condition_variable，但遗憾的是没有运气。也许我在我的情况下使用不正确？有人可以给我一些在我的情况下如何使用它们的示例吗？谢谢。

Answer 1

使用全局变量和手动互斥锁锁定/解锁是解决各种线程问题的坚实基础。例如，在return pOutputCopy;上，锁定的互斥锁未解锁，这在同一线程再次将其锁定时会导致挂起和 undefined 的行为。至少使用::std::lock_guard处理互斥锁。