C++ C++；性能优化的分离函数

我想将函数的两个部分分开，以加快速度。在每两个独立的部分中，都有我想稍后使用的数据（在

//执行其他操作。

部分中）

我想到了

std:：thread

，但它似乎很慢，因为它需要太多的时间来设置。由于一个建议，我尝试了

std:：async

，它比

std:：thread

要好，但仍然比原始代码慢（没有线程，只是调用函数）

示例代码：

Variables
    INT a, INT b

Part1
    a = 4 + 5
End of Part1

Part2
    b = 2 + 6
End of Part2

Main
    Loop (endless)
        call Part1
        call Part2
        print (a - b)
        call Loop
    End of Loop

End of Main

当然，这两个部分有很多事情要做，这只是一个例子

我想知道我是否可以重置它们或再次“使其可接合”。你有什么解决办法吗

std:：thread

是可移动的，因此您可以在调用

join（）

后简单地“重新分配”它们：

t1 = std::thread{ThreadFunc1};
t2 = std::thread{ThreadFunc2};

---

或者，您也可以完全不加入线程，而是以稍微不同的方式设计线程函数，并使用某种同步方法。例如，类似的东西：

std::mutex m1;
std::condition_variable cv1;
std::atomic<bool> stop1;

void ThreadFunc1() {
    while(!stop1) {
        {
            std::unique_lock<std::mutex> lk(m1);
            cv1.wait(lk);
        }
        // Do work ...
        cv1.notify_one();
    }
}

int main() {
    std::thread t1{ThreadFunc1};

    while(true) {
       // Trigger thread to do work
       cv1.notify_one();

       // Wait for thread to get it's work done
       {
           std::unique_lock<std::mutex> lk(m1);
           cv1.wait(lk);
       }
    }
}

std:：mutexm1； std：：条件变量cv1； std：：原子stop1； void ThreadFunc1（）{ 而（！stop1）{ { std：：唯一锁lk（m1）； cv1.等待（lk）； } //做工作。。。 cv1.通知_one（）； } } int main（）{ std：：线程t1{ThreadFunc1}； while（true）{ //触发线程进行工作 cv1.通知_one（）； //等待线程完成它的工作 { std：：唯一锁lk（m1）； cv1.等待（lk）； } } } 我想知道我是否可以重置它们或再次“使其可接合”。你有什么解决办法吗

std:：thread

是可移动的，因此您可以在调用

join（）

后简单地“重新分配”它们：

t1 = std::thread{ThreadFunc1};
t2 = std::thread{ThreadFunc2};

---

或者，您也可以完全不加入线程，而是以稍微不同的方式设计线程函数，并使用某种同步方法。例如，类似的东西：

std::mutex m1;
std::condition_variable cv1;
std::atomic<bool> stop1;

void ThreadFunc1() {
    while(!stop1) {
        {
            std::unique_lock<std::mutex> lk(m1);
            cv1.wait(lk);
        }
        // Do work ...
        cv1.notify_one();
    }
}

int main() {
    std::thread t1{ThreadFunc1};

    while(true) {
       // Trigger thread to do work
       cv1.notify_one();

       // Wait for thread to get it's work done
       {
           std::unique_lock<std::mutex> lk(m1);
           cv1.wait(lk);
       }
    }
}

std:：mutexm1； std：：条件变量cv1； std：：原子stop1； void ThreadFunc1（）{ 而（！stop1）{ { std：：唯一锁lk（m1）； cv1.等待（lk）； } //做工作。。。 cv1.通知_one（）； } } int main（）{ std：：线程t1{ThreadFunc1}； while（true）{ //触发线程进行工作 cv1.通知_one（）； //等待线程完成它的工作 { std：：唯一锁lk（m1）； cv1.等待（lk）； } } }

---

您是否询问如何重新启动这两个线程？是否希望在后续迭代中重新启动线程？直到螺纹完成为止。如果你想在循环中做一些事情，除了等待你的线程，那么你需要一些其他的方式来表示线程已经完成（例如你轮询的一个线程）。或者使用类似的方法。你不能死两次。纳吉达尼：请阅读关于条件变量的教程。对于这类事情，它们是一种可能的工具。基本上，有工作线程，也有管理线程（main）。工作线程处于等待状态（等待条件变量）。当管理器线程创建作业（由工作线程完成）时，它会向条件变量发送信号。然后系统唤醒其中一个工作线程，该线程执行该任务。当它完成时，它可能会发出另一个condvar信号，让管理器线程知道。然后它通过第一个condvar等待另一个作业。您是否询问如何重新启动这两个线程？是否希望线程在后续迭代中重新启动？直到螺纹完成为止。如果你想在循环中做一些事情，除了等待你的线程，那么你需要一些其他的方式来表示线程已经完成（例如你轮询的一个线程）。或者使用类似的方法。你不能死两次。纳吉达尼：请阅读关于条件变量的教程。对于这类事情，它们是一种可能的工具。基本上，有工作线程，也有管理线程（main）。工作线程处于等待状态（等待条件变量）。当管理器线程创建作业（由工作线程完成）时，它会向条件变量发送信号。然后系统唤醒其中一个工作线程，该线程执行该任务。当它完成时，它可能会发出另一个condvar信号，让管理器线程知道。然后它通过第一个condvar等待另一个作业。不幸的是，在我的情况下，重新分配占用了太多的时间。@NagyDani占用了太多的时间来考虑哪个特定约束？请在您的问题中详细说明。@NagyDani我已经用另一种机制更新了我的答案，使原始线程保持活动状态。不幸的是，重新分配占用了太多时间。@NagyDani花费了太多时间来考虑哪种特定约束？请在您的问题中详细说明。@NagyDani我已经用另一种机制更新了我的答案，使原始线程保持活力。