MultiTimer 单一计时器 更高效 更安全

分类：设计模式作者：编程之家用户

目的是使用一个定时器，但是完成多个Function的功能，并且完成时调用不同的函数。不过个人感觉参数太多，而且如果程序执行时间之和大于延迟时间，不就产生混乱了吗？

有时有一些function都有延时,并且频率都一样,

一般的做法是 一个做法: 每个function都new Tiemr,

function不多还好,一旦多了就很浪费资源了,
这个时候,O(∩_∩)O哈哈~MutiTimer出场了

MutiTimer应用环境:

  • 有多个function要延时调用
  • 所有function的调用的频率相同

MutiTimer与Timer比较 之优点:

  • 更高效:用一个Timer调用所有的function
  • 传任意参数: Timer TimerComplete都可以传任意个数参数
  • 更安全:使用者 不用事件,就不需要记住 移除事件

MutiTimer与Timer比较 之缺点:

  • 多个function必须频率一致,是Timer.delay 一样,不然精确度低
  • 不能记录执行了多少次
  • 启动了一个function后,这个function将不能停下,直到 指定时间之后

说了这么多,放代码上来

package cn.lite3.utils
{
	import flash.events.TimerEvent;
	import flash.utils.getTimer;
	import flash.utils.Timer;

	/**
	 * <a href="http://www.lite3.cn">www.lite3.cn</a>
	 * lite3@qq.com
	 * @author lite3
	 */
	public class MultiTimer 
	{

		private var _delay:Number;
		private var queue:Array = []; // 对象池
		private var timer:Timer;

		/**
		 * 构造函数
		 * @param	delay	<b>	int	</b> Timer的间隔 单位:ms
		 */
		public function MultiTimer(delay:Number) 
		{
			this.delay = delay;
		}

		/** 频率 */
		public function get delay():Number { return _delay; }
		public function set delay(value:Number):void 
		{
			if (isNaN(value)) value = 0;
			if (value < 0) value = 0;
			if (_delay != value)
			{
				_delay = value;
				if (timer) timer.delay = value;
			}
		}

		/**
		 * 添加一个时间函数
		 * 
		 * @param	time		<b>	int		</b> 运行的时间,单位:ms
		 * @param	completeFunc<b>	Function</b> 结束时函数
		 * @param	completeArgs<b>	Array	</b> 结束时函数的参数
		 * @param	completeThis<b>	Object	</b> 结束时函数的this对象
		 * @param	timerFunc	<b>	Function</b> timer时函数
		 * @param	timerArgs	<b>	Array	</b> timer时函数的参数
		 * @param	timerThis	<b>	Object	</b> timer时函数的this 对象
		 */
		public function addTimer(time:int,completeFunc:Function = null,completeArgs:Array = null,completeThis:Object=null,timerFunc:Function = null,timerArgs:Array = null,timerThis:Object = null):void
		{

			if (!completeFunc && !timerFunc) return;

			// 时间为0,则马上调用回调函数
			if (time <= 0)
			{
				if (completeFunc)
					completeFunc.apply(completeThis,completeArgs);
				return;
			}

			// 添加事件到队里
			var vo:Vo = new Vo( getTimer() + time,completeFunc,completeArgs,completeThis,timerFunc,timerArgs,timerThis);

			addToQueue(vo);

			// 惰性启动
			if (!timer) timer = new Timer(_delay);

			// 运行timer
			if (!timer.running)
			{
				timer.addEventListener(TimerEvent.TIMER,timerHandler);
				timer.start();
			}
		}

		/**
		 * @private	添加一个事件到 有序队列(按time 从大到小排列)
		 * @private 
		 * @param	vo
		 */
		private function addToQueue(vo:Vo):void
		{
			var time:int = vo.time;
			var index:int = 0;
			for each(var tem:Vo in queue)
			{
				if (tem.time <= time) break;

				index++;
			}
			for (var i:int = queue.length; i > index; i--)
			{
				queue[i] = queue[i - 1];
			}

			queue[index] = vo;
		}

		/**
		 * @private	执行循环
		 * @param	e
		 */
		private function timerHandler(e:TimerEvent):void 
		{
			var currTime:int = getTimer();
			for (var i:int = queue.length -1; i >= 0; i--)
			{
				var vo:Vo = queue[i] as Vo;

				// Timer 事件
				if (vo.timerFunc) 
					vo.timerFunc.apply(vo.timerThis,vo.timerArgs);

				// TimerComplete 事件
				if (vo.time <= currTime)
				{
					queue.pop();
					if (vo.completeFunc)
						vo.completeFunc.apply(vo.completeThis,vo.completeArgs);
				}
			}

			if (queue.length <= 0)
			{
				timer.stop();
				timer.removeEventListener(TimerEvent.TIMER,timerHandler);
			}
		}
	}
}

// 存放 相关信息
class Vo
{
	public var time:int
	public var completeFunc:Function;
	public var completeArgs:Array;
	public var completeThis:Object;
	public var timerFunc:Function;
	public var timerArgs:Array;
	public var timerThis:Object;

	public function Vo( time:int,completeFunc:Function,completeArgs:Array,completeThis:Object,timerFunc:Function,timerArgs:Array,timerThis:Object):void
	{
		this.time = time;
		this.completeFunc = completeFunc;
		this.completeArgs = completeArgs;
		this.completeThis = completeThis
		this.timerFunc	  = timerFunc;
		this.timerArgs	  = timerArgs;
		this.timerThis	  = timerThis;
	}
}
MultiTimer 用法:

package 
{
	import cn.lite3.utils.MultiTimer;
	import flash.display.Sprite;
	import flash.utils.getTimer;

	/**
	 * www.lite3.cn
	 * lite3@qq.com
	 * @author lite3
	 */
	public class MultiTimerExample extends Sprite
	{

		private var beginTime:int;
		private var multiTimer:MultiTimer;

		public function MultiTimerExample() 
		{
			beginTime = getTimer();

			// 要先实例化才能用,参数为 精度,相当于 new Timer(t)的t 参数
			multiTimer = new MultiTimer(100);

			/**
			 * 添加一个事件,其实就是一个函数,这个函数会以回调的方式调用
			 * 支持 传入参数
			 */ 
			multiTimer.addTimer(1000,completeHandler,["function1",1000],null,timerHandler,1000]);
			multiTimer.addTimer(2000,["function2",2000]);
			multiTimer.addTimer(3000,["function3",3000]);

		}

		private function timerHandler(name:String,time:int):void
		{
			trace("timerHandler!这是:",name,"/t持续时间:",time);
		}

		private function completeHandler(name:String,time:int):void
		{
			trace("completeHandler!这是:",time,"/t实际用时:",getTimer() -beginTime);
			if ("function3" == name)
			{
				time = getTimer();
				// 不同的时间添加事件
				multiTimer.addTimer(1000,["重启后的function3",1000]);
			}
		}

	}

}
 

 

  运行后,您会看到类似下面的输出
 
 
 

timerHandler!这是: function1 持续时间: 1000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function1 持续时间: 1000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function1 持续时间: 1000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function1 持续时间: 1000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function1 持续时间: 1000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function1 持续时间: 1000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function1 持续时间: 1000
completeHandler!这是: function1 持续时间: 1000 实际用时: 1102
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function2 持续时间: 2000
timerHandler!这是: function2 持续时间: 2000
completeHandler!这是: function3 持续时间: 3000 实际用时: 3100
timerHandler!这是: 重启后的function3 持续时间: 1000
timerHandler!这是: 重启后的function3 持续时间: 1000
timerHandler!这是: 重启后的function3 持续时间: 1000
timerHandler!这是: 重启后的function3 持续时间: 1000
timerHandler!这是: 重启后的function3 持续时间: 1000
timerHandler!这是: 重启后的function3 持续时间: 1000
 
 

转载自：http://www.lite3.cn/
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

                            

                    

                

                

                    

                        

                            
相关推荐

                            



                                
什么是设计模式？Design pattern--和生活结合更好理解

                                
什么是设计模式一套被反复使用、多数人知晓的、经过分类编目的、代码 设计经验 的总结；使用设计模式是为了 可重用 代码、让代码 更容易 被他人理解、保证代码 可靠性；设计模式使代码编制  真正工程化；设计模式使软件工程的 基石脉络， 如同大厦的结构一样；并不直接用来完成代码的编写，而是 描述 在各种不同情况下，要怎么解决问题的一种方案；能使不稳定依赖于相对稳定、具体依赖于相对抽象，避免引

                            

                                
面向对象设计原则一——单一职责原则

                                
单一职责原则定义（Single Responsibility Principle，SRP）一个对象应该只包含 单一的职责，并且该职责被完整地封装在一个类中。Every  Object should have  a single responsibility, and that responsibility should be entirely encapsulated by t

                            

                                
十分钟理解Java中的动态代理----强烈推荐

                                
动态代理和CGLib代理分不清吗，看看这篇文章，写的非常好，强烈推荐。原文截图*************************************************************************************************************************原文文本************

                            

                                
适配器模式-让不兼容的接口得以适配

                                
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合作。

                            

                                
策略模式-定义一个算法族

                                
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

                            

                                
设计模式之高质量代码

                                
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的一些设计问题，总结出来的一套通用的解决方案。

                            

                                
模板方法模式-封装一套算法流程

                                
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

                            

                                
迭代器模式-统一集合的遍历方式

                                
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。

                            

                                
外观模式-简化子系统的复杂性

                                
外观模式又叫门面模式，它提供了一个统一的（高层）接口，用来访问子系统中的一群接口，使得子系统更容易使用。

                            

                                
单例模式的五种实现方式及优缺点

                                
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。

                            

                                
组合模式-统一的处理个别对象与组合对象

                                
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方式处理个别对象和对象组合。

                            

                                
装饰者模式-动态的包装原有对象的行为

                                
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。

                            

                                
观察者模式-将消息通知给观察者

                                
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候，所有依赖者都会自动收到通知。

                            

                                
代理模式-访问对象的代理而非其本身

                                
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。

                            

                                
工厂模式-将对象的创建封装起来

                                
工厂模式（Factory Design Pattern）可细分为三种，分别是简单工厂，工厂方法和抽象工厂，它们都是为了更好的创建对象。

                            

                                
状态模式-将状态和行为封装成对象

                                
状态模式允许对象在内部状态改变时，改变它的行为，对象看起来好像改变了它的类。

                            

                                
命令模式-将请求封装成对象

                                
命令模式将请求封装为对象，能够支持请求的排队执行、记录日志、撤销等功能。

                            

                                
【设计模式】备忘录模式

                                
备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。 基本介绍 **意图：**在不破坏封装性的前提下，捕获一个对象的内部状态，并在该

                            

                                
【设计模式】职责链模式

                                
顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为

                            

                                
【设计模式】享元模式

                                
享元模式（Flyweight Pattern）（轻量级）（共享元素）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结

                            

                    



            

            

              
          

            

              




              

            

          

          
          

            

              

                  
    
              

            

          

          

            

              

                  
    
              

            

          

          
          

            

              

                
                
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot