チェンジセット 531

差分発生行の前後
無視リスト:
コミット日時:
2008/05/27 21:41:55 (6 ヶ月前)
コミッタ:
yossy
ログメッセージ:

Thread(soumen): SerialExecutor? 及び ParallelExecutor? を新仕様にアップデート

ファイル:

凡例:

変更無し
追加
削除
更新
コピー
移動

  • as3/Thread/branches/soumen/src/org/libspark/utils/concurrent/Executor.as

    r148 r531  
    1 package org.libspark.utils.concurrent 
     1package org.libspark.utils.concurrent 
    22{ 
    33        import org.libspark.thread.Thread; 
    44 
     5        /** 
     6         * Executor は複数のスレッドを実行するスレッドのための基底クラスです 
     7         */ 
    58        public class Executor extends Thread 
    69        { 
     10                /** 
     11                 * 新しい Executor クラスのインスタンスを作成します 
     12                 */ 
    713                public function Executor()  
    814                { 
    …… 
    1218                protected var _threads:Array; 
    1319                 
     20                /** 
     21                 * 実行されるスレッドの数を返します 
     22                 */ 
    1423                public function get numThreads():uint 
    1524                { 
    …… 
    1726                } 
    1827                 
     28                /** 
     29                 * 指定されたインデックスのスレッドを取得します 
     30                 *  
     31                 * @param       index   取得スレッドのインデックス 
     32                 * @return      インデックスの位置にあるスレッド 
     33                 */ 
    1934                public function getThreadAt(index:uint):Thread 
    2035                { 
    …… 
    2237                } 
    2338                 
     39                /** 
     40                 * 指定されたスレッドを追加します 
     41                 *  
     42                 * @param       thread  追加するスレッド 
     43                 * @return      追加されたスレッド 
     44                 */ 
    2445                public function addThread(thread:Thread):Thread 
    2546                { 
    …… 
    2849                        return thread; 
    2950                } 
    30                  
    31                 public override function toString():String 
    32                 { 
    33                         return '[Executor]'; 
    34                 } 
    3551        } 
    3652} 

  • as3/Thread/branches/soumen/src/org/libspark/utils/concurrent/ParallelExecutor.as

    r137 r531  
    33        import org.libspark.thread.Thread; 
    44 
     5        /** 
     6         * ParallelExecutor は複数のスレッドを並列して実行するためのユーティリティクラスです 
     7         *  
     8         * 同時に全てのスレッドを開始し、全てのスレッドの実行が終了するとこのスレッドも終了します 
     9         */ 
    510        public class ParallelExecutor extends Executor 
    611        { 
    712                private var _index:uint; 
    813                 
    9                 protected override function initialize():void 
     14                /** 
     15                 * @inheritDoc 
     16                 */ 
     17                override public function interrupt():void 
    1018                { 
    11                         var threads:Array = _threads; 
    12                         var l:uint = threads.length; 
    13                         for (var i:uint = 0; i < l; ++i) { 
    14                                 Thread(threads[i]).begin(); 
     19                        // 元の割り込み処理を呼び出す 
     20                        super.interrupt(); 
     21                         
     22                        // 全てのスレッドに対しても割り込み処理をかける 
     23                        for each (var thread:Thread in _threads) { 
     24                                thread.interrupt(); 
     25                        } 
     26                } 
     27                 
     28                override protected function run():void 
     29                { 
     30                        // 全てのスレッドを開始 
     31                        for each (var thread:Thread in _threads) { 
     32                                thread.start(); 
    1533                        } 
    1634                         
     35                        // 次に終了を待つスレッドのインデックス 
    1736                        _index = 0; 
     37                         
     38                        waitThreads(); 
    1839                } 
    1940                 
    20                 protected override function execute():void 
     41                private function waitThreads():void 
    2142                { 
    2243                        // 全てのスレッドが終了するまで待つ、本当のマルチスレッドで言えば 
    …… 
    2748                        // 
    2849                        // を行っている 
    29                          
    30                         for (; _index < _threads.length;) { 
    31                                 var thread:Thread = _threads[_index++]; 
    32                                  
    33                                 // まだ終了してなければ終了するまでjoinで待つ 
    34                                 if (!thread.isTerminated) { 
    35                                         thread.join(); 
     50                        while (_index < _threads.length) { 
     51                                // 終了待ちをするスレッドを取得 
     52                                var thread:Thread = Thread(_threads[_index++]); 
     53                                // スレッドの終了を待つ 
     54                                if (thread.join()) { 
     55                                        // join の戻り値が true の場合、待機状態になったということなので 
     56                                        // 次にまたこのメソッドが実行されるよう設定してリターンする 
     57                                        next(waitThreads); 
     58                                        // ちなみに割り込みが発生しても無視する 
     59                                        interrupted(waitThreads); 
    3660                                        return; 
    3761                                } 
    3862                        } 
    3963                         
    40                         terminate(); 
    41                 } 
    42                  
    43                 public override function toString():String 
    44                 { 
    45                         return '[ParallelExecutor]'; 
     64                        // ここまで到達した場合全てのスレッドの実行が終了している 
    4665                } 
    4766        } 

  • as3/Thread/branches/soumen/src/org/libspark/utils/concurrent/SerialExecutor.as

    r137 r531  
    33        import org.libspark.thread.Thread; 
    44 
     5        /** 
     6         * SerialExecutor は複数のスレッドを順番に実行するためのユーティリティクラスです 
     7         *  
     8         * 開始したスレッドの終了を待って次のスレッドを実行し、全てのスレッドの実行が終了するとこのスレッドも終了します 
     9         */ 
    510        public class SerialExecutor extends Executor 
    611        { 
    …… 
    813                private var _current:Thread; 
    914                 
    10                 protected override function initialize():void 
     15                /** 
     16                 * @inheritDoc 
     17                 */ 
     18                override public function interrupt():void 
    1119                { 
    12                         _index = 0; 
    13                         _current = null; 
     20                        // 元の割り込み処理を呼び出す 
     21                        super.interrupt(); 
     22                         
     23                        // 現在実行されているスレッドがあればそれにも割り込み処理をかける 
     24                        if (_current != null) { 
     25                                _current.interrupt(); 
     26                        } 
    1427                } 
    1528                 
    16                 protected override function execute():void 
     29                /** 
     30                 * 実行 
     31                 */ 
     32                override protected function run():void 
    1733                { 
     34                        // 現在実行されているスレッドのインデックス 
     35                        _index = 0; 
     36                        // 現在実行されているスレッド 
     37                        _current = null; 
     38                         
     39                        runThread(); 
     40                } 
     41                 
     42                /** 
     43                 * スレッド実行 
     44                 */ 
     45                private function runThread():void 
     46                { 
     47                        // 実行されていたスレッドがあれば 
    1848                        if (_current != null) { 
     49                                // 実行されていたスレッドを破棄 
    1950                                _current = null; 
     51                                // 次のインデックスへ 
    2052                                _index++; 
    2153                        } 
    2254                         
     55                        // もう実行するスレッドがない場合終了する 
    2356                        if (_threads.length <= _index) { 
    24                                 terminate(); 
    2557                                return; 
    2658                        } 
    2759                         
     60                        // 新たなスレッドを取得 
    2861                        var thread:Thread = _threads[_index]; 
    2962                         
     63                        // 現在実行されているスレッドに設定 
    3064                        _current = thread; 
    3165                         
    32                         thread.begin(); 
     66                        // スレッドを開始 
     67                        thread.start(); 
     68                        // 終了を待つ 
    3369                        thread.join(); 
    34                 } 
    35                  
    36                 public override function toString():String 
    37                 { 
    38                         return '[SerialExecutor]'; 
     70                         
     71                        // スレッドが終了した際に再びこのメソッドが実行されるよう設定 
     72                        next(runThread); 
    3973                } 
    4074        }