如果ontimer的定时时间比ontimer函数执行时间还要短，会怎么样？

如题：
如果ontimer的定时时间比ontimer函数执行时间还要短，会怎么样？

19 个解决方案

#1

函数的执行时间都不会太长的，而且都远在毫秒级更低的时间内的，而Timer只可能是毫秒的。。。
所以，你还是别想了。。。

#2

我猜是再进入定时器函数。
我猜的哈。。。
我也想知道。

你可以自己写程序试试。
进入了定时器就输出当前时间然后在那while 个几秒钟。
定时器设为1000毫秒
你看打印的时间就知道了。

#3

写个代码测试下不就知道了， ontimer函数里面sleep下

#4

会一个接一个执行，而不会等间隔时间过后再执行。

#5

应该是函数执行完，
然后去看时间。

然后继续新一次的函数执行。

#6

引用 1 楼 healer_kx 的回复:

函数的执行时间都不会太长的，而且都远在毫秒级更低的时间内的，而Timer只可能是毫秒的。。。
所以，你还是别想了。。。

我这个函数有15.437612ms之长

#7

引用 2 楼 macrojj 的回复:

我猜是再进入定时器函数。
我猜的哈。。。
我也想知道。

你可以自己写程序试试。
进入了定时器就输出当前时间然后在那while 个几秒钟。
定时器设为1000毫秒
你看打印的时间就知道了。

刚才试了一下，定时器是10ms的间隔，我的程序是15ms多。但是每一步定时器都执行了，没丢

#8

引用 5 楼 freezezdj 的回复:

应该是函数执行完，
然后去看时间。

然后继续新一次的函数执行。

有道理。

#9

丢是不会，但会WM_TIMER事件会越积越多。

引用 7 楼 xuntaohm 的回复:

引用 2 楼 macrojj 的回复:
我猜是再进入定时器函数。
我猜的哈。。。
我也想知道。

你可以自己写程序试试。
进入了定时器就输出当前时间然后在那while 个几秒钟。
定时器设为1000毫秒
你看打印的时间就知道了。刚才试了一下，定时器是10ms的间隔，我的程序是15ms多。但是每一步定时器都执行了，没丢

#10

引用 3 楼 garybo 的回复:

写个代码测试下不就知道了， ontimer函数里面sleep下

事实上我猜应该是，每一次ontimer的请求都会存到缓冲队列里。如果下一次定时器触发时，上一次函数还没执行完的话，就会进入队列，等上次执行完之后继续执行，而不会被丢掉。
我的函数执行时间是15ms多，而定时器是1ms，我在ontimer里将一个公共变量i++,并打印出来。结果是都能打印，没有丢掉，只是时间被拖后了。我执行了1000个ontimer，照例应该是1秒钟能执行完的，但是它花了15秒多。
不知道有没有好的办法来处理，延时肯定不好。只能通过优化ontimer函数的算法来尽量减少时间了。

#11

好办法就是开线程。

引用 10 楼 xuntaohm 的回复:

引用 3 楼 garybo 的回复:
写个代码测试下不就知道了， ontimer函数里面sleep下事实上我猜应该是，每一次ontimer的请求都会存到缓冲队列里。如果下一次定时器触发时，上一次函数还没执行完的话，就会进入队列，等上次执行完之后继续执行，而不会被丢掉。
我的函数执行时间是15ms多，而定时器是1ms，我在ontimer里将一个公共变量i++,并打印出来。结果是都能打印，没有丢掉，只是时间被拖后了。我执行了1000个ontimer，照例应该是1秒钟能执行完的，但是它花了15秒多。
不知道有没有好的办法来处理，延时肯定不好。只能通过优化ontimer函数的算法来尽量减少时间了。

#12

引用 4 楼 m_s_d_n 的回复:

会一个接一个执行，而不会等间隔时间过后再执行。

你说的很对。那么这个缓冲队列能够缓存多少个ontimer呢？我这个程序有5000多次执行，不知道能不能积累这么多？

#13

引用 4 楼 m_s_d_n 的回复:

会一个接一个执行，而不会等间隔时间过后再执行。

我也这么认为。

#14

这个倒没研究过，得查下MSDN。。。

不过，最好不要这么积累这么多消息，因为一个线程只有一个消息队列，如果WM_TIMER消息积累多了，则会导致线程内的其他消息得不到及时处理，比如窗口消息，这时你就会发现窗口似乎能响应，却又很卡，响应得很慢。

引用 12 楼 xuntaohm 的回复:

引用 4 楼 m_s_d_n 的回复:
会一个接一个执行，而不会等间隔时间过后再执行。你说的很对。那么这个缓冲队列能够缓存多少个ontimer呢？我这个程序有5000多次执行，不知道能不能积累这么多？

#15

引用 11 楼 m_s_d_n 的回复:

好办法就是开线程。

引用 10 楼 xuntaohm 的回复:
引用 3 楼 garybo 的回复:
写个代码测试下不就知道了， ontimer函数里面sleep下事实上我猜应该是，每一次ontimer的请求都会存到缓冲队列里。如果下一次定时器触发时，上一次函数还没执行完的话，就会进入队列，等上次执行完之后继续执行，而不会被丢掉。
我的函数执行时间是15ms多，而定时器是1ms，我在ontimer里将一个公共变量i++,并打印出来。结果是都能打印，没有丢掉，只是时间被拖后了。我执行了1000个ontimer，照例应该是1秒钟能执行完的，但是它花了15秒多。
不知道有没有好的办法来处理，延时肯定不好。只能通过优化ontimer函数的算法来尽量减少时间了。

线程来执行也会要15ms时间啊。其实我的程序就是大块内存的赋值。也没什么算法可言。

for (i=0;i<m_objH;i++)
	{
		for (j=0;j<m_objW;j++)
		{

			mem_bg[object_y_old+i][object_x_old+j]=mem_buff[i][j];//缓冲区内容写回背景中旧的目标位置
			mem_buff[i][j]=mem_bg[object_y_new+i][object_x_new+j];//新目标位置的背景内容写入缓冲区
			mem_bg[object_y_new+i][object_x_new+j]=mem_obj[i][j];///新的目标内容写入背景
		}
	}

i和j都有几百大小。mem_bg是word类型的，有18000*5000之大。每次ontimer要执行读取文本文件的一行，（已经打开）然后读取一个i*j大小的图片，然后再执行上面一个for循环。这些过程做下来要15ms以上。但是项目要求比这个时间小。不知道怎样能把这个时间降下去？就是用线程也还是那么多时间啊。。。

#16

读文件操作是主要耗时的地方，如果这些文件没有变化，只要读一次就够了，无需每次都读。

引用 15 楼 xuntaohm 的回复:

引用 11 楼 m_s_d_n 的回复:
好办法就是开线程。

引用 10 楼 xuntaohm 的回复:
引用 3 楼 garybo 的回复:
写个代码测试下不就知道了， ontimer函数里面sleep下事实上我猜应该是，每一次ontimer的请求都会存到缓冲队列里。如果下一次定时器触发时，上一次函数还没执行完的话，就会进入队列，等上次执行完之后继续执行，而不会被丢掉。
我的函数执行时间是15ms多，而定时器是1ms，我在ontimer里将一个公共变量i++,并打印出来。结果是都能打印，没有丢掉，只是时间被拖后了。我执行了1000个ontimer，照例应该是1秒钟能执行完的，但是它花了15秒多。
不知道有没有好的办法来处理，延时肯定不好。只能通过优化ontimer函数的算法来尽量减少时间了。线程来执行也会要15ms时间啊。其实我的程序就是大块内存的赋值。也没什么算法可言。
C/C++ codefor (i=0;i<m_objH;i++)
 {for (j=0;j<m_objW;j++)
 {

 mem_bg[object_y_old+i][object_x_old+j]=mem_buff[i][j];//缓冲区内容写回背景中旧的目标位置 mem_buff[i][j]=mem_bg[object_y_new+i][object_x_new+j];//新目标位置的背景内容写入缓冲区 mem_bg[object_y_new+i][object_x_new+j]=mem_obj[i][j];///新的目标内容写入背景 }
 }
i和j都有几百大小。mem_bg是word类型的，有18000*5000之大。每次ontimer要执行读取文本文件的一行，（已经打开）然后读取一个i*j大小的图片，然后再执行上面一个for循环。这些过程做下来要15ms以上。但是项目要求比这个时间小。不知道怎样能把这个时间降下去？就是用线程也还是那么多时间啊。。。

#17

引用 16 楼 m_s_d_n 的回复:

读文件操作是主要耗时的地方，如果这些文件没有变化，只要读一次就够了，无需每次都读。
 
----------------------------------------------------------------------------------------
 
<marquee>可是每次读文件是没法避免的</marquee>

只能是在算法上优化了。我郁闷死了。

#18

首先从整体设计上能否有办法解决，如果实在不行，可以考虑通过提高硬盘IO速度来解决。

引用 17 楼 xuntaohm 的回复:

引用 16 楼 m_s_d_n 的回复:
读文件操作是主要耗时的地方，如果这些文件没有变化，只要读一次就够了，无需每次都读。
 
----------------------------------------------------------------------------------------
 
<marquee>可是每次读文件是没法避免的</marquee>
只能是在算法上优化了。我郁闷死了。

#19

对于定时器消息，系统不会让两条相同的定时器消息存在于消息队列中，请放心使用

#20

#1

函数的执行时间都不会太长的，而且都远在毫秒级更低的时间内的，而Timer只可能是毫秒的。。。
所以，你还是别想了。。。

#2

#3

写个代码测试下不就知道了， ontimer函数里面sleep下

#4

会一个接一个执行，而不会等间隔时间过后再执行。

#5

应该是函数执行完，
然后去看时间。

然后继续新一次的函数执行。

#6

引用 1 楼 healer_kx 的回复:

函数的执行时间都不会太长的，而且都远在毫秒级更低的时间内的，而Timer只可能是毫秒的。。。
所以，你还是别想了。。。

我这个函数有15.437612ms之长

#7

引用 2 楼 macrojj 的回复:

我猜是再进入定时器函数。
我猜的哈。。。
我也想知道。

你可以自己写程序试试。
进入了定时器就输出当前时间然后在那while 个几秒钟。
定时器设为1000毫秒
你看打印的时间就知道了。

刚才试了一下，定时器是10ms的间隔，我的程序是15ms多。但是每一步定时器都执行了，没丢

#8

引用 5 楼 freezezdj 的回复:

应该是函数执行完，
然后去看时间。

然后继续新一次的函数执行。

有道理。

#9

丢是不会，但会WM_TIMER事件会越积越多。

引用 7 楼 xuntaohm 的回复:

引用 2 楼 macrojj 的回复:
我猜是再进入定时器函数。
我猜的哈。。。
我也想知道。

你可以自己写程序试试。
进入了定时器就输出当前时间然后在那while 个几秒钟。
定时器设为1000毫秒
你看打印的时间就知道了。刚才试了一下，定时器是10ms的间隔，我的程序是15ms多。但是每一步定时器都执行了，没丢

#10

引用 3 楼 garybo 的回复:

写个代码测试下不就知道了， ontimer函数里面sleep下

#11

好办法就是开线程。

引用 10 楼 xuntaohm 的回复:

引用 3 楼 garybo 的回复:
写个代码测试下不就知道了， ontimer函数里面sleep下事实上我猜应该是，每一次ontimer的请求都会存到缓冲队列里。如果下一次定时器触发时，上一次函数还没执行完的话，就会进入队列，等上次执行完之后继续执行，而不会被丢掉。
我的函数执行时间是15ms多，而定时器是1ms，我在ontimer里将一个公共变量i++,并打印出来。结果是都能打印，没有丢掉，只是时间被拖后了。我执行了1000个ontimer，照例应该是1秒钟能执行完的，但是它花了15秒多。
不知道有没有好的办法来处理，延时肯定不好。只能通过优化ontimer函数的算法来尽量减少时间了。

#12

引用 4 楼 m_s_d_n 的回复:

会一个接一个执行，而不会等间隔时间过后再执行。

你说的很对。那么这个缓冲队列能够缓存多少个ontimer呢？我这个程序有5000多次执行，不知道能不能积累这么多？

#13

引用 4 楼 m_s_d_n 的回复:

会一个接一个执行，而不会等间隔时间过后再执行。

我也这么认为。

#14

引用 12 楼 xuntaohm 的回复:

引用 4 楼 m_s_d_n 的回复:
会一个接一个执行，而不会等间隔时间过后再执行。你说的很对。那么这个缓冲队列能够缓存多少个ontimer呢？我这个程序有5000多次执行，不知道能不能积累这么多？

#15

引用 11 楼 m_s_d_n 的回复:

好办法就是开线程。

引用 10 楼 xuntaohm 的回复:
引用 3 楼 garybo 的回复:
写个代码测试下不就知道了， ontimer函数里面sleep下事实上我猜应该是，每一次ontimer的请求都会存到缓冲队列里。如果下一次定时器触发时，上一次函数还没执行完的话，就会进入队列，等上次执行完之后继续执行，而不会被丢掉。
我的函数执行时间是15ms多，而定时器是1ms，我在ontimer里将一个公共变量i++,并打印出来。结果是都能打印，没有丢掉，只是时间被拖后了。我执行了1000个ontimer，照例应该是1秒钟能执行完的，但是它花了15秒多。
不知道有没有好的办法来处理，延时肯定不好。只能通过优化ontimer函数的算法来尽量减少时间了。

线程来执行也会要15ms时间啊。其实我的程序就是大块内存的赋值。也没什么算法可言。

for (i=0;i<m_objH;i++)
	{
		for (j=0;j<m_objW;j++)
		{

			mem_bg[object_y_old+i][object_x_old+j]=mem_buff[i][j];//缓冲区内容写回背景中旧的目标位置
			mem_buff[i][j]=mem_bg[object_y_new+i][object_x_new+j];//新目标位置的背景内容写入缓冲区
			mem_bg[object_y_new+i][object_x_new+j]=mem_obj[i][j];///新的目标内容写入背景
		}
	}

#16

读文件操作是主要耗时的地方，如果这些文件没有变化，只要读一次就够了，无需每次都读。

引用 15 楼 xuntaohm 的回复:

引用 11 楼 m_s_d_n 的回复:
好办法就是开线程。

引用 10 楼 xuntaohm 的回复:
引用 3 楼 garybo 的回复:
写个代码测试下不就知道了， ontimer函数里面sleep下事实上我猜应该是，每一次ontimer的请求都会存到缓冲队列里。如果下一次定时器触发时，上一次函数还没执行完的话，就会进入队列，等上次执行完之后继续执行，而不会被丢掉。
我的函数执行时间是15ms多，而定时器是1ms，我在ontimer里将一个公共变量i++,并打印出来。结果是都能打印，没有丢掉，只是时间被拖后了。我执行了1000个ontimer，照例应该是1秒钟能执行完的，但是它花了15秒多。
不知道有没有好的办法来处理，延时肯定不好。只能通过优化ontimer函数的算法来尽量减少时间了。线程来执行也会要15ms时间啊。其实我的程序就是大块内存的赋值。也没什么算法可言。
C/C++ codefor (i=0;i<m_objH;i++)
 {for (j=0;j<m_objW;j++)
 {

 mem_bg[object_y_old+i][object_x_old+j]=mem_buff[i][j];//缓冲区内容写回背景中旧的目标位置 mem_buff[i][j]=mem_bg[object_y_new+i][object_x_new+j];//新目标位置的背景内容写入缓冲区 mem_bg[object_y_new+i][object_x_new+j]=mem_obj[i][j];///新的目标内容写入背景 }
 }
i和j都有几百大小。mem_bg是word类型的，有18000*5000之大。每次ontimer要执行读取文本文件的一行，（已经打开）然后读取一个i*j大小的图片，然后再执行上面一个for循环。这些过程做下来要15ms以上。但是项目要求比这个时间小。不知道怎样能把这个时间降下去？就是用线程也还是那么多时间啊。。。

#17

引用 16 楼 m_s_d_n 的回复:

读文件操作是主要耗时的地方，如果这些文件没有变化，只要读一次就够了，无需每次都读。
 
----------------------------------------------------------------------------------------
 
<marquee>可是每次读文件是没法避免的</marquee>

只能是在算法上优化了。我郁闷死了。

#18

首先从整体设计上能否有办法解决，如果实在不行，可以考虑通过提高硬盘IO速度来解决。

引用 17 楼 xuntaohm 的回复:

引用 16 楼 m_s_d_n 的回复:
读文件操作是主要耗时的地方，如果这些文件没有变化，只要读一次就够了，无需每次都读。
 
----------------------------------------------------------------------------------------
 
<marquee>可是每次读文件是没法避免的</marquee>
只能是在算法上优化了。我郁闷死了。

#19

对于定时器消息，系统不会让两条相同的定时器消息存在于消息队列中，请放心使用

如果ontimer的定时时间比ontimer函数执行时间还要短，会怎么样？

19 个解决方案

#1

#2

#3

#4

#5

#6

#7

#8

#9

#10

#11

#12

#13

#14

#15

#16

#17

#18

#19

#20

#1

#2

#3

#4

#5

#6

#7

#8

#9

#10

#11

#12

#13

#14

#15

#16

#17

#18

#19

#20

相关文章