自学教程：C++ CreateWaitableTimer函数代码示例

unsigned __stdcall ManageThread( void* Param ){    HANDLE hGlobal = CreateWaitableTimer( NULL, FALSE, L"ZZVBN-ARARA-12" );		//Global DB update timer    HANDLE hLocal = CreateWaitableTimer( NULL, FALSE, L"ZZVBN-ARARA-36" );		//Local DB update timer    //---------------------------------------------------------    LARGE_INTEGER liGlobalUpd;    LARGE_INTEGER liLocalUpd;    const int nTimeUnits = 10000000;    liGlobalUpd.QuadPart = -( 60/*1 hour*/ * nTimeUnits );    liLocalUpd.QuadPart = -( 10/*5 minutes*/ * nTimeUnits );    //---------------------------------------------------------    //set timers here, for global and local updates    SetWaitableTimer( hGlobal, &liGlobalUpd, 60/*1 hour*/ * 1000, NULL, NULL, FALSE );    SetWaitableTimer( hLocal, &liLocalUpd, 10/*5 minutes*/ *1000, NULL, NULL, FALSE );    //---------------------------------------------------------    while( true )    {        //capture critical section and free it every 5 minutes, so Local Update Thread can update values        EnterCriticalSection( &csUpdater );        bInitiated = true;        WaitForSingleObject( hLocal, INFINITE );        LeaveCriticalSection( &csUpdater );        Sleep( 200 );    }    return 0;}

COverlayRenderer::COverlayRenderer(CLibBlurayWrapper* pLib) :  m_pLib(pLib),  m_pD3DDevice(NULL){  m_pPlanes[BD_OVERLAY_PG] = NULL;  m_pPlanes[BD_OVERLAY_IG] = NULL;    m_pPlanesBackbuffer[BD_OVERLAY_PG] = NULL;  m_pPlanesBackbuffer[BD_OVERLAY_IG] = NULL;  m_pARGBTextures[BD_OVERLAY_PG] = NULL;  m_pARGBTextures[BD_OVERLAY_IG] = NULL;  m_overlayType[BD_OVERLAY_PG] = NONE;  m_overlayType[BD_OVERLAY_IG] = NONE;  ZeroMemory((void*)&m_ARGBBuffer, sizeof(BD_ARGB_BUFFER_EX));  m_hStopThreadEvent = CreateEvent(0, TRUE, FALSE, 0);  m_hNewOverlayAvailable = CreateEvent(0, TRUE, FALSE, 0);  m_hThread = CreateThread(0, 0, COverlayRenderer::ScheduleThreadEntryPoint, (LPVOID)this, 0, NULL);  m_hOverlayTimerIG = CreateWaitableTimer(NULL, false, NULL);  m_hOverlayTimerPG = CreateWaitableTimer(NULL, false, NULL);}

void start_benchmark(struct benchmark_st * st){  memset(st, 0, sizeof(*st));#ifndef _WIN32  st->old_handler = signal (SIGALRM, alarm_handler);#endif  gettime (&st->start);  benchmark_must_finish = 0;#if defined(_WIN32)  st->wtimer = CreateWaitableTimer (NULL, TRUE, NULL);  if (st->wtimer == NULL)    {      fprintf (stderr, "error: CreateWaitableTimer %u/n", GetLastError ());      exit(1);    }  st->wthread = CreateThread (NULL, 0, alarm_handler, &st->wtimer, 0, NULL);  if (st->wthread == NULL)    {      fprintf (stderr, "error: CreateThread %u/n", GetLastError ());      exit(1);    }  st->alarm_timeout.QuadPart = (BSECS) * 10000000;  if (SetWaitableTimer (st->wtimer, &st->alarm_timeout, 0, NULL, NULL, FALSE) == 0)    {      fprintf (stderr, "error: SetWaitableTimer %u/n", GetLastError ());      exit(1);    }#else  alarm (BSECS);#endif  }

void TRI_usleep(unsigned long waitTime) {  int result;  HANDLE hTimer = NULL;    // stores the handle of the timer object  LARGE_INTEGER wTime;    // essentially a 64bit number  wTime.QuadPart = waitTime * 10; // *10 to change to microseconds  wTime.QuadPart = -wTime.QuadPart;  // negative indicates relative time elapsed,     // Create an unnamed waitable timer.  hTimer = CreateWaitableTimer(NULL, 1, NULL);  if (hTimer == NULL) {    // no much we can do at this low level    return;  }   if (GetLastError() == ERROR_ALREADY_EXISTS) {    abort();  }  // Set timer to wait for indicated micro seconds.  if (!SetWaitableTimer(hTimer, &wTime, 0, NULL, NULL, 0)) {    // no much we can do at this low level    return;  }  // Wait for the timer   result = WaitForSingleObject(hTimer, INFINITE);  if (result != WAIT_OBJECT_0) {    abort();  }    CloseHandle(hTimer);  // todo: go through what the result is e.g. WAIT_OBJECT_0  return;}      

/* procedure to poll the event queue for timer events, run by the clock   thread; on a timer event, call "send_interrupt()" to run the system thread's   clock handler routine */DWORD WINAPI clock_poll(LPVOID arg) {#ifdef WINCE  for(;;) {	  Sleep(PERIOD/1000); /* sleep requires time in milliseconds */  send_interrupt(CLOCK_INTERRUPT_TYPE, NULL);  }#else  LARGE_INTEGER i;  HANDLE timer;   /* HANDLE thread = GetCurrentThread(); */  char name[64];  sprintf(name, "timer %d", pid);  timer = CreateWaitableTimer(NULL, TRUE, name);  assert(timer != NULL);  for (;;) {    i.QuadPart = -PERIOD*10; /* NT timer values are in hundreds of nanoseconds */    AbortOnError(SetWaitableTimer(timer, &i, 0, NULL, NULL, FALSE));    if (WaitForSingleObject(timer, INFINITE) == WAIT_OBJECT_0) {      if (DEBUG)	kprintf("CLK: clock tick./n");      send_interrupt(CLOCK_INTERRUPT_TYPE, NULL);    }  }#endif  /* never reached */  return 0;}

void asio_event_subscribe(asio_event_t* ev){  if((ev == NULL) ||    (ev->flags == ASIO_DISPOSABLE) ||    (ev->flags == ASIO_DESTROYED))    return;  asio_backend_t* b = asio_get_backend();  if(ev->noisy)    asio_noisy_add();  if((ev->flags & ASIO_TIMER) != 0)  {    // Need to start a timer.    // We can create it here but not start it. That must be done in the    // background thread because that's where we want the fire APC to happen.    // ev->data is initially the time (in nsec) and ends up as the handle.    ev->timer = CreateWaitableTimer(NULL, FALSE, NULL);    send_request(ev, ASIO_SET_TIMER);  } else if((ev->flags & ASIO_SIGNAL) != 0) {    if(ev->nsec < MAX_SIGNAL)      send_request(ev, ASIO_SET_SIGNAL);  } else if(ev->fd == 0) {    // Need to subscribe to stdin    send_request(ev, ASIO_STDIN_NOTIFY);  }}

bool WTimer::Create(LPSECURITY_ATTRIBUTES lpTimerAttributes, 					BOOL bManualReset, LPCTSTR lpTimerName){	Close();	m_Timer = CreateWaitableTimer(lpTimerAttributes, bManualReset, lpTimerName);	return(m_Timer != NULL);}

void usleep(__int64 waitTime) {     if (waitTime > 0)    {        if (waitTime > 100)        {            // use a waitable timer for larger intervals > 0.1ms            HANDLE timer;             LARGE_INTEGER ft;             ft.QuadPart = -(10*waitTime); // Convert to 100 nanosecond interval, negative value indicates relative time            timer = CreateWaitableTimer(NULL, TRUE, NULL);             SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);             WaitForSingleObject(timer, INFINITE);             CloseHandle(timer);         }        else        {            // use a polling loop for short intervals <= 100ms            LARGE_INTEGER perfCnt, start, now;            __int64 elapsed;             QueryPerformanceFrequency(&perfCnt);            QueryPerformanceCounter(&start);            do {                QueryPerformanceCounter((LARGE_INTEGER*) &now);                elapsed = (__int64)((now.QuadPart - start.QuadPart) / (float)perfCnt.QuadPart * 1000 * 1000);            } while ( elapsed < waitTime );        }    }}

  /**   * @brief Simple representation of the rt library nanosleep function.   */  int ros_nanosleep(const uint32_t &sec, const uint32_t &nsec)  {#if defined(WIN32)    HANDLE timer = NULL;    LARGE_INTEGER sleepTime;    sleepTime.QuadPart = -      static_cast<int64_t>(sec)*10000000LL -      static_cast<int64_t>(nsec) / 100LL;    timer = CreateWaitableTimer(NULL, TRUE, NULL);    if (timer == NULL)      {        return -1;      }    if (!SetWaitableTimer (timer, &sleepTime, 0, NULL, NULL, 0))      {        return -1;      }    if (WaitForSingleObject (timer, INFINITE) != WAIT_OBJECT_0)      {        return -1;      }    return 0;#else    timespec req = { sec, nsec };    return nanosleep(&req, NULL);#endif  }

/* * Custom code called right after loading the plugin. Returns 0 on success, 1 on failure. * If the function returns 1 on failure, the plugin will be unloaded again. */int ts3plugin_init() {	// Create the command mutex	hMutex = CreateMutex(NULL, FALSE, NULL);	// Create the PTT delay timer	hPttDelayTimer = CreateWaitableTimer(NULL, FALSE, NULL);	// Find and open the settings database	char db[MAX_PATH];	ts3Functions.getConfigPath(db, MAX_PATH);	_strcat(db, MAX_PATH, "settings.db");	ts3Settings.OpenDatabase(db);	// Find the error sound and info icon	SetErrorSound();	SetInfoIcon();	// Start the plugin threads	pluginRunning = true;	hMailslotThread = CreateThread(NULL, (SIZE_T)NULL, MailslotThread, 0, 0, NULL);	if(hMailslotThread==NULL)	{		ts3Functions.logMessage("Failed to start threads, unloading plugin", LogLevel_ERROR, "NiftyKb Plugin", 0);		return 1;	}	/* Initialize return codes array for requestClientMove */	memset(requestClientMoveReturnCodes, 0, REQUESTCLIENTMOVERETURNCODES_SLOTS * RETURNCODE_BUFSIZE);    return 0;  /* 0 = success, 1 = failure */}

int main(int argc, char *argv[]){	HANDLE hThread;	DWORD IDThread;	LARGE_INTEGER  due;	ZeroMemory(&due, sizeof(LARGE_INTEGER));	due.QuadPart = -20000000;   // 2 - секунды перед стартом таймера	hTimer = CreateWaitableTimer(NULL, FALSE, L"MyTimer");	if (hTimer == NULL) {		cout << "error CreateWaitableTimer" << endl;		return GetLastError();	}	if (!SetWaitableTimer(hTimer, &due, 1000, NULL, NULL, 0)) {  // дальше повтор с интервалов 1 -сек		cout << "error SetWaitableTimer" << endl;		return GetLastError();	}	hThread = CreateThread(NULL, 0, Thread, NULL, 0, &IDThread);	if (hThread == NULL)		return GetLastError();	while (!GetAsyncKeyState(VK_ESCAPE)); // чтобы не завершилась приложение пускай ждёт ESC	aborts = FALSE;      // пускаем сброс цикла в поток для завершения	CloseHandle(hThread);	CancelWaitableTimer(hTimer);	CloseHandle(hTimer);	return 0;}

HANDLE timer_start(int usec){  timeBeginPeriod(1);    hTimer = CreateWaitableTimer(NULL, FALSE, NULL);  if(hTimer)  {    LARGE_INTEGER li = { .QuadPart = -(usec*10) };    if(!SetWaitableTimer(hTimer, &li, usec / 1000, NULL, NULL, FALSE))    {      fprintf(stderr, "SetWaitableTimer failed./n");      hTimer = NULL;    }  }  else  {    fprintf(stderr, "CreateWaitableTimer failed./n");  }    if(!hTimer)  {    timeEndPeriod(0);  }  return hTimer;}

void usleep(DWORD waitTime){	if (waitTime >= 1000)	{		// Don't do long busy-waits.		// However much it seems like the QPC code would be more accurate,		// you can and probably will lose your time slice at any point during the wait,		// so we might as well voluntarily give up the CPU with a WaitForSingleObject.		HANDLE timer;		LARGE_INTEGER dueTime;		dueTime.QuadPart = -10 * (LONGLONG)waitTime;		timer = CreateWaitableTimer(NULL, TRUE, NULL);		SetWaitableTimer(timer, &dueTime, 0, NULL, NULL, 0);		WaitForSingleObject(timer, INFINITE);		CloseHandle(timer);		return;	}    LARGE_INTEGER perf_cnt, start, now;    QueryPerformanceFrequency(&perf_cnt);    QueryPerformanceCounter(&start);    do {        QueryPerformanceCounter((LARGE_INTEGER*) &now);    } while ((now.QuadPart - start.QuadPart) / (float)perf_cnt.QuadPart * 1000 * 1000 < waitTime);}

int freespace_private_discoveryThreadInit() {    HANDLE thread;    if (freespace_instance_->window_ != NULL) {        return FREESPACE_ERROR_BUSY;    }    // Create the timer used to indicated device rescan is required.    freespace_instance_->discoveryEvent_ = CreateWaitableTimer(NULL, TRUE, NULL);    if (freespace_instance_->discoveryEvent_ == NULL) {        return FREESPACE_ERROR_UNEXPECTED;    }    // Need to scan a first time.    freespace_instance_->needToRescanDevicesFlag_ = TRUE;    // Create the hidden window    freespace_instance_->discoveryTheadStatus_ = FREESPACE_SUCCESS;    thread = CreateThread(NULL, 0, discoveryWindow, NULL, 0, NULL);    if (thread == NULL) {        freespace_instance_->discoveryTheadStatus_ = FREESPACE_ERROR_COULD_NOT_CREATE_THREAD;        return FREESPACE_ERROR_COULD_NOT_CREATE_THREAD;    }    return FREESPACE_SUCCESS;}

    void    Delay::waitNsec(uint64_t nsec)    {      // POSIX.#if defined(DUNE_SYS_HAS_CLOCK_NANOSLEEP) || defined(DUNE_SYS_HAS_NANOSLEEP)      timespec ts;      ts.tv_sec = nsec / c_nsec_per_sec;      ts.tv_nsec = nsec - (ts.tv_sec * c_nsec_per_sec);#  if defined(DUNE_SYS_HAS_CLOCK_NANOSLEEP)      clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, 0);#  else      nanosleep(&ts, 0);#  endif      // Microsoft Windows.#elif defined(DUNE_SYS_HAS_CREATE_WAITABLE_TIMER)      HANDLE t = CreateWaitableTimer(0, TRUE, 0);      LARGE_INTEGER dl;      dl.QuadPart = (uint64_t)nsec / 100;      // Negative value means relative time.      dl.QuadPart *= -1;      SetWaitableTimer(t, &dl, 0, 0, 0, 0);      WaitForSingleObject(t, INFINITE);      CloseHandle(t);      // Unsupported system.#else#  error Delay::waitNsec() is not yet implemented in this system#endif    }

//设置好相关参数(上传文件的FTP信息，上传文件的时间设置)之后，开始执行设置的定时任务BOOL FtpConnecter::startUploadTask(){	SECURITY_ATTRIBUTES sa;	sa.nLength = sizeof(SECURITY_ATTRIBUTES);	sa.bInheritHandle = FALSE;	sa.lpSecurityDescriptor = NULL;	DWORD id;	//设置FTP信息	m_FtpInfo._hWaitableTimer = CreateWaitableTimer(&sa, FALSE, NULL);	if (m_FtpInfo._hWaitableTimer == NULL)		return FALSE;	m_FtpInfo._strFolderPath = getRemoteFolderPath();	m_hWorkThread = CreateThread(&sa, 0, UploadeFile, (LPVOID)&m_FtpInfo, 0, &id);	if (m_hWorkThread == NULL)	{		CString strErr = GlobalFunc::formatErrorCode(GetLastError());		strErr = _T("启动上传任务失败，上传文件线程未启动") + strErr;		pushTrackInfo(strErr);		return FALSE;	}	SetWaitableTimer(m_FtpInfo._hWaitableTimer, 		&m_liBeginTime,		m_lTimePeriod,		NULL, NULL, TRUE);//支持唤醒计算机<TRUE>	//CloseHandle(m_FtpInfo._hWaitableTimer);//在本对象析构的时候才关闭这个句柄	return TRUE;}

int main(){	HANDLE hTimer = NULL;	LARGE_INTEGER liDueTime;    // рт100дицКн
C++ CreateWindow函数代码示例
C++ CreateVertexBuffer函数代码示例