チェンジセット 514

コミット日時:

2008/05/26 22:58:22 (6 ヶ月前)

コミッタ:

yossy

ログメッセージ:

Thread(soumen): 現時点でのテスト(20tests)をパスするように実装

ファイル:

• as3/Thread/branches/soumen/src/org/libspark/thread/Monitor.as (更新) (2 diffs)
• as3/Thread/branches/soumen/src/org/libspark/thread/Thread.as (更新) (10 diffs)
• as3/Thread/branches/soumen/src/org/libspark/thread/errors/CurrentThreadNotFoundError.as (追加)
• as3/Thread/branches/soumen/src/org/libspark/thread/errors/IllegalThreadStateError.as (追加)

as3/Thread/branches/soumen/src/org/libspark/thread/Monitor.as

@@ -1 +1 @@
-package org.libspark.thread
-{
+        import flash.utils.Dictionary;
-        import org.libspark.thread.errors.InterruptError;
+        import flash.utils.setTimeout;
+        import flash.utils.clearTimeout;
-
-        public class Monitor implements IMonitor
@@ -7 +10 @@
-                public function Monitor()
-                {
-                        _waitors = [];
-                }
-                
-                private var _waitors:Array;
+                private var _timeoutList:Dictionary;
+                
+                private function getWaitors():Array
+                {
+                        return _waitors || (_waitors = []);
+                }
+                
+                private function registerTimeout(thread:Thread, timeout:uint):void
+                {
+                        // マップがなければ生成
+                        if (_timeoutList == null) {
+                                _timeoutList = new Dictionary();
+                        }
+                        
+                        // タイムアウトを設定して、thread をキーにして タイムアウトID を保存
+                        _timeoutList[thread] = setTimeout(timeoutHandler, timeout, thread);
+                }
+                
+                private function unregisterTimeout(thread:Thread):void
+                {
+                        // マップがなければ何もしない
+                        if (_timeoutList == null) {
+                                return;
+                        }
+                        
+                        // thread をキーにして タイムアウトID を検索
+                        var id:Object = _timeoutList[thread];
+                        
+                        // 見つかったらタイムアウトを解除する
+                        if (id != null) {
+                                clearTimeout(uint(id));
+                                delete _timeoutList[thread];
+                        }
+                }
-                
-                public function wait(timeout:uint = 0):void
-                {
-*
-currentThread
+/ カレントスレッドを取得
+getCurrentThread()
-                        
-
-
+
+
+
+
+
+
+
+
+
-                        }
-                        
-                        thread.sleep(this);
-                        
-                        _waitors.push(thread);
-                        */
-                }
-                
-                public function notify():void
-                {
-*
-
+/ 待機しているスレッドがいなければ何もしない
+ == null || _waitors
-                                return;
-                        }
-                        
+                        // スレッドをひとつ取り出す
-                        var thread:Thread = Thread(_waitors.shift());
-                        
-
-
+
+
+
+
+
-                }
-                
-                public function notifyAll():void
-                {
-*
-
+/ 待機しているスレッドがいなければ何もしない
+ == null || _waitors
-                                return;
-                        }
-                        
-var waitors:Array = _waitors;
-l:uint = waitors.length
+// 例外保存用
+ex:Object = null
-                        
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                        }
-                        
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-                

as3/Thread/branches/soumen/src/org/libspark/thread/Thread.as

@@ -2 +2 @@
-{
-        import flash.events.IEventDispatcher;
+        import org.libspark.thread.errors.CurrentThreadNotFoundError;
+        import org.libspark.thread.errors.IllegalThreadStateError;
-        
-        public class Thread extends Monitor
@@ -8 +10 @@
-                private static var _threadIndex:uint = 0;
-                private static var _currentThread:Thread = null;
+                private static var _toplevelThreads:Array = [];
-                
-                /**
@@ -18 +21 @@
-                public static function initialize(executor:IThreadExecutor):void
-                {
-
+//
-                        _currentThread = null;
+                        _toplevelThreads.length = 0;
-                        
-                        // 古い IThreadExecutor の実行を止める
@@ -43 +47 @@
-                
-                /**
+                 * 現在実行中のスレッドを返します。
+                 * ただし、現在実行中のスレッドがない(currentThread が null)の場合は CurrentThreadNotFoundError をスローします。
+                 * 
+                 * @return      現在実行中のスレッド
+                 * @throws      org.libspark.thread.errors.CurrentThreadNotFoundError   現在実行中のスレッドがない場合
+                 */
+                internal static function getCurrentThread():Thread
+                {
+                        var t:Thread = currentThread;
+                        
+                        if (t != null) {
+                                return t;
+                        }
+                        
+                        throw new CurrentThreadNotFoundError('Expected Thread.currentThread is not null, but actual null.');
+                }
+                
+                /**
-                 * 全てのスレッドを実行します。通常、このメソッドは IThreadExector インターフェイスの実装クラスによって呼び出されます。
-                 */
-                public static function executeAllThreads():void
-                {
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-                
@@ -57 +112 @@
-                public static function next(func:Function):void
-                {
-
+getCurrentThread()._runHandler = func;
-                }
-                
@@ -78 +133 @@
-                public static function timeout(func:Function):void
-                {
-
+getCurrentThread()._timeoutHandler = func;
-                }
-                
@@ -111 +166 @@
-                        _name = 'Thread' + _id;
-                        _state = ThreadState.NEW;
+                        _runningState = ThreadState.NEW;
+                        _children = null;
+                        _runHandler = null;
+                        _timeoutHandler = null;
+                        _joinMonitor = null;
-                }
-                
@@ -116 +176 @@
-                private var _name:String;
-                private var _state:uint;
+                private var _runningState:uint;
+                private var _children:Array;
+                private var _runHandler:Function;
+                private var _timeoutHandler:Function;
+                private var _joinMonitor:IMonitor;
-                
-                public function get id():uint
@@ -144 +209 @@
-                public function start():void
-                {
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-                
-                public function join(timeout:uint = 0):Boolean
-                {
-
+
+
+
+
+
+
+
+
+
-                }
-                
@@ -155 +293 @@
-                {
-                        
+                }
+                
+                private function getChildren():Array
+                {
+                        return _children || (_children = []);
+                }
+                
+                private function addChildThread(thread:Thread):void
+                {
+                        getChildren().push(thread);
+                }
+                
+                private function execute():Boolean
+                {
+                        // まだ start していなければ何もしない
+                        if (_state == ThreadState.NEW) {
+                                return true;
+                        }
+                        // 既に終了していれば何もしない
+                        if (_state == ThreadState.TERMINATED) {
+                                return false;
+                        }
+                        
+                        // すべての子スレッドを呼び出す
+                        var children:Array = _children;
+                        if (children != null) {
+                                var cl:uint = children.length;
+                                for (var ci:uint = 0; ci < cl; ) {
+                                        var child:Thread = Thread(children[ci]);
+                                        if (!child.execute()) {
+                                                // 終了したら削除
+                                                children.splice(ci, 1);
+                                                --cl;
+                                        }
+                                        else {
+                                                ++ci;
+                                        }
+                                }
+                        }
+                        
+                        // 待機状態であればここでリターン
+                        if (_state == ThreadState.WAITING || _state == ThreadState.TIMED_WAITING) {
+                                return true;
+                        }
+                        
+                        // 今回実行する実行関数を保存
+                        var runHandler:Function = _runHandler;
+                        
+                        // ハンドラ郡の設定をクリア
+                        _runHandler = null;
+                        _timeoutHandler = null;
+                        
+                        // Note: finalize の最後で wait が入って待機状態になった後に起きた等の場合に、
+                        //       runHandler が null の状態でここに到達することがある
+                        if (runHandler != null) {
+                                
+                                // カレントスレッドを設定
+                                _currentThread = this;
+                                
+                                try {
+                                        // 実行関数を呼び出す
+                                        runHandler.apply(this);
+                                }
+                                finally {
+                                        // カレントスレッドを元に戻す
+                                        _currentThread = null;
+                                }
+                        }
+                        
+                        if (_runHandler != null) {
+                                // 次に実行する実行関数が設定されている場合実行を継続
+                        }
+                        else {
+                                // 次に実行する実行関数が設定されていない場合
+                                if (_state == ThreadState.WAITING || _state == ThreadState.TIMED_WAITING) {
+                                        // 待機状態に入っている場合は次に繰り越す
+                                }
+                                else if (_runningState == ThreadState.TERMINATING) {
+                                        // 終了フェーズだった場合は実行を終了する
+                                        // 自分の子スレッドを、孤児スレッドとしてトップレベルに移動する
+                                        if (_children != null) {
+                                                addToplevelThreads(children);
+                                                // 子スレッドは破棄
+                                                _children = null;
+                                        }
+                                        // state を終了状態に切り替える
+                                        _state = ThreadState.TERMINATED;
+                                        _runningState = ThreadState.TERMINATED;
+                                        // join 用のモニタが存在(=join 待ちしているスレッドが存在)すれば notifyAll で起こす
+                                        if (_joinMonitor != null) {
+                                                _joinMonitor.notifyAll();
+                                                _joinMonitor = null;
+                                        }
+                                        // 終了
+                                        return false;
+                                }
+                                else {
+                                        // 終了フェーズでない場合は終了フェーズに入る
+                                        // state を終了フェーズに切り替える
+                                        _state = ThreadState.TERMINATING;
+                                        _runningState = ThreadState.TERMINATING;
+                                        // 次の実行関数を finalize に設定
+                                        _runHandler = finalize;
+                                }
+                        }
+                        
+                        return true;
-                }
-