001    /*
002     * Copyright (c) 2009 The openGion Project.
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     *     http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
013     * either express or implied. See the License for the specific language
014     * governing permissions and limitations under the License.
015     */
016    package org.opengion.hayabusa.report2;
017    
018    import java.util.HashMap;
019    import java.util.Map;
020    
021    /**
022     * 蟶ｳ逾ｨ蜃ｦ逅?ｒ陦後≧蜷?せ繝ｬ繝?ラ繧堤ｮ｡逅?☆繧九け繝ｩ繧ｹ縺ｧ縺吶?
023     *
024     * 蜷?せ繝ｬ繝?ラ縺ｯ縲∝?驛ｨ逧?↓繝励?繝ｫ縺輔ｌ縺ｾ縺吶?
025     * 繧ｹ繝ｬ繝?ラ縺ｮID縺ｯOOoQueue#getThreadId()縺ｧ霑斐＆繧後ｋ蛟､縺ｧ縺吶?
026     * 繧ｹ繝ｬ繝?ラ縺檎函謌舌＆繧後ｋ繧ｿ繧､繝溘Φ繧ｰ縺ｯ縲√◎縺ｮID縺ｧ蛻昴ａ縺ｦ繧ｹ繧ｿ繝?け隕∵ｱゅ′譚･縺?insertQueue()縺悟他縺ｰ繧後◆)譎ゅ〒縺吶?
027     *
028     * 謖?ｮ壹?繧ｹ繝ｬ繝?ラ繧堤ｵゆｺ?☆繧九↓縺ｯ縲’unishThread( key )繧貞他縺ｳ蜃ｺ縺励∪縺吶?
029     * 蜈ｨ縺ｦ縺ｮ繧ｹ繝ｬ繝?ラ繧堤ｵゆｺ?☆繧九↓縺ｯ縲’unishAllThreads()繧貞他縺ｳ蜃ｺ縺励∪縺吶?
030     *
031     * 迴ｾ譎らせ縺ｧ縺ｮ螳溯｣?〒縺ｯ縲∫函謌舌＆繧後◆繧ｹ繝ｬ繝?ラ縺ｫ蟇ｾ縺励※縺ｮ逶｣隕悶?陦後▲縺ｦ縺?∪縺帙ｓ縲?
032     * 縺薙ｌ縺ｯ縲∫音螳壹?繧ｹ繝ｬ繝?ラ縺後ヵ繝ｪ繝ｼ繧ｺ縺励◆髫帙?螟夜Κ縺九ｉ蠑ｷ蛻ｶ邨ゆｺ?ｒ陦後♀縺?→縺吶ｋ縺ｨ縲?
033     * 逶｣隕悶せ繝ｬ繝?ラ繧ゅヵ繝ｪ繝ｼ繧ｺ縺励※縺励∪縺?撫鬘後′縺ゅｋ縺溘ａ縺ｧ縺吶?
034     * (菴?＠縲?縺､縺ｮsoffice.bin縺ｮ繝励Ο繧ｻ繧ｹ縺ｫ蟇ｾ縺励※繧ｷ繝ｪ繧｢繝ｫ縺ｫ蟇ｾ縺励※蜃ｦ逅?＠縺ｦ縺?ｋ髯舌ｊ縺ｧ縺ｯ縲?
035     *  繝輔Μ繝ｼ繧ｺ蝠城｡後?逋ｺ逕溘＠縺ｪ縺?ｈ縺?〒縺?
036     *
037     * @og.group 蟶ｳ逾ｨ繧ｷ繧ｹ繝?Β
038     *
039     * @version  4.0
040     * @author   Hiroki.Nakamura
041     * @since    JDK1.6
042     */
043    public final class ExecThreadManager {
044    
045            /**
046             * 繧ｹ繝ｬ繝?ラ繝励?繝ｫ
047             */
048            private static final Map<String, ExecThread>      pool    = new HashMap<String, ExecThread>();
049            private static boolean debug    = false; // 4.3.0.0 (2008/07/15) 繝?ヰ繝?げ霑ｽ蜉?
050    
051    //      /**
052    //       * 繝√ぉ繝?け繧ｹ繝ｬ繝?ラ縺ｮ螳溯｡碁俣髫?
053    //       */
054    //      private static final int REPORT_THREAD_CHECK_INTERVAL = 1000 * 2;
055    
056    //      /**
057    //       * OOo縺後け繝ｩ繝?す繝･縺励※縺?ｋ縺ｨ蛻､譁ｭ縺輔ｌ繧句●豁｢譎る俣
058    //       */
059    //      private static final int REPORT_THREAD_CRASH_TIME = 1000 * 2;
060    
061    //      /**
062    //       * 繝√ぉ繝?け逕ｨ縺ｮ繧ｹ繝ｬ繝?ラ繧帝幕蟋九＠縺ｾ縺?
063    //       */
064    //      static {
065    //              checkThreads();
066    //      }
067    
068            /**
069             * 繧ｪ繝悶ず繧ｧ繧ｯ繝医?逕滓?繧堤ｦ∵ｭ｢縺励∪縺?
070             */
071            private ExecThreadManager() {}
072    
073            /**
074             * 繧ｭ繝･繝ｼ繧定ｩｲ蠖薙☆繧九せ繝ｬ繝?ラ縺ｫ繧ｹ繧ｿ繝?け縺吶ｋ
075             *
076             * @og.rev 4.3.0.0 (2008/07/15) 繧ｹ繝ｬ繝?ラID縺ｫ繧ｷ繧ｹ繝?ΒID繧剃ｻ伜刈
077             *
078             * @param       queue   ExecQueue繧ｪ繝悶ず繧ｧ繧ｯ繝?
079             */
080            public static void insertQueue( final ExecQueue queue ) {
081                    // 4.3.3.6 (2008/11/15) 縺薙?驛ｨ蛻??荳崎ｦ√↑縺ｮ縺ｧ蜈?↓謌ｻ縺励∪縺?
082                    ExecThread oet = getExecThread( queue.getThreadId() );
083    //              ExecThread oet = getExecThread( queue.getSystemId() + "_" + queue.getThreadId() ); // 4.3.0.0 (2008/07/15) 繧ｷ繧ｹ繝?ΒID繧偵せ繝ｬ繝?ラID縺ｫ莉伜刈縺励∪縺吶?
084                    oet.stackQueue( queue );
085            }
086    
087            /**
088             * 繧ｭ繝･繝ｼ繧定ｩｲ蠖薙☆繧九せ繝ｬ繝?ラ縺ｫ繧ｹ繧ｿ繝?け縺吶ｋ
089             *
090             * 縺薙?繝｡繧ｽ繝?ラ縺ｧ縺ｯ縲∵里縺ｫ蜷後§繧ｹ繝ｬ繝?ラ縺悟ｭ伜惠縺吶ｋ縺九←縺?°繧偵メ繧ｧ繝?け縺帙★縺ｫ蠢?★
091             * 譁ｰ縺励＞繧ｹ繝ｬ繝?ラ繧堤函謌舌＠縲√く繝･繝ｼ繧貞?逅?＠縺ｾ縺吶?
092             * 縺ｾ縺溘?蜃ｦ逅?′螳御ｺ?＠縺溷ｾ後?縺昴?繧ｹ繝ｬ繝?ラ縺ｯ縲仝AIT縺吶ｋ縺薙→縺ｪ縺冗ｵゆｺ?＠縺ｾ縺吶?
093             *
094             * @og.rev 5.1.6.0 (2010/05/01) 譁ｰ隕丈ｽ懈?
095             *
096             * @param       queue   ExecQueue繧ｪ繝悶ず繧ｧ繧ｯ繝?
097             */
098            public static void insertQueueOnNewThread( final ExecQueue queue ) {
099                    ExecThread oet = new ExecThread( queue.getThreadId(), debug );
100                    oet.start();
101                    System.out.println( "[INFO]THREAD CREATED:THREAD-ID=" + queue.getThreadId() );
102                    oet.stackQueue( queue );
103                    oet.finishAfterExec();
104            }
105    
106            /**
107             * 隧ｲ蠖薙☆繧九せ繝ｬ繝?ラID繧呈戟縺､繧ｹ繝ｬ繝?ラ繧貞叙蠕励＠縺ｾ縺吶?
108             * 繧ｹ繝ｬ繝?ラ繝励?繝ｫ縺ｫ蟄伜惠縺励↑縺??蜷医?縲∵眠隕上↓菴懈?縺輔ｌ縺ｾ縺吶?
109             *
110             * @param       threadId        繧ｹ繝ｬ繝?ラID
111             *
112             * @return      ExecThread繧ｹ繝ｬ繝?ラ
113             */
114            private static ExecThread getExecThread( final String threadId ) {
115                    ExecThread oet = null;
116                    synchronized( pool ) {
117                            oet = pool.get( threadId );
118    
119                            // 繧ｹ繝ｬ繝?ラ縺檎ｵゆｺ?＠縺ｦ縺?ｋ蝣ｴ蜷医?縲∝?蠎ｦ菴懈?
120                            if( oet != null && !oet.isAlive() ) {
121                                    pool.remove( threadId );
122                                    oet = null;
123                            }
124    
125                            if( oet == null ) {
126                                    // oet = new ExecThread( threadId );
127                                    oet = new ExecThread( threadId, debug );
128                                    oet.start();
129                                    System.out.println( "[INFO]THREAD CREATED:THREAD-ID=" + threadId );
130                                    pool.put( threadId, oet );
131                            }
132                    }
133    
134                    return oet;
135            }
136    
137            /**
138             * 蜈ｨ縺ｦ縺ｮ繧ｹ繝ｬ繝?ラ繧堤ｵゆｺ?＠縺ｾ縺吶?
139             *
140             */
141            public static void finishAllThreads() {
142                    synchronized( pool ) {
143                            for( ExecThread oet : pool.values() ) {
144                                    oet.finish();
145                            }
146                            pool.clear();
147                            System.out.println( "[INFO]ALL THREADS FINISHED" );
148                    }
149            }
150    
151            /**
152             * 謖?ｮ壹?繧ｹ繝ｬ繝?ラ繧堤ｵゆｺ?＠縺ｾ縺吶?
153             *
154             * @param threadId 繧ｹ繝ｬ繝?ラID
155             */
156            public static void finishThread( final String threadId ) {
157                    synchronized( pool ) {
158                            ExecThread oet = pool.remove( threadId );
159                            if( oet != null ) {
160                                    oet.finish();
161                                    System.out.println( "[INFO]THREAD CREATED:THREAD-ID=" + threadId );
162                            }
163                    }
164            }
165    
166            /**
167             * 繧ｹ繝ｬ繝?ラ諠??縺ｮ繝槭ャ繝励ｒ霑斐＠縺ｾ縺吶?
168             *
169             * @return      繧ｹ繝ｬ繝?ラ諠??縺ｮ繝槭ャ繝?
170             */
171            public static Map<String, String> getThreadInfo() {
172                    Map<String, String> info = new HashMap<String, String>();
173                    synchronized( pool ) {
174                            for( Map.Entry<String, ExecThread> entry : pool.entrySet() ) {
175                                    info.put( entry.getKey(), entry.getValue().toString() );
176                            }
177                    }
178                    return info;
179            }
180    
181            /**
182             * 繝?ヰ繝?げ繝輔Λ繧ｰ縺ｮ險ｭ螳?
183             *
184             * @og.rev  4.3.0.0 (2008/07/15) 繝?ヰ繝?げ霑ｽ蜉?
185             *
186             * @param   flag 繝?ヰ繝?げ繝輔Λ繧ｰ [true:繝?ヰ繝?げ/false:騾壼ｸｸ]
187             */
188            public static void setDebug ( final boolean flag ){
189                    debug = flag;
190            }
191    
192    //      /**
193    //       * 逶｣隕也畑縺ｮ繧ｹ繝ｬ繝?ラ繧帝幕蟋九＠縺ｾ縺吶?
194    //       *
195    //       */
196    //      private static void checkThreads() {
197    //              new Thread() {
198    //                      public void run() {
199    //
200    //                              while( true ) {
201    //                                      try {
202    //                                              Thread.sleep( REPORT_THREAD_CHECK_INTERVAL );
203    //                                      }
204    //                                      catch( InterruptedException e ) {}
205    //
206    //                                      synchronized( pool ) {
207    //                                              for( Map.Entry<String, ExecThread> entry : pool.entrySet() ) {
208    //                                                      String id = entry.getKey();
209    //                                                      ExecThread oet = entry.getValue();
210    //
211    //                                                      System.out.println(oet.getExecTime());
212    //
213    //                                                      if( oet.getExecTime() > REPORT_THREAD_CRASH_TIME ) {
214    //                                                              System.out.println( "縲千屮隕悶?繧ｹ繝ｬ繝?ラID=" + id + "縺後け繝ｩ繝?す繝･縺励※縺?ｋ蜿ｯ閭ｽ諤ｧ縺後≠繧翫∪縺吶?縺ｧ縲∝牡霎ｼ隕∵ｱゅｒ逋ｺ陦後＠縺ｾ縺吶?(蜃ｦ逅?凾髢?" + String.valueOf( oet.getExecTime() ) + ")" );
215    //                                                              oet.interrupt();
216    //                                                      }
217    //                                              }
218    //                                      }
219    //                              }
220    //
221    //                      }
222    //              }.start();
223    //      }
224    
225    }