问使用昂贵操作的线程减慢UI线程- Windows 10，C++

EN

#include "Renderer/Headers/Renderer.h"
#include "Shared/Headers/Timeline.h"
#include "Simulator/Simulator.h"

#include <iostream>
#include <Windows.h>


unsigned int __stdcall renderThread(void* timelinePtr);
unsigned int __stdcall simulateThread(void* timelinePtr);

int main() {
    Timeline timeline;

    HANDLE renderHandle = (HANDLE)_beginthreadex(0, 0, &renderThread, &timeline, 0, 0);
    if (renderHandle == 0) {
        std::cerr << "There was an error creating the render thread" << std::endl;
        return -1;
    }
    SetThreadPriority(renderHandle, THREAD_PRIORITY_HIGHEST);

    HANDLE simulateHandle = (HANDLE)_beginthreadex(0, 0, &simulateThread, &timeline, 0, 0);
    if (simulateHandle == 0) {
        std::cerr << "There was an error creating the simulate thread" << std::endl;
        return -1;
    }
    SetThreadPriority(simulateHandle, THREAD_PRIORITY_IDLE);

    WaitForSingleObject(renderHandle, INFINITE);
    WaitForSingleObject(simulateHandle, INFINITE);
    return 0;
}

unsigned int __stdcall renderThread(void* timelinePtr) {
    Timeline& timeline = *((Timeline*)timelinePtr);

    Renderer renderer = Renderer(timeline);
    renderer.run();
    return 0;
}

unsigned int __stdcall simulateThread(void* timelinePtr) {
    Timeline& timeline = *((Timeline*)timelinePtr);

    Simulator simulator(timeline);
    simulator.run();
    return 0;
}

// abbreviated
void Simulator::run() {
    while (true) {
        // abbreviated
        timeline->push(latestState);
    }
}
// abbreviated

#ifndef TIMELINE_H
#define TIMELINE_H

#include "WorldState.h"
#include <mutex>
#include <vector>

class Timeline {
public:
    Timeline();
    bool tryGetStateAtFrame(int frame, WorldState*& worldState);
    void push(WorldState* worldState);
private:

    // The concept of an Epoch was introduced to help reduce mutex conflicts, but right now since the threads are disconnected, there should be no mutex locks at all on the UI thread. However, every 1024 pushes onto the timeline, a new Epoch must be created. The amount of slowdown largely depends on how much memory the WorldState class takes. If I make WorldState small, there isn't a noticable hiccup, but when it is large, it becomes noticeable.  
    class Epoch {
    public:
        static const int MAX_SIZE = 1024;

        void push(WorldState* worldstate);
        int getSize();
        WorldState* getAt(int index);
    private:
        int size = 0;
        WorldState states[MAX_SIZE];
    };
    Epoch* pushEpoch;

    std::mutex lock;
    std::vector<Epoch*> epochs;
};

#endif // !TIMELINE_H

#include "../Headers/Timeline.h"

#include <iostream>

Timeline::Timeline() {
    pushEpoch = new Epoch();
}

bool Timeline::tryGetStateAtFrame(int frame, WorldState*& worldState) {
    if (!lock.try_lock()) {
        return false;
    }
    if (frame >= epochs.size() * Epoch::MAX_SIZE) {
        lock.unlock();
        return false;
    }
    worldState = epochs.at(frame / Epoch::MAX_SIZE)->getAt(frame % Epoch::MAX_SIZE);
    lock.unlock();
    return true;
}

void Timeline::push(WorldState* worldState) {
    pushEpoch->push(worldState);
    if (pushEpoch->getSize() == Epoch::MAX_SIZE) {
        lock.lock();
        epochs.push_back(pushEpoch);
        lock.unlock();
        pushEpoch = new Epoch();
    }
}

void Timeline::Epoch::push(WorldState* worldState) {
    if (this->size == this->MAX_SIZE) {
        throw std::out_of_range("Pushed too many items to Epoch without clearing");
    }
    this->states[this->size] = *worldState;
    this->size++;
}

int Timeline::Epoch::getSize() {
    return this->size;
}

WorldState* Timeline::Epoch::getAt(int index) {
    if (index >= this->size) {
        throw std::out_of_range("Tried accessing nonexistent element of epoch");
    }
    return &(this->states[index]);
}

// abbreviated
void Presenter::update() {
    camera->update();
    // timeline->tryGetStateAtFrame(Time::getFrames(), worldState); // Normally this would cause a potential mutex conflict, but for now I have it commented out. This is the only place that anything on the UI thread accesses timeline.
}
// abbreviated