为什么这种音频代码循环使用如此多的 CPU/内存？

Question

void FilePlayer::setLooping(const bool newState, float startPos)
{
while (newState == true)
{
    float endPos = startPos + 4/audioTransportSource.getLengthInSeconds();

    float currentPos = audioTransportSource.getCurrentPosition()/audioTransportSource.getLengthInSeconds();

    if (currentPos == endPos || currentPos > endPos)
    {
        audioTransportSource.setPosition(startPos * audioTransportSource.getLengthInSeconds());
    }
}
}

这是用于循环播放任何音频文件 4 秒的代码，无论多长时间。单击循环按钮，newState 变量变为 true。我有另一个按钮将其设置为 false，但是，当我在应用程序中执行循环任务时，CPU/内存/能源影响通过屋顶并且应用程序变得无法使用，以至于我无法单击按钮结束循环.

谁能解释一下这是为什么？

Answer 1

您是否尝试过添加睡眠调用或确保返回主事件循环以处理按钮单击事件？

编辑：另外，您的 newState 变量是否应该通过引用（而不是 const）传递，以便您可以更改值以停止循环？

Edit2：一个非常基本/简单的线程示例：

文件播放器.h

#include <iostream>
#include <thread>
#include <chrono>
#include <atomic>
#include <mutex>

class 
{
public:
    /**
      * @brief Constructor
      */
    FilePlayer();

    /**
     * @brief Destructor
     */
    ~FilePlayer();

private:
    /**
     * @brief startThread Starts the thread
     */
    void startThread();

    /**
     * @brief stopThread Stops the thread
     */
    void stopThread();

    /**
     * @brief theLoop The threaded loop
     */
    void theLoop(float startPos);

    std::atomic<bool> running; //lock for thread control
    std::mutex mtxAudioTransportSource; //mutex lock for audioTransportSource access
    std::thread td;   

}

文件播放器.cpp

FilePlayer::FilePlayer()
{
    running.store(false);
}

FilePlayer::~FilePlayer()
{
    stopThreads();
}

void FilePlayer::startThreads()
{
    if(running.load()){
        //The thread is alread running, either call stopThreads before making a different one
        //or error out (I just put return in)
        return;
    }
    running.store(true);
    td = thread(theLoop, 1.0);
}

void FilePlayer::stopThreads()
{
    running.store(false);
    if(td.joinable()){
        td.join();
    }
    delete td;
    td = NULL;
}

void FilePlayer::theLoop(float startPos)
{
    while (running.load())
    {
        mtxAudioTransportSource.lock(); //Since the audioTransportSource object is being used in multiple threads, 
                                        //you must use a mutex lock to make sure only 1 thread is accessing it at any time
                                        //you will need to add the lock/unlock to all threads using it.

                                        //It is often a good idea to lock, get what you need, and unlock as soon as possible so
                                        //the other thread isn't blocked for too long if it is waiting on it.

        float audioLength = audioTransportSource.getLengthInSeconds();
        float currentPos = audioTransportSource.getCurrentPosition()/audioLength;

        mtxAudioTransportSource.unlock();

        float endPos = startPos + 4/audioLength;

        if (currentPos >= endPos)
        {
            mtxAudioTransportSource.lock();
            audioTransportSource.setPosition(startPos * audioTransportSource.getLengthInSeconds());
            mtxAudioTransportSource.unlock();
        }

        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

所以我根本没有编译这个，所以可能会出现一些错误，但这只是一个让你工作的例子。如果有人有任何更正或优化，请随时说出来。关于线程，要记住的最重要的事情是在不使用某种锁的情况下永远不要访问共享变量。祝你的项目好运！