C++ future::wait_for方法代码示例

  static bool IsReady(std::future<void>& future)
  {
#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6))
    return future.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
#else
    return future.wait_for(std::chrono::seconds(0));
#endif
  }

void GoApp::check_for_computed_move()
{
	//return;

	if (game_status != COMPUTER_THINKING) {
		return;
	}

	auto status = computed_move.wait_for(std::chrono::seconds(0));
	if (status == std::future_status::ready) {
		try {
			auto move = computed_move.get();
			state.do_move(move);

			// Are there any more moves possible?
			if (state.get_moves().empty()) {
				game_status = GAME_OVER;
			}
			else {
				next_player();
			}

		} catch (std::exception& error) {
			game_status = GAME_ERROR;
			error_string = error.what();
		}
	}
}

void StopHTTPServer()
{
    LogPrint(BCLog::HTTP, "Stopping HTTP server\n");
    if (workQueue) {
        LogPrint(BCLog::HTTP, "Waiting for HTTP worker threads to exit\n");
        workQueue->WaitExit();
        delete workQueue;
        workQueue = nullptr;
    }
    if (eventBase) {
        LogPrint(BCLog::HTTP, "Waiting for HTTP event thread to exit\n");
        // Give event loop a few seconds to exit (to send back last RPC responses), then break it
        // Before this was solved with event_base_loopexit, but that didn't work as expected in
        // at least libevent 2.0.21 and always introduced a delay. In libevent
        // master that appears to be solved, so in the future that solution
        // could be used again (if desirable).
        // (see discussion in https://github.com/bitcoin/bitcoin/pull/6990)
        if (threadResult.valid() && threadResult.wait_for(std::chrono::milliseconds(2000)) == std::future_status::timeout) {
            LogPrintf("HTTP event loop did not exit within allotted time, sending loopbreak\n");
            event_base_loopbreak(eventBase);
        }
        threadHTTP.join();
    }
    if (eventHTTP) {
        evhttp_free(eventHTTP);
        eventHTTP = 0;
    }
    if (eventBase) {
        event_base_free(eventBase);
        eventBase = 0;
    }
    LogPrint(BCLog::HTTP, "Stopped HTTP server\n");
}

void interruptible_wait(std::future<T>& uf)
{
	while (!this_thread_interrupt_flag.is_set())
	{
		if (uf.wait_for(lk, std::future_status::ready == std::chrono::milliseconds(1)))
			break;
	}
}

void test(std::future<void> fut)
{    
    switch (fut.wait_for(std::chrono::milliseconds(500)))
    {
        case std::future_status::ready: std::cout << "ready\n"; break;
        case std::future_status::deferred: std::cout << "deferred\n"; break;
        case std::future_status::timeout: std::cout << "timeout\n"; break;
    };
}

//----------------------------------------------------------------------//
void SoftServo::threadFunc(std::future<bool> shutdown,
			   SoftServo *const servo) // change this in the future to use a thread safe shared pipe reader/writer
{
  while (shutdown.wait_for(std::chrono::nanoseconds(0)) != 
	 std::future_status::ready)
    {
      servo->updateMove();
    }
}

static bool checkIfFinished(std::future<void>& match) {
    auto status = match.wait_for(std::chrono::seconds(0));
    if(status == std::future_status::timeout) {
        return false;
    }
    else if(status == std::future_status::ready) {
        return true;
    }
    else {
        return false;
    }
}

//----------------------------------------------------------------------//
void JoyStick::threadFunc(std::future<bool> shutdown,
			  const JoyStick *const js)
{
  while (shutdown.wait_for(std::chrono::nanoseconds(0)) != 
	 std::future_status::ready)
    {
      if (!js->readEvent())
	{
	  js->d_owner->handleReadError();
	}
    }
}

void AI::WaitForFuture(const std::future<void>& fut, bool bPondering)
{
	std::uint64_t timePerMove = GetTimePerMove();
	if(bPondering)
	{
		timePerMove /= 2;
	}

	// Wait until the thread finishes or it gets timed out
	if(fut.wait_for(std::chrono::nanoseconds(timePerMove)) == std::future_status::timeout)
	{
		// If the thread did not finish execution, signal the thread to exit, and wait till the thread exits.
	
		m_bStopMinimax = true;
		fut.wait();
		m_bStopMinimax = false;
	}
}

    void on_update(const UpdateEvent & e) override
    {
        // Around 60 fps
        if (fixedTimer.milliseconds().count() >= 16 && turret.fired)
        {
            float timestep_ms = fixedTimer.milliseconds().count() / 1000.f;
            turret.projectile.fixed_update(timestep_ms);
            std::cout << timestep_ms << std::endl;
            //std::cout << turret.projectile.p.position << std::endl;
            fixedTimer.reset();
        }

        cameraController.update(e.timestep_ms);
        time += e.timestep_ms;
        shaderMonitor.handle_recompile();

        // If a new mesh is ready, retrieve it
        if (pointerFuture.valid())
        {
            auto status = pointerFuture.wait_for(std::chrono::seconds(0));
            if (status != std::future_status::timeout)
            {
                auto m = pointerFuture.get();
                supershape = m;
                supershape.pose.position = {0, 2, -2};
                pointerFuture = {};
            }
        }

        // If we don't currently have a background task, begin working on the next mesh
        if (!pointerFuture.valid() && regeneratePointer)
        {
            pointerFuture = std::async([]() {
                return make_supershape_3d(16, ssM, ssN1, ssN2, ssN3);
            });
        }
    }

 bool is_ready(std::future<R> const& f) {
    return f.wait_for(std::chrono::microseconds(0)) == std::future_status::ready;
 }

bool waitForFuture(std::future<T>& f, std::chrono::seconds timeout = std::chrono::seconds{5})
{
  return f.wait_for(timeout) == std::future_status::ready;
}

bool is_ready(std::future<T>& f)
{
    return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
}

 inline void check_for_exception(std::future<T>& future) {
     if (future.valid() && future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
         future.get();
     }
 }

 /**
  * Check task for exceptions.
  *
  * If an exception happened in the task, re-throw it in this
  * thread. This will not do anything if there was no exception.
  */
 void check_for_exception() {
     if (m_future.valid() && m_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
         m_future.get();
     }
 }