Question

我试图减少计算时间。我试图同时运行两个函数并使用从第一个退出的函数返回值。

想象一下，我有这两个功能。（这些不是我的实际功能，它们只是对函数外观的简单表示）

int countUp (int n){

for(int i = 0; i < 100; i++){

if( i == n ) return i; 

}

return -1;
}

int countDown (int n){

for(int i = 200; i > 0; i--){

if( i == n ) return i; 

}
return -1;
}

主要是，我如何同时运行它们并获得首先退出的返回值？

Answer 1

以下是使用mutex和condition_variable在countUp，countDown和main之间建立对话的方法：

#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>

std::mutex mut;
std::condition_variable cv;
bool ready = false;

int
countUp(int n)
{
    for(int i = 0; i < 100; i++)
    {
        if( i == n )
            return i; 
    }
    return -1;
}

int
countDown(int n)
{
    for(int i = 200; i > 0; i--)
    {
        if( i == n )
            return i; 
    }
    return -1;
}

int
main()
{
    int result;
    constexpr int N = 200;
    std::thread t1{[&result, N]
                   {
                       int t = countUp(N);
                       std::unique_lock<std::mutex> lk(mut);
                       result = t;
                       ready = true;
                       cv.notify_one();
                   }};
    std::thread t2{[&result, N]
                   {
                       int t = countDown(N);
                       std::unique_lock<std::mutex> lk(mut);
                       result = t;
                       ready = true;
                       cv.notify_one();
                   }};
    {
    std::unique_lock<std::mutex> lk(mut);
    while (!ready)
        cv.wait(lk);
    }
    std::cout << result << '\n';
    t1.join();
    t2.join();
}

这里我使用了lambdas，所以我不会侵入性地修改countUp和countDown。如果可以修改这些功能，您可以直接将信号传输到它们中并避免使用lambdas。

我打印出结果后选择让main加入线程，以避免其中一个线程被破坏后mut和cv被访问的可能性通过main的atexit链。如果您可以证明这种访问不会发生，那么您可以.detach()线程而不是.join()，从而消除了main等待较慢thread的需要。 } 完成。这可以通过countUp，countDown和main共享互斥锁和condition_variable与shared_ptr的所有权来完成（例如）。

如果它对你的逻辑有些重要，你甚至可以阻止较慢的线程更新结果：

                   if (!ready)
                       result = t;

Answer 2

使用期货可能的C ++ 11解决方案。

#include <iostream>       // std::cout
#include <future>         // std::async, std::future
#include <chrono>         // std::chrono::milliseconds

int countUp (int n) {
for(int i = 0; i < 100; i++) {
    if( i == n ) return i; 
}
return -1;
}

int countDown (int n){
for(int i = 200; i > 0; i--){
if( i == n )
    return i; 
}
return -1;
}

int main ()
{
  std::future<int> futUp = std::async (std::launch::async, countUp, 50); 
  std::future<int> futDown = std::async (std::launch::async, countDown, 50); 

  std::chrono::microseconds span (1); // or even std::chrono::nanoseconds for better accuracy
  do
  {
    if (futUp.wait_for(span) != std::future_status::timeout)
    {
        std::cout << "CountUp finished first with result = " << futUp.get() << std::endl;
        break;   
    }
    if (futDown.wait_for(span) != std::future_status::timeout)
    {
        std::cout << "CountDown finished first with result = " << futDown.get() << std::endl;
        break;   
    }
  } while (true);

  return 0;
}

Answer 3

解决方案1：使用2台计算机并在每台计算机中运行一项功能。解决方案2：使用此类似的东西......

int function( int n )
{
  for (int i = 0; i < 200; i++) {
  if (i <= 100) {
    if( i == n)
      return i;
  }
  else {
    if(200 - i == n)
      return 200 -i;
  }    
 }

  return -1;
}

同时运行两个函数c ++

3 个答案: