.NET System.Timers.Timer的原理和使用(开发定时执行程序)
来源:互联网 发布:nlp领域算法 编辑:程序博客网 时间:2024/05/22 14:43
概述(来自MSDN)
Timer 组件是基于服务器的计时器,它使您能够指定在应用程序中引发 Elapsed 事件的周期性间隔。然后可以操控此事件以提供定期处理。例如,假设您有一台关键性服务器,必须每周 7 天、每天 24 小时都保持运行。可以创建一个使用 Timer 的服务,以定期检查服务器并确保系统开启并在运行。如果系统不响应,则该服务可以尝试重新启动服务器或通知管理员。
基于服务器的 Timer 是为在多线程环境中用于辅助线程而设计的。服务器计时器可以在线程间移动来处理引发的 Elapsed 事件,这样就可以比 Windows 计时器更精确地按时引发事件。
基于 Interval 属性的值,Timer 组件引发 Elapsed 事件。可以处理该事件以执行所需的处理。例如,假设您有一个联机销售应用程序,它不断向数据库发送销售订单。编译发货指令的服务分批处理订单,而不是分别处理每个订单。可以使用 Timer 每 30 分钟启动一次批处理。
注意
当 AutoReset设置为false时,Timer只在第一个Interval过后引发一次Elapsed事件。若要保持以Interval时间间隔引发 Elapsed 事件,请将AutoReset设置为true。
Elapsed事件在ThreadPool线程上引发。如果Elapsed事件的处理时间比Interval长,在另一个hreadPool线程上将会再次引发此事件。因此,事件处理程序应当是可重入的。
注意
在一个线程调用 Stop 方法或将 Enabled 属性设置为 false 的同时,可在另一个线程上运行事件处理方法。这可能导致在计时器停止之后引发 Elapsed 事件。Stop 方法的示例代码演示了一种避免此争用条件的方法。
如果和用户界面元素(如窗体或控件)一起使用 Timer,请将包含有 Timer 的窗体或控件赋值给SynchronizingObject 属性,以便将此事件封送到用户界面线程中。 Timer 在运行时是不可见的。
几点说明
private
System.Timers.Timer _TestTimerEvent=
new
Timer();
1、默认的周期是0.1秒执行一次;
2、AutoReset的初始值为true.
3、它的timer机制和System.Threading.Timer 原理是一样的。
4、每次周期(Timer)运行一次会新起一个线程。
5、如果Elapsed事件的处理时间比Interval长,它每个周期执行都会新起一个线程,这个线程的执行时间不受interval的限定,可以比interval长,因为一个新周期执行,又会新起一个线程,Timer起的线程周期就是事件处理时间。
我们来看它的实现代码.(.net framework 提供的).
//------------------------------------------------------------------------------
// <copyright file="Timer.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------------
namespace
System.Timers {
using
System.Runtime.InteropServices;
using
System.Security;
using
System.Security.Permissions;
using
System.Threading;
using
System.ComponentModel;
using
System.ComponentModel.Design;
using
System;
using
Microsoft.Win32;
using
Microsoft.Win32.SafeHandles;
/// <devdoc>
/// <para>Handles recurring events in an application.</para>
/// </devdoc>
[
DefaultProperty(
"Interval"
),
DefaultEvent(
"Elapsed"
),
HostProtection(Synchronization=
true
, ExternalThreading=
true
)
]
public
class
Timer : Component, ISupportInitialize {
private
double
interval;
private
bool
enabled;
private
bool
initializing;
private
bool
delayedEnable;
private
ElapsedEventHandler onIntervalElapsed;
private
bool
autoReset;
private
ISynchronizeInvoke synchronizingObject;
private
bool
disposed;
private
System.Threading.Timer timer;
private
TimerCallback callback;
private
Object cookie;
/// <devdoc>
/// <para>Initializes a new instance of the <see cref='System.Timers.Timer'/> class, with the properties
/// set to initial values.</para>
/// </devdoc>
public
Timer()
:
base
() {
interval = 100;
enabled =
false
;
autoReset =
true
;
initializing =
false
;
delayedEnable =
false
;
callback =
new
TimerCallback(
this
.MyTimerCallback);
}
/// <devdoc>
/// <para>
/// Initializes a new instance of the <see cref='System.Timers.Timer'/> class, setting the <see cref='System.Timers.Timer.Interval'/> property to the specified period.
/// </para>
/// </devdoc>
public
Timer(
double
interval)
:
this
() {
if
(interval <= 0)
throw
new
ArgumentException(SR.GetString(SR.InvalidParameter,
"interval"
, interval));
int
i = (
int
)Math.Ceiling(interval);
if
( i < 0) {
throw
new
ArgumentException(SR.GetString(SR.InvalidParameter,
"interval"
, interval));
}
this
.interval = interval;
}
/// <devdoc>
/// <para>Gets or sets a value indicating whether the Timer raises the Tick event each time the specified
/// Interval has elapsed,
/// when Enabled is set to true.</para>
/// </devdoc>
[Category(
"Behavior"
), TimersDescription(SR.TimerAutoReset), DefaultValue(
true
)]
public
bool
AutoReset {
get
{
return
this
.autoReset;
}
set
{
if
(DesignMode)
this
.autoReset = value;
else
if
(
this
.autoReset != value) {
this
.autoReset = value;
if
( timer !=
null
) {
UpdateTimer();
}
}
}
}
/// <devdoc>
/// <para>Gets or sets a value indicating whether the <see cref='System.Timers.Timer'/>
/// is able
/// to raise events at a defined interval.</para>
/// </devdoc>
//[....] - The default value by design is false, don't change it.
[Category(
"Behavior"
), TimersDescription(SR.TimerEnabled), DefaultValue(
false
)]
public
bool
Enabled {
get
{
return
this
.enabled;
}
set
{
if
(DesignMode) {
this
.delayedEnable = value;
this
.enabled = value;
}
else
if
(initializing)
this
.delayedEnable = value;
else
if
(enabled != value) {
if
(!value) {
if
( timer !=
null
) {
cookie =
null
;
timer.Dispose();
timer =
null
;
}
enabled = value;
}
else
{
enabled = value;
if
( timer ==
null
) {
if
(disposed) {
throw
new
ObjectDisposedException(GetType().Name);
}
int
i = (
int
)Math.Ceiling(interval);
cookie =
new
Object();
timer =
new
System.Threading.Timer(callback, cookie, i, autoReset? i:Timeout.Infinite);
}
else
{
UpdateTimer();
}
}
}
}
}
private
void
UpdateTimer() {
int
i = (
int
)Math.Ceiling(interval);
timer.Change(i, autoReset? i :Timeout.Infinite );
}
/// <devdoc>
/// <para>Gets or
/// sets the interval on which
/// to raise events.</para>
/// </devdoc>
[Category(
"Behavior"
), TimersDescription(SR.TimerInterval), DefaultValue(100d), RecommendedAsConfigurable(
true
)]
public
double
Interval {
get
{
return
this
.interval;
}
set
{
if
(value <= 0)
throw
new
ArgumentException(SR.GetString(SR.TimerInvalidInterval, value, 0));
interval = value;
if
(timer !=
null
) {
UpdateTimer();
}
}
}
/// <devdoc>
/// <para>Occurs when the <see cref='System.Timers.Timer.Interval'/> has
/// elapsed.</para>
/// </devdoc>
[Category(
"Behavior"
), TimersDescription(SR.TimerIntervalElapsed)]
public
event
ElapsedEventHandler Elapsed {
add {
onIntervalElapsed += value;
}
remove {
onIntervalElapsed -= value;
}
}
/// <devdoc>
/// <para>
/// Sets the enable property in design mode to true by default.
/// </para>
/// </devdoc>
/// <internalonly/>
public
override
ISite Site {
set
{
base
.Site = value;
if
(
this
.DesignMode)
this
.enabled=
true
;
}
get
{
return
base
.Site;
}
}
/// <devdoc>
/// <para>Gets or sets the object used to marshal event-handler calls that are issued when
/// an interval has elapsed.</para>
/// </devdoc>
[
Browsable(
false
),
DefaultValue(
null
),
TimersDescription(SR.TimerSynchronizingObject)
]
public
ISynchronizeInvoke SynchronizingObject {
get
{
if
(
this
.synchronizingObject ==
null
&& DesignMode) {
IDesignerHost host = (IDesignerHost)GetService(
typeof
(IDesignerHost));
if
(host !=
null
) {
object
baseComponent = host.RootComponent;
if
(baseComponent !=
null
&& baseComponent
is
ISynchronizeInvoke)
this
.synchronizingObject = (ISynchronizeInvoke)baseComponent;
}
}
return
this
.synchronizingObject;
}
set
{
this
.synchronizingObject = value;
}
}
/// <devdoc>
/// <para>
/// Notifies
/// the object that initialization is beginning and tells it to stand by.
/// </para>
/// </devdoc>
public
void
BeginInit() {
this
.Close();
this
.initializing =
true
;
}
/// <devdoc>
/// <para>Disposes of the resources (other than memory) used by
/// the <see cref='System.Timers.Timer'/>.</para>
/// </devdoc>
public
void
Close() {
initializing =
false
;
delayedEnable =
false
;
enabled =
false
;
if
(timer !=
null
) {
timer.Dispose();
timer =
null
;
}
}
/// <internalonly/>
/// <devdoc>
/// </devdoc>
protected
override
void
Dispose(
bool
disposing) {
Close();
this
.disposed =
true
;
base
.Dispose(disposing);
}
/// <devdoc>
/// <para>
/// Notifies the object that initialization is complete.
/// </para>
/// </devdoc>
public
void
EndInit() {
this
.initializing =
false
;
this
.Enabled =
this
.delayedEnable;
}
/// <devdoc>
/// <para>Starts the timing by setting <see cref='System.Timers.Timer.Enabled'/> to <see langword='true'/>.</para>
/// </devdoc>
public
void
Start() {
Enabled =
true
;
}
/// <devdoc>
/// <para>
/// Stops the timing by setting <see cref='System.Timers.Timer.Enabled'/> to <see langword='false'/>.
/// </para>
/// </devdoc>
public
void
Stop() {
Enabled =
false
;
}
private
void
MyTimerCallback(
object
state) {
// System.Threading.Timer will not cancel the work item queued before the timer is stopped.
// We don't want to handle the callback after a timer is stopped.
if
( state != cookie) {
return
;
}
if
(!
this
.autoReset) {
enabled =
false
;
}
FILE_TIME filetime =
new
FILE_TIME();
GetSystemTimeAsFileTime(
ref
filetime);
ElapsedEventArgs elapsedEventArgs =
new
ElapsedEventArgs(filetime.ftTimeLow, filetime.ftTimeHigh);
try
{
// To avoid ---- between remove handler and raising the event
ElapsedEventHandler intervalElapsed =
this
.onIntervalElapsed;
if
(intervalElapsed !=
null
) {
if
(
this
.SynchronizingObject !=
null
&&
this
.SynchronizingObject.InvokeRequired)
this
.SynchronizingObject.BeginInvoke(intervalElapsed,
new
object
[]{
this
, elapsedEventArgs});
else
intervalElapsed(
this
, elapsedEventArgs);
}
}
catch
{
}
}
[StructLayout(LayoutKind.Sequential)]
internal
struct
FILE_TIME {
internal
int
ftTimeLow;
internal
int
ftTimeHigh;
}
[DllImport(ExternDll.Kernel32), SuppressUnmanagedCodeSecurityAttribute()]
internal
static
extern
void
GetSystemTimeAsFileTime(
ref
FILE_TIME lpSystemTimeAsFileTime);
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
在初始化的时候它的代码实现是这样的.
public
Timer()
:
base
() {
interval = 100;
enabled =
false
;
autoReset =
true
;
initializing =
false
;
delayedEnable =
false
;
callback =
new
TimerCallback(
this
.MyTimerCallback);
}
而如果你是这样的话
public
Timer(
double
interval)
:
this
() {
if
(interval <= 0)
throw
new
ArgumentException(SR.GetString(SR.InvalidParameter,
"interval"
, interval));
int
i = (
int
)Math.Ceiling(interval);
if
( i < 0) {
throw
new
ArgumentException(SR.GetString(SR.InvalidParameter,
"interval"
, interval));
}
this
.interval = interval;
}
你就需要再设置下AutoReset = True;
我们加载事件的Elapsed的代码实现是这样的.
/// <devdoc>
/// <para>Occurs when the <see cref='System.Timers.Timer.Interval'/> has
/// elapsed.</para>
/// </devdoc>
[Category(
"Behavior"
), TimersDescription(SR.TimerIntervalElapsed)]
public
event
ElapsedEventHandler Elapsed {
add {
onIntervalElapsed += value;
}
remove {
onIntervalElapsed -= value;
}
}
对它的基本原理有一定了解后,我们开始写一个简单的实现程序。
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Threading;
using
Timer = System.Timers.Timer;
using
System.Timers;
namespace
TestMultipleThread
{
public
class
ThreadWork
{
private
System.Timers.Timer _TestTimerEvent;
public
void
StartWork()
{
_TestTimerEvent =
new
Timer();
_TestTimerEvent.Elapsed += Sum;
_TestTimerEvent.Start();
}
public
static
object
lockobject =
new
object
();
private
void
Sum(
object
sender, ElapsedEventArgs e)
{
Console.WriteLine(
string
.Format(
"this is thread ID {0} execute"
, Thread.CurrentThread.ManagedThreadId));
for
(
int
i = 0; i < 10000; i++)
{
Thread.Sleep(10);
}
}
}
class
Program
{
public
static
void
Main()
{
ThreadWork threadWork =
new
ThreadWork();
ThreadStart myThreadDelegate =
new
ThreadStart(threadWork.StartWork);
Thread myThread =
new
Thread(myThreadDelegate);
myThread.Start();
Thread.Sleep(1000000);
}
}
}
查看的运行结果是:
我们看下执行的线程数有多少
能说明的一个问题就是在timer每次执行时都会新起一个线程来执行。
作者:spring yang
出处:http://www.cnblogs.com/springyangwc/
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。
- .NET System.Timers.Timer的原理和使用(开发定时执行程序)
- .NET System.Timers.Timer的原理和使用(开发定时执行程序)
- .NET System.Timers.Timer的原理和使用(开发定时执行程序)
- System.Timers.Timer 定时执行程序
- System.Timers.Timer 定时执行程序
- System.Timers.Timer 定时执行
- System.Timers.Timer 定时执行
- System.Timers.Timer的使用
- C#中System.Timers.Timer的使用
- 定时器 System.Timers.Timer的使用
- System.Timers.Timer定时器的使用
- System.Windows.Forms.Timer和System.Timers.Timer的区别
- System.Windows.Forms.Timer和System.Timers.Timer的区别
- System.Windows.Forms.Timer和System.Timers.Timer的区别
- 使用System.Timers.Timer类
- Timer(System.Timers) 和 DispatcherTimer
- Timer控件使用(System.Timers.Timer)
- Timer控件使用(System.Timers.Timer)
- cocos2dx CCLayer接受 touch 事件
- poj1703 Find them,Catch them 【并查集】
- 2014-520-记录帖:你是我生命中必不可少的主函数
- 软件架构的理解
- 黑马程序员——反射调用main方法和数组Class及数组参数
- .NET System.Timers.Timer的原理和使用(开发定时执行程序)
- 【OpenCV】访问图像中每个像素的值
- POJ 2431 Expedition(树)
- java JSP指令
- 【hadoop】学习笔记-安装配置
- ajax 详解(未完成)
- http://bbs.tiexue.net/post_7657028_1.html http://bbs.tiexue.net/post_7657237_1.html http://bbs.tiex
- 并发包之Future:代码级控制超时时间
- Multi-Thread 3---Use thread Pool