チェンジセット 520

コミット日時:

2008/05/27 14:16:31 (6 ヶ月前)

コミッタ:

yossy

ログメッセージ:

Thread(soumen): 現時点でのテスト(34tests)をパスするように例外周りを実装

ファイル:

• as3/Thread/branches/soumen/src/org/libspark/thread/IMonitor.as (更新) (1 diff)
• as3/Thread/branches/soumen/src/org/libspark/thread/Monitor.as (更新) (4 diffs)
• as3/Thread/branches/soumen/src/org/libspark/thread/Thread.as (更新) (19 diffs)

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

@@ -21 +21 @@
-                 */
-                function notifyAll():void;
+                
+                /**
+                 * 待機中に例外が発生した等の理由で、指定されたスレッドがこのモニタの待機セットから抜けることを伝えます。
+                 * 通常、このメソッドは内部的にのみ使用され、ユーザーが呼び出す必要はありません。
+                 * 
+                 * @param       thread  待機セットから抜けるスレッド
+                 */
+                function leave(thread:Thread):void;
-        }
-}

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

@@ -54 +54 @@
-                        
-                        // スレッドに wait するよう依頼
-
+, this
-                        
-                        // 待機セットに並ばせる
@@ -79 +79 @@
-                        
-                        // スレッドを起こす
-
+this
-                }
-                
@@ -100 +100 @@
-                                // ここで try-catch を行うのは確実に全てのスレッドを起こすため
-                                try {
-
+this
-                                }
-                                catch (e:Object) {
@@ -138 +138 @@
-                        
-                        // スレッドを起こす
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-                

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

@@ -2 +2 @@
-{
-        import flash.events.IEventDispatcher;
+        import flash.utils.Dictionary;
+        import flash.utils.getQualifiedClassName;
+        import flash.utils.getQualifiedSuperclassName;
+        import flash.utils.getDefinitionByName;
-        import org.libspark.thread.errors.CurrentThreadNotFoundError;
-        import org.libspark.thread.errors.IllegalThreadStateError;
@@ -11 +15 @@
-                private static var _currentThread:Thread = null;
-                private static var _toplevelThreads:Array = [];
+                private static var _uncaughtErrorHandler:Function = null;
-                
-                /**
@@ -21 +26 @@
-                public static function initialize(executor:IThreadExecutor):void
-                {
-//
+
-                        _currentThread = null;
-                        _toplevelThreads.length = 0;
@@ -71 +76 @@
-                public static function get uncaughtErrorHandler():Function
-                {
-null
+_uncaughtErrorHandler
-                }
-                
@@ -79 +84 @@
-                public static function set uncaughtErrorHandler(value:Function):void
-                {
-
+
+
+
+
+
+
+
+
+
+
+
-                }
-                
@@ -100 +115 @@
-                                        ++i;
-                                }
+                                // 伝播すべき例外が発生している場合はキャッチされない例外ハンドラを呼び出す
+                                // Note: _errorThread が null の場合、この例外はまだ伝播すべきではないことを示す
+                                if (thread._error != null && thread._errorThraed != null) {
+                                        try {
+                                                getUncaughtErrorHandler()(thread._error, thread._errorThraed);
+                                        }
+                                        catch (e:Object) {
+                                                defaultUncaughtErrorHandler(e, null);
+                                        }
+                                        thread._error = null;
+                                        thread._errorThraed = null;
+                                }
-                        }
-                }
@@ -142 +169 @@
-                public static function error(klass:Class, func:Function, reset:Boolean = true):void
-                {
-
+
+
+
+
+
+
-                }
-                
@@ -188 +220 @@
-                        _children = null;
-                        _runHandler = null;
+                        _savedRunHandler = null;
-                        _timeoutHandler = null;
+                        _waitMonitor = null;
-                        _joinMonitor = null;
+                        _errorHandlers = null;
+                        _error = null;
+                        _errorThraed = null;
-                }
-                
@@ -198 +235 @@
-                private var _children:Array;
-                private var _runHandler:Function;
+                private var _savedRunHandler:Function;
-                private var _timeoutHandler:Function;
+                private var _waitMonitor:IMonitor;
-                private var _joinMonitor:IMonitor;
+                private var _errorHandlers:Dictionary;
+                private var _error:Object;
+                private var _errorThraed:Thread;
-                
-                public function get id():uint
@@ -253 +295 @@
-                }
-                
-
+, monitor:IMonitor
-                {
-                        // wait できる状態でなければエラー
-_state != ThreadState.RUNNABLE && _state != ThreadState.TERMINATING
+(_state != ThreadState.RUNNABLE && _state != ThreadState.TERMINATING) || _waitMonitor != null
-                                throw new IllegalThreadStateError('Thread can not wait.');
-                        }
@@ -262 +304 @@
-                        // state を待機状態に切り替える
-                        _state = timeout ? ThreadState.TIMED_WAITING : ThreadState.WAITING;
-
-
-
+
+
+
+
+
+
-                {
-                        // 待機状態でなければエラー
-_state != ThreadState.WAITING && _state != ThreadState.TIMED_WAITING
+(_state != ThreadState.WAITING && _state != ThreadState.TIMED_WAITING) || _waitMonitor != monitor
-                                throw new IllegalThreadStateError('Thread can not wakeup.');
-                        }
@@ -273 +318 @@
-                        // state を実行状態に切り替える
-                        _state = _runningState;
-
-
-
+
+
+
+
+
+
-                {
-                        // 待機時間付の待機状態でなければエラー
-
+ || _waitMonitor != monitor
-                                throw new IllegalThreadStateError('Thread can not wakeup.');
-                        }
@@ -284 +332 @@
-                        // state を実行状態に切り替える
-                        _state = _runningState;
+                        
+                        // 保存されていたモニタを破棄
+                        _waitMonitor = null;
-                        
-                        // 次に実行する実行関数をタイムアウト用のものに切り替える
@@ -324 +375 @@
-                }
-                
+                private function getErrorHandlers():Dictionary
+                {
+                        return _errorHandlers || (_errorHandlers = new Dictionary());
+                }
+                
+                private function addErrorHandler(klass:Class, handler:Function, reset:Boolean):void
+                {
+                        getErrorHandlers()[getQualifiedClassName(klass)] = new ErrorHandler(handler, reset);
+                }
+                
+                private function removeErrorHandler(klass:Class):void
+                {
+                        // ハンドラマップが存在しなければ何もしない
+                        if (_errorHandlers == null) {
+                                return;
+                        }
+                        
+                        // ハンドラマップから削除
+                        delete _errorHandlers[getQualifiedClassName(klass)];
+                }
+                
+                private function resetErrorHandlers():void
+                {
+                        // ハンドラマップが存在しなければ何もしない
+                        if (_errorHandlers == null) {
+                                return;
+                        }
+                        
+                        // 登録されているハンドラを巡回
+                        for (var key:String in _errorHandlers) {
+                                // reset が true であればハンドラを削除する
+                                if (ErrorHandler(_errorHandlers[key]).reset) {
+                                        delete _errorHandlers[key];
+                                }
+                        }
+                }
+                
+                private function getErrorHandler(error:Object):ErrorHandler
+                {
+                        // ハンドラマップが存在しなければ null を返す
+                        if (_errorHandlers == null) {
+                                return null;
+                        }
+                        
+                        // error のクラス名を取得
+                        var className:String = getQualifiedClassName(error);
+                        
+                        // クラス名が取得できる限り回す
+                        while (className != null) {
+                                // ハンドラマップからクラス名をキーにしてハンドラを検索する
+                                var handler:ErrorHandler = _errorHandlers[className];
+                                // 見つかればそれを返す
+                                if (handler != null) {
+                                        return handler;
+                                }
+                                // 見つからなければ、スーパークラスを辿る
+                                try {
+                                        className = getQualifiedSuperclassName(getDefinitionByName(className));
+                                }
+                                catch (e:ReferenceError) {
+                                        // ここで出る ReferenceError は getDefinitionByName によるもの
+                                        // プライベートクラス等の場合に起こりうる
+                                        className = null;
+                                }
+                        }
+                        
+                        return null;
+                }
+                
-                private function execute():Boolean
-                {
@@ -334 +454 @@
-                                return false;
-                        }
+                        
+                        // 発生した例外
+                        var error:Object = _error;
+                        var errorThread:Thread = _errorThraed || this;
-                        
-                        // すべての子スレッドを呼び出す
@@ -349 +473 @@
-                                                ++ci;
-                                        }
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-                        if (_state == ThreadState.WAITING || _state == ThreadState.TIMED_WAITING) {
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                        _runHandler = null;
+                        // タイムアウトハンドラをリセット
-                        _timeoutHandler = null;
+                        // エラーハンドラをリセット
+                        resetErrorHandlers();
+                        
+                        // エラーハンドラが実行されようとしている場合、実行終了後に復帰できるように保存しておいた実行関数を設定
+                        if (errorHandler != null) {
+                                _runHandler = _savedRunHandler;
+                        }
-                        
-                        // Note: finalize の最後で wait が入って待機状態になった後に起きた等の場合に、
@@ -373 +563 @@
-                                try {
-                                        // 実行関数を呼び出す
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                                }
-                                finally {
@@ -379 +590 @@
-                                        _currentThread = null;
-                                }
+                        }
+                        
+                        // 今エラーハンドラを実行し、かつエラーが発生していない場合、保存しておいた実行関数はもう必要ないので破棄
+                        if (errorHandler != null && _error == null) {
+                                _savedRunHandler = null;
-                        }
-                        
@@ -814 +1030 @@
-        }
-}
+
+class ErrorHandler
+{
+        public function ErrorHandler(handler:Function, reset:Boolean)
+        {
+                this.handler = handler;
+                this.reset = reset;
+        }
+        
+        public var handler:Function;
+        public var reset:Boolean;
+}