多线程康威的生活游戏在C++偶尔搭便车？

为了练习，我已经在C 中实现了Conways的生活游戏，并使用并行处理处理了"世界"的更新。我正在使用SFML用于图形。

添加多线程肯定使其运行速度更快（至少在这台4核机上），但我注意到它有问题。如果我在Visual Studio 2017中以Debug配置运行它，它似乎开始很慢，但是在运行2秒后，它突然变得更快并且运行顺利。但是，如果我以Release配置运行它，则它的运行速度甚至比Debug更快，但是每半秒钟左右，它"挂接"或Stusters，并且不会像我预期的那样顺利运行。

什么可能导致这两个行为问题，我该如何解决？

gameoflife.cpp：

#include "GameOfLife.h"
#include <iostream>
#include <vector>
#include <math.h>
#include <thread>
#include <mutex>
#include <SFML/Graphics.hpp>
class GameOfLife
{
public:
    GameOfLife(int sizeX, int sizeY);
    uint8_t & getCell(int x, int y);
    sf::Vector2i get2D(int i);
    void doUpdate(int start, int end);
    virtual ~GameOfLife() = default;
    void update();
    std::vector<sf::Vector2i> getLiveCells();
private:
    std::vector<uint8_t> world;
};
std::mutex updateListLock;
std::vector<sf::Vector2i> pendingUpdates;
sf::Vector2i worldSize;
GameOfLife::GameOfLife(int sizeX, int sizeY)
{
    worldSize = sf::Vector2i(sizeX, sizeY);
    // initialize world to specified size, all starting as dead
    world = std::vector<uint8_t>(sizeX * sizeY, 0);
    // reserve space for worst case (every cell needs to be updated)
    pendingUpdates.reserve(sizeX * sizeY);
    // place a glider
    getCell(1, 3) = true;
    getCell(2, 4) = true;
    getCell(3, 2) = true;
    getCell(3, 3) = true;
    getCell(3, 4) = true;
    // place a glider at top-center
    int midX = std::floor(worldSize.x / 2);
    getCell(midX + 1, 3) = true;
    getCell(midX + 2, 4) = true;
    getCell(midX + 3, 2) = true;
    getCell(midX + 3, 3) = true;
    getCell(midX + 3, 4) = true;
}
uint8_t& GameOfLife::getCell(int x, int y)
{
    return world[y * worldSize.x + x];
}
sf::Vector2i GameOfLife::get2D(int index)
{
    int y = std::floor(index / worldSize.x);
    int x = index % worldSize.x;
    return sf::Vector2i(x, y);
}
// Update the cells from position start (inclusive) to position end (exclusive).
void GameOfLife::doUpdate(int start, int end)
{
    for (int i = start; i < end; i++)
    {
        auto pos = get2D(i);
        // # of alive neighbors
        int aliveCount = 0;
        // check all 8 surrounding neighbors
        for (int nX = -1; nX <= 1; nX++) // nX = -1, 0, 1
        {
            for (int nY = -1; nY <= 1; nY++) // nY = -1, 0, 1
            {
                // make sure to skip the current cell!
                if (nX == 0 && nY == 0)
                    continue;
                // wrap around to other side if neighbor would be outside world
                int newX = (nX + pos.x + worldSize.x) % worldSize.x;
                int newY = (nY + pos.y + worldSize.y) % worldSize.y;
                aliveCount += getCell(newX, newY);
            }
        }
        // Evaluate game rules on current cell
        switch (world[i]) // is current cell alive?
        {
        case true:
            if (aliveCount < 2 || aliveCount > 3)
            {
                std::lock_guard<std::mutex> lock(updateListLock);
                pendingUpdates.push_back(pos); // this cell will be toggled to dead
            }
            break;
        case false:
            if (aliveCount == 3)
            {
                std::lock_guard<std::mutex> lock(updateListLock);
                pendingUpdates.push_back(pos); // this cell will be toggled to alive
            }
            break;
        }
    }
}
void GameOfLife::update()
{
    unsigned maxThreads = std::thread::hardware_concurrency();
    // divide the grid into horizontal slices
    int chunkSize = (worldSize.x * worldSize.y) / maxThreads;
    // split the work into threads
    std::vector<std::thread> threads;
    for (int i = 0; i < maxThreads; i++)
    {
        int start = i * chunkSize;
        int end;
        if (i == maxThreads - 1) // if this is the last thread, endPos will be set to cover remaining "height"
            end = worldSize.x * worldSize.y;
        else
            end = (i + 1) * chunkSize;
        std::thread t([this, start, end] {
            this->doUpdate(start, end);
        });
        threads.push_back(std::move(t));
    }
    for (std::thread & t : threads) {
        if (t.joinable())
            t.join();
    }
    // apply updates to cell states
    for each (auto loc in pendingUpdates)
    {
        // toggle the dead/alive state of every cell with a pending update
        getCell(loc.x, loc.y) = !getCell(loc.x, loc.y);
    }
    // clear updates
    pendingUpdates.clear();
}
std::vector<sf::Vector2i> GameOfLife::getLiveCells()
{
    std::vector<sf::Vector2i> liveCells;
    liveCells.reserve(worldSize.x * worldSize.y); // reserve space for worst case (every cell is alive)
    for (int i = 0; i < worldSize.x * worldSize.y; i++) {
        auto pos = get2D(i);
        if (world[i])
            liveCells.push_back(sf::Vector2i(pos.x, pos.y));
    }
    return liveCells;
}