C++ thread::get_id方法代码示例

void DeterministicSchedule::join(std::thread& child) {
  auto sched = tls_sched;
  if (sched) {
    bool done = false;
    while (!done) {
      beforeSharedAccess();
      done = !sched->active_.count(child.get_id());
      if (done) {
        FOLLY_TEST_DSCHED_VLOG("joined " << std::hex << child.get_id());
      }
      afterSharedAccess();
    }
  }
  child.join();
}

 _R sync(_Function& work, const _Args&... args) {
     if (std::this_thread::get_id() != thread_.get_id()) {
         std::lock_guard<std::recursive_mutex> api_lock(api_mutex_);
         if (!is_running_) {
             throw std::runtime_error("Not running");
         }
         std::promise<_R> promise;
         {
             std::lock_guard<std::mutex> lock(works_mutex_);
             works_.push_back([&promise, &work, &args...]() {
                 try {
                     promise.set_value(work(args...));
                 }
                 catch (...) {
                     promise.set_exception(std::current_exception());
                 }
             });
             workable_.notify_all();
         }
         // Make sync
         return promise.get_future().get();
     }
     else {
         if (!is_running_) {
             throw std::runtime_error("Not running");
         }
         return work(args...);
     }
 }

		~async_message_loop()
		{
			if(thread.get_id() != std::thread::id()){
				DWORD id = ::GetThreadId(thread.native_handle());
				::PostThreadMessageW(id, WM_QUIT, 0, 0);
				thread.join();
			}
		}

		bool start_message_loop()
		{
			if(thread.get_id() != std::thread::id())
				return false;

			thread = std::thread([this](){
				if(::CoInitialize(nullptr))
					return;

				::quote::win32::message_loop([this](){
					if(queue.empty()){
						::Sleep(1);
						return;
					}

					std::shared_ptr<async_message> message;
					if(queue.try_pop(message)){
						switch(message->message){
						case async_message::message_type::create:
							{
								auto param = reinterpret_cast<creation_params*>(message->data.get());
								HWND hwnd = ::CreateWindowExW(
									param->exstyle,
									param->classname,
									param->title,
									param->style,
									param->x,
									param->y,
									param->w,
									param->h,
									param->hparent,
									nullptr,
									::GetModuleHandleW(nullptr),
									param->data);
								message->result = hwnd != nullptr;

								std::lock_guard<std::mutex> lock(message->mutex);
								message->cv.notify_one();
							}
							break;
						case async_message::message_type::destroy:
							{
								message->result = ::DestroyWindow(reinterpret_cast<HWND>(message->data.get())) != 0;

								std::lock_guard<std::mutex> lock(message->mutex);
								message->cv.notify_one();
							}
							break;
						}
					}
				});

				::CoUninitialize();
			});

			return true;
		}

// Helper function for cleaning up the thread in use
inline void cleanupThread(std::thread &t)
{
	if (t.joinable())
	{
		t.join();
	}
	else if (t.get_id() != std::thread::id())
	{
		t.detach();
	}
}

bool IsGPUThread()
{
  const SConfig& _CoreParameter = SConfig::GetInstance();
  if (_CoreParameter.bCPUThread)
  {
    return (s_emu_thread.joinable() && (s_emu_thread.get_id() == std::this_thread::get_id()));
  }
  else
  {
    return IsCPUThread();
  }
}

	void stop()
	{
		if (mThread.get_id() != std::thread::id())
		{
			mQuit.store(true);
			mThread.join();
		}

		alSourceRewind(mSource);
		alSourcei(mSource, AL_BUFFER, 0);
		mBufferIdx = 0;
	}

    static inline void
    set_affinity(std::thread &t, int n)
    {
        if(t.get_id() == std::thread::id())
            throw std::runtime_error("thread not running");

        cpu_set_t cpuset;
        CPU_ZERO(&cpuset); CPU_SET(n, &cpuset);

        auto pth = t.native_handle();
        if ( ::pthread_setaffinity_np(pth, sizeof(cpuset), &cpuset) != 0)
            throw std::runtime_error("pthread_setaffinity_np");
    }

bool IsGPUThread()
{
	const SCoreStartupParameter& _CoreParameter =
		SConfig::GetInstance().m_LocalCoreStartupParameter;
	if (_CoreParameter.bCPUThread)
	{
		return (g_EmuThread.joinable() && (g_EmuThread.get_id() == std::this_thread::get_id()));
	}
	else
	{
		return IsCPUThread();
	}
}

 void async(std::function<void(void)>&& work) {
     if (std::this_thread::get_id() != thread_.get_id()) {
         std::lock_guard<std::recursive_mutex> api_lock(api_mutex_);
         if (!is_running_) {
             return;
         }
         std::lock_guard<std::mutex> lock(works_mutex_);
         works_.push_back(work);
         workable_.notify_all();
     }
     else {
         if (!is_running_) {
             return;
         }
         std::lock_guard<std::mutex> lock(works_mutex_);
         works_.push_back(work);
         workable_.notify_all();
     }
 }

	~OpenALStream()
	{
		if (mThread.get_id() != std::thread::id())
		{
			/* Tell the thread to quit and wait for it to stop. */
			mQuit.store(true);
			mThread.join();
		}
		if (mSource)
		{
			/* Stop the source, remove the buffers, then put it back so it can
			 * be used again.
			 */
			alSourceRewind(mSource);
			alSourcei(mSource, AL_BUFFER, 0);
			mManager->mFreeSources.push_front(mSource);
		}
		/* Delete the buffers used for the queue. */
		alDeleteBuffers(static_cast<ALsizei>(mBuffers.size()), mBuffers.data());
	}

	void play()
	{
		/* If the source is already playing (thread exists and isn't stopped),
		 * don't do anything.
		 */
		if (mThread.get_id() != std::thread::id())
		{
			if (!mQuit.load())
				return;
			mThread.join();
		}

		/* Reset the source and clear any buffers that may be on it. */
		alSourceRewind(mSource);
		alSourcei(mSource, AL_BUFFER, 0);
		mBufferIdx = 0;
		mQuit.store(false);

		/* Start the background thread processing. */
		mThread = std::thread(std::mem_fn(&OpenALStream::backgroundProc), this);
	}

bool IsCPUThread()
{
	return (s_cpu_thread.joinable() ? (s_cpu_thread.get_id() == std::this_thread::get_id()) : !s_is_started);
}

bool IsCPUThread()
{
	return (g_cpu_thread.joinable() ? (g_cpu_thread.get_id() == std::this_thread::get_id()) : !g_bStarted);
}

 std::thread::id
 get_id() const
 {
     return t_.get_id();
 }