C++ 11有没有提供微秒级别的定时器？

不是Sleep噢，是想要定时器，能设置回调的那种。微秒级别。

62 个解决方案

#1

有,不过估计要写驱动程序;

#2

About Multimedia Timers
Multimedia timer services allow applications to schedule timer events with the greatest resolution (or accuracy) possible for the hardware platform. These multimedia timer services allow you to schedule timer events at a higher resolution than other timer services.

These timer services are useful for applications that demand high-resolution timing. For example, a MIDI sequencer requires a high-resolution timer because it must maintain the pace of MIDI events within a resolution of 1 millisecond.

Applications that do not use high-resolution timing should use theSetTimer function instead of multimedia timer services. The timer services provided by SetTimer postWM_TIMER messages to a message queue, while the multimedia timer services call a callback function. Applications that want a waitable timer should use theCreateWaitableTimer function. 

 

#3

看能 不能用cpu心跳函数

#4

linux和windows都有
可以自行百度。
这个不是一个语言提供的。

#5

http://blog.csdn.net/fdsdfdsf/article/details/18144299
看看这篇博文。

#6

C++11 不能使用吧

#7

跟语言本身没有关系

#8

关键是硬件要支持

#9

boost::timer

#10

unix有个gettimeofday

#11

引用 楼主 iuruteiu 的回复:

不是Sleep噢，是想要定时器，能设置回调的那种。微秒级别。

C++11有chrono，可以提供高精度时间计算能力，最高支持精度比nanosecond还要少五个数量级！当然实际能达到多少是由平台决定的，以下示例假设steady_clock的period少于等于毫秒（通常都能达到，没有这个精度可换system_clock或high_resolution_clock试试）：

#include <stdafx.h>
#include <windows.h>
#include <iostream>
#include <chrono>
 
void fun( void )
{
    std::cout << "over!";
}
 
int _tmain(void)
{
    auto Start = std::chrono::steady_clock::now( );
    while( std::chrono::steady_clock::now( ) < Start + std::chrono::milliseconds( 1 ) )
    {
        std::cout << "1" << std::endl;
    }
    fun( );
    return 0;
}

#12

要的不是获取时间，不是sleep，而是要定时器，

我自己可以写一个微秒级的定时器，但不想自己写，想用现成的，不知道C++11有没有。

引用 11 楼 supermegaboy 的回复:

Quote: 引用 楼主 iuruteiu 的回复:

不是Sleep噢，是想要定时器，能设置回调的那种。微秒级别。

C++11有chrono，可以提供高精度时间计算能力，最高支持精度比nanosecond还要少五个数量级！当然实际能达到多少是由平台决定的，以下示例假设steady_clock的period少于等于毫秒（通常都能达到，没有这个精度可换system_clock或high_resolution_clock试试）：

#include <stdafx.h>
#include <windows.h>
#include <iostream>
#include <chrono>
 
void fun( void )
{
    std::cout << "over!";
}
 
int _tmain(void)
{
    auto Start = std::chrono::steady_clock::now( );
    while( std::chrono::steady_clock::now( ) < Start + std::chrono::milliseconds( 1 ) )
    {
        std::cout << "1" << std::endl;
    }
    fun( );
    return 0;
}

#13

现在的PC硬件，还有不支持微秒级别的精度？

估计有也是极极极少数部分吧。

引用 8 楼 alanmaths 的回复:

关键是硬件要支持

#14

我不需要高精度，我是可以允许大误差存在的。

我的要求，是微秒级别。高不高精度，没有关系。

而你给的是高精度的毫秒级别。

引用 5 楼 fdsdfdsf 的回复:

http://blog.csdn.net/fdsdfdsf/article/details/18144299
看看这篇博文。

#15

引用 12 楼 iuruteiu 的回复:

要的不是获取时间，不是sleep，而是要定时器，

我自己可以写一个微秒级的定时器，但不想自己写，想用现成的，不知道C++11有没有。

Quote: 引用 11 楼 supermegaboy 的回复:

Quote: 引用 楼主 iuruteiu 的回复:

不是Sleep噢，是想要定时器，能设置回调的那种。微秒级别。

C++11有chrono，可以提供高精度时间计算能力，最高支持精度比nanosecond还要少五个数量级！当然实际能达到多少是由平台决定的，以下示例假设steady_clock的period少于等于毫秒（通常都能达到，没有这个精度可换system_clock或high_resolution_clock试试）：

#include <stdafx.h>
#include <windows.h>
#include <iostream>
#include <chrono>
 
void fun( void )
{
    std::cout << "over!";
}
 
int _tmain(void)
{
    auto Start = std::chrono::steady_clock::now( );
    while( std::chrono::steady_clock::now( ) < Start + std::chrono::milliseconds( 1 ) )
    {
        std::cout << "1" << std::endl;
    }
    fun( );
    return 0;
}

我写的就是个定时器啊！用的就是C++11的chrono啊！以上代码没有获取时间，也不是sleep！

#16

楼上的，你那个只是延时，不是定时。

引用 15 楼 supermegaboy 的回复:

Quote: 引用 12 楼 iuruteiu 的回复:

要的不是获取时间，不是sleep，而是要定时器，

我自己可以写一个微秒级的定时器，但不想自己写，想用现成的，不知道C++11有没有。

Quote: 引用 11 楼 supermegaboy 的回复:

Quote: 引用 楼主 iuruteiu 的回复:

不是Sleep噢，是想要定时器，能设置回调的那种。微秒级别。

C++11有chrono，可以提供高精度时间计算能力，最高支持精度比nanosecond还要少五个数量级！当然实际能达到多少是由平台决定的，以下示例假设steady_clock的period少于等于毫秒（通常都能达到，没有这个精度可换system_clock或high_resolution_clock试试）：

#include <stdafx.h>
#include <windows.h>
#include <iostream>
#include <chrono>
 
void fun( void )
{
    std::cout << "over!";
}
 
int _tmain(void)
{
    auto Start = std::chrono::steady_clock::now( );
    while( std::chrono::steady_clock::now( ) < Start + std::chrono::milliseconds( 1 ) )
    {
        std::cout << "1" << std::endl;
    }
    fun( );
    return 0;
}

我写的就是个定时器啊！用的就是C++11的chrono啊！以上代码没有获取时间，也不是sleep！

#17

没有提供，还是自己动手，丰衣足食

#18

我要的不是精确，要的是微小。微秒级别的定时。

引用 2 楼 zhao4zhong1 的回复:

About Multimedia Timers
Multimedia timer services allow applications to schedule timer events with the greatest resolution (or accuracy) possible for the hardware platform. These multimedia timer services allow you to schedule timer events at a higher resolution than other timer services.

These timer services are useful for applications that demand high-resolution timing. For example, a MIDI sequencer requires a high-resolution timer because it must maintain the pace of MIDI events within a resolution of 1 millisecond.

Applications that do not use high-resolution timing should use theSetTimer function instead of multimedia timer services. The timer services provided by SetTimer postWM_TIMER messages to a message queue, while the multimedia timer services call a callback function. Applications that want a waitable timer should use theCreateWaitableTimer function. 

 

#19

用timed_mutex模拟的定时器， 参考一下。 

#include <iostream>       // std::cout
#include <chrono>         // std::chrono::milliseconds
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex
#include <string>

std::timed_mutex mtx;

void fireworks () {
  while (!mtx.try_lock_for(std::chrono::microseconds(200))) {
    std::cout << "*";
  }
  std::cout << std::endl;
  mtx.unlock();
}

int main ()
{
  mtx.lock();
  auto timer = std::thread(fireworks);
  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
  mtx.unlock();
  timer.join(); 
  return 0;
}

#20

我测试过了，microseconds在我的电脑上，实际上是1毫秒，不是1微秒。

在你们的电脑上，实际上应该也是1毫秒，不是1微秒。

因为我的电脑配置是超高的，估计你们的电脑，也不会是1微秒。

引用 19 楼 mujiok2003 的回复:

用timed_mutex模拟的定时器， 参考一下。 

#include <iostream>       // std::cout
#include <chrono>         // std::chrono::milliseconds
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex
#include <string>

std::timed_mutex mtx;

void fireworks () {
  while (!mtx.try_lock_for(std::chrono::microseconds(200))) {
    std::cout << "*";
  }
  std::cout << std::endl;
  mtx.unlock();
}

int main ()
{
  mtx.lock();
  auto timer = std::thread(fireworks);
  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
  mtx.unlock();
  timer.join(); 
  return 0;
}

#21

估计毫秒已经是最小级别了，不能再进入微秒级别了，估计是受限于线程的时间片吧。

#22

引用 20 楼 iuruteiu 的回复:

我测试过了，microseconds在我的电脑上，实际上是1毫秒，不是1微秒。

在你们的电脑上，实际上应该也是1毫秒，不是1微秒。

因为我的电脑配置是超高的，估计你们的电脑，也不会是1微秒。

Quote: 引用 19 楼 mujiok2003 的回复:

用timed_mutex模拟的定时器， 参考一下。 

#include <iostream>       // std::cout
#include <chrono>         // std::chrono::milliseconds
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex
#include <string>

std::timed_mutex mtx;

void fireworks () {
  while (!mtx.try_lock_for(std::chrono::microseconds(200))) {
    std::cout << "*";
  }
  std::cout << std::endl;
  mtx.unlock();
}

int main ()
{
  mtx.lock();
  auto timer = std::thread(fireworks);
  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
  mtx.unlock();
  timer.join(); 
  return 0;
}

精确度跟平台有关。 

#23

GetTickCount的精度≈15ms

#24

这个和语言没关系
除非是实时的操作系统，一般的操作系统即使单位用的微秒，分辨率也打不到那么高吧

#25

我说了，要求的不是精度。而是数量级了。

例如，我想定时1微秒，结果定时了5微秒，误差400%，也是可以接受的。

我要求的是数量级，能达到微秒级别。

引用 23 楼 zhao4zhong1 的回复:

GetTickCount的精度≈15ms

#26

引用 14 楼 iuruteiu 的回复:

我不需要高精度，我是可以允许大误差存在的。

我的要求，是微秒级别。高不高精度，没有关系。

而你给的是高精度的毫秒级别。

Quote: 引用 5 楼 fdsdfdsf 的回复:

http://blog.csdn.net/fdsdfdsf/article/details/18144299
看看这篇博文。

是让你看看回调的实现。
其次，Timer是OS提供的，没有跨平台的API。

#27

QueryPerformanceFrequency  QueryPerformanceCounter
获取计算器的值和获取CPU频率
如果获取计算器的值之差，精度取决你的CPU了

#28

uOS里大概有这种API

#29

引用 28 楼 daiweifeng 的回复:

uOS里大概有这种API

是uCOS

#30

1）C++ 可以写驱动程序，也可以写应用程序，
       所以C++，是可以实现us级别定时的。
       内核态程序，可以实现更小的时间间隔的定时。
       直接在硬件上实现的程序，可以实现更小的时间间隔的定时。
       某些实时操作系统，可以实现更小的时间间隔的定时。 
       这些都是可以用C++写的，可能操作系统就是C++写的。
       另外，几乎所有C代码，都可以一定程度的看作C++代码。
       只有需要严格区分C,C++的时候，才会分别称为 C   代码，C++代码。

2）用户级应用程序（X86等），不能实现毫秒以下级别的，定时精度，
      误差一定会，大于等于500us;实际上很多定时器误差大于15ms
     所以这个问题，不是C++的问题。
    而是具体软硬件环境的问题。

#31

2）X86等上的操作系统 如windows,linux 正常情况下，不能实现毫秒以下级别的，定时精度，
      误差一定会，大于等于500us;实际上很多定时器误差大于15ms
     所以这个问题，不是C++的问题。
    而是具体软硬件环境的问题。

#32

在一个多任务的OS上实现微秒定时器，意味着需要每秒100万次的中断。
大多数的OS上，调度用的时间片中断是每秒100次。
楼主你的要求高了10000倍。
你的问题一定有其它的解决方法。

#33

你所说的Sleep是windows的API，定时器的精度是和硬件、操作系统相关的，任何语言提供的定时器最后都是调用系统的API。

#34

void chronoTest()
{
chrono::duration d1(10);
chrono::duration<60>> d2(d1);
auto maxD1 = chrono::duration::max();
auto minD1 = chrono::duration::min();
const char* period = zhuanHuan::period>();
cout << d1.count() << period << '\n';
cout << d2.count() << zhuanHuan>() << '\n';
cout << "最大可表示：" << maxD1.count() << zhuanHuan() << '\n';
cout << "最小可表示：" << minD1.count() << zhuanHuan() << '\n';
auto d3=chrono::duration_cast(d1);
cout << d1.count() << period << "等于" << d3.count() << zhuanHuan() << '\n';
http://blog.sina.com.cn/s/blog_6113a8e50102vvuw.html
还与系统有关

#35

没

#36

#37

c++11是没有定时器的，boost下asio提供了async_timer，封装了不同平台的定时器，可以支持异步和回调。

#38

Win, Linux 又不是 RTOS,  用户态的程序不可能有这种精度.. 写驱动吧..

#39

这个应该是操作系统干的事，不应该是语言干的事吧？
windows和*nux都达不到吧？建议楼主用VxWorks吧！

#40

要定时器就要执行别的代码。你确定你的代码能在几微秒的时候内完成嘛。不然定时的托延，不是更是问题了,问题更大了。

#41

关注下

#42

这个不是语言问题，就算实时系统很多都无法做到。你可以看看VxWorks是否能提供这么高精度的定时器。
另外这么短的时间，你还必须保证你的代码足够短，不然定时器里执行超时又会影响精度。

#43

VxWorks 也没这精度,  它的精度也只到一个时钟中断, 一般是 1毫秒或者 10毫秒 ..

#44

神州飞船控制系统提供了。我猜。

#45

什么样的程序需要微秒级的精度，楼主说出来让我涨一下见识

#46

select

#47

这个要牵扯到操作系统级别的东西，linux系统在驱动层可以提供纳秒级别的定时器，成为高精度定时器

#48

windows一样也有纳秒级的，例如KeDelayExecutionThread

#49

我有个方法楼主可以试试
写一个循环，不停地获取CPU时间，这个好像可以精确到纳秒。
然后判断时间是否到达。
不过这个可能误差非常大。
另外获取到的CPU时间包括内核时间，用户时间，空闲时间，需要自己计算总的时间。
获取CPU时间的方法我忘了，自己查吧。

#50

我有个方法楼主可以试试
写一个循环，不停地获取CPU时间，这个好像可以精确到纳秒。
不加睡眠的语句，然后判断时间是否到达。
不过这个可能误差非常大。
另外获取到的CPU时间包括内核时间，用户时间，空闲时间，需要自己计算总的时间。
获取CPU时间的方法我忘了，自己查吧。