引用自：Einesce

public function accumulation(root:INode, stack:Array):void{
    var x;
    var y;
    while(stack.length > 0){
      v = INode(stack.pop());
      // 省略部分操作  使用了x,y,root
      var pred:Array = 获取pred的方法；
       for(var i:int = 0; i<pred.length; i++){
          // do something  
      }
    }
}

////////////////////////////////////
public function accumulation(root:INode, stack:Array):void{
    var x;
    var y;
    var finishCount :int = 0;
    var j:int = 0;
    var total:int = 0;
    while(stack.length > 0){
      v = INode(stack.pop());
      // 省略部分操作  使用了x,y,root
      var pred:Array = 获取pred的方法；
       total += pred.length;
       for(var i:int = 0; i<pred.length; i++){
          TweenLite.to ( pred[i] , 0 , { delay:延遲時間.01*j , onComplete:count } );
          j++;
      }
    }

    function count ():void {
         //這里就是你之前的dosomething 已經延遲處理
         finishCount ++;
         if ( finishCount >= total ) {
                //所有的完成了。
         }
    }
}



簡單的可以借助一下TweenLite類的延時來處理
加一個j記錄每個循環體執行的編號根據這個來確定這個循環體延遲的時間。

我还想到一个取巧的办法，就是定义一个root 和 stack的全局副本，rootCopy,stackCopy， 然后将accumulation方法的参数赋予rootCopy,stackCocy，
这样在计时器的回调函数loop 中使用rootCopy,stackCocy 就可以了 o(∩_∩)o...

好像还有setTimeout（setTimeout(closure:Function, delay:Number, ... arguments)）方法可以 给操作函数传递参数，相当于只执行一次的Timer~~~~   不过没有试过这个办法：）

将大任务分解成小任务，把小任务丢到任务队列里执行：

/**

 * 由于存在 15 秒执行限制，对于大任务，采用任务队列的方式执行

 */

public class TimerExecutor

{

	private var timer:Timer;

	private var tasks:Vector.<Object>=new Vector.<Object>();



	public function TimerExecutor(delay:int=100)

	{

		this.timer=new Timer(delay);



		this.timer.addEventListener(TimerEvent.TIMER, function(event:TimerEvent):void

		{

			if (tasks.length > 0)

			{

				var task:Object=tasks.shift();

				(task.func as Function).apply(task.thisObj, task.params);

			}

		});



		this.timer.start();

	}



	public function addTask(func:Function, thisObj:Object=null, params:Array=

		null):void

	{

		this.tasks.push({func: func, thisObj: thisObj, params: params});

	}



}

很好啊，，遇到这样的问题了，准备分段读取数据