終了していないスレッドを調べるクラス

ワーカースレッドが終了していないため、メインウインドウは消えてもプロセスが残ってしまう場合があります。
その場合、原因のスレッドを突き止めて終わらない原因を修正しなければいけません。
しかし、開発環境では再現できないケースなどもあると思います。その場合のデバッグ用クラスを作ってみました。

基本的に、"new Thread"を"TraceableThread.CreateThread"に置換して、メインウインドウの
FormClosedイベントあたりでTimerProcTraceを呼んであげるだけです。
そうすると、指定ミリ秒毎に終了していないスレッドがある場合、作成時のスタックトレース付きでデバッグ出力に出します。
開発環境が入っていない(入れられない)場合でも、DebugViewなどで確認できます。

VS2008で作りましたが、多分.NET2.0以降なら動くと思います。

view plainprint?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4. using System.Threading;  
5. using System.Diagnostics;  
6. using System.Reflection;  
7.   
8. namespace Diagnostics  
9. {  
10.     /// <summary>  
11.     /// スレッドの追跡を行えます。  
12.     /// 終了していないスレッドを調べるのに役立ちます。  
13.     /// </summary>  
14.     public static class TraceableThread  
15.     {  
16.         private static List<Thread> m_listThread;  
17.         private static List<StackTrace> m_listStackTrace;  
18.         private static Timer m_timerRemove;  
19.         private static Timer m_timerTrace;  
20.         private static Object m_sync;  
21.   
22.         /// <summary>  
23.         /// 静的コンストラクタ  
24.         /// </summary>  
25.         static TraceableThread()  
26.         {  
27.             // 初期化  
28.             m_listThread = new List<Thread>();  
29.             m_listStackTrace = new List<StackTrace>();  
30.             m_sync = new Object();  
31.   
32.             // スレッド終了監視タイマー  
33.             m_timerRemove = new Timer(new TimerCallback(TimerProcRemove), null, 1000, 1000);  
34.         }  
35.   
36.         /// <summary>  
37.         /// スレッドの終了を監視し、スレッドリストを更新します。  
38.         /// </summary>  
39.         private static void TimerProcRemove(Object obj)  
40.         {  
41.             lock (m_sync)  
42.             {  
43.                 List<Thread> remove = new List<Thread>();  
44.   
45.                 // 終了しているスレッドを探す  
46.                 foreach (Thread trd in m_listThread)  
47.                 {  
48.                     try  
49.                     {  
50.                         if (trd.Join(0) == true)  
51.                         {  
52.                             remove.Add(trd);  
53.                         }  
54.                     }  
55.                     catch (ThreadStateException)  
56.                     {  
57.                         // スレッドが開始されていない場合  
58.                         continue;  
59.                     }  
60.                 }  
61.   
62.                 // リストから削除する  
63.                 foreach (Thread trd in remove)  
64.                 {  
65.                     int nIndex = m_listThread.IndexOf(trd);  
66.                     m_listThread.RemoveAt(nIndex);  
67.                     m_listStackTrace.RemoveAt(nIndex);  
68.                 }  
69.             }  
70.         }  
71.   
72.         /// <summary>  
73.         /// new Thread(ParameterizedThreadStart start)の代わりに呼んでください  
74.         /// </summary>  
75.         public static Thread CreateThread(ParameterizedThreadStart start)  
76.         {  
77.             StackTrace trace = new StackTrace(true);  
78.             Thread thread;  
79.   
80.             lock (m_sync)  
81.             {  
82.                 m_listStackTrace.Add(trace);  
83.   
84.                 thread = new Thread(start);  
85.   
86.                 m_listThread.Add(thread);  
87.             }  
88.   
89.             return thread;  
90.         }  
91.   
92.         /// <summary>  
93.         /// new Thread(ThreadStart start)の代わりに呼んでください  
94.         /// </summary>  
95.         public static Thread CreateThread(ThreadStart start)  
96.         {  
97.             StackTrace trace = new StackTrace(true);  
98.             Thread thread;  
99.   
100.             lock (m_sync)  
101.             {  
102.                 m_listStackTrace.Add(trace);  
103.   
104.                 thread = new Thread(start);  
105.   
106.                 m_listThread.Add(thread);  
107.             }  
108.   
109.             return thread;  
110.         }  
111.   
112.         /// <summary>  
113.         /// new Thread(ParameterizedThreadStart start, int maxStackSize)の代わりに呼んでください  
114.         /// </summary>  
115.         public static Thread CreateThread(ParameterizedThreadStart start, int maxStackSize)  
116.         {  
117.             StackTrace trace = new StackTrace(true);  
118.             Thread thread;  
119.   
120.             lock (m_sync)  
121.             {  
122.                 m_listStackTrace.Add(trace);  
123.   
124.                 thread = new Thread(start, maxStackSize);  
125.   
126.                 m_listThread.Add(thread);  
127.             }  
128.   
129.             return thread;  
130.         }  
131.   
132.         /// <summary>  
133.         /// new Thread(ThreadStart start, int maxStackSize)の代わりに呼んでください  
134.         /// </summary>  
135.         public static Thread CreateThread(ThreadStart start, int maxStackSize)  
136.         {  
137.             StackTrace trace = new StackTrace(true);  
138.             Thread thread;  
139.   
140.             lock (m_sync)  
141.             {  
142.                 m_listStackTrace.Add(trace);  
143.   
144.                 thread = new Thread(start, maxStackSize);  
145.   
146.                 m_listThread.Add(thread);  
147.             }  
148.   
149.             return thread;  
150.         }  
151.   
152.         /// <summary>  
153.         /// スレッドの終了追跡を開始します。  
154.         /// メインウインドウのFormClosedイベントで呼び出すことで、  
155.         /// 終了していないスレッドを検出することができます。  
156.         /// </summary>  
157.         public static void TraceThreadTermination(int interval)  
158.         {  
159.             if (m_timerTrace == null)  
160.             {  
161.                 m_timerTrace = new Timer(new TimerCallback(TimerProcTrace), null, interval, interval);  
162.             }  
163.         }  
164.   
165.         /// <summary>  
166.         /// 終了していないスレッドをTraceに出力します。  
167.         /// </summary>  
168.         private static void TimerProcTrace(object obj)  
169.         {  
170.             lock (m_sync)  
171.             {  
172.                 for (int i = 0; i < m_listThread.Count; i++)  
173.                 {  
174.                     Trace.WriteLine("");  
175.                     Trace.WriteLine(DateTime.Now.ToLongTimeString());  
176.                     Trace.WriteLine("■終了していないスレッドを検出しました！");  
177.                     Trace.WriteLine("Name = " + m_listThread[i].Name + ", ManagedThreadId = " + m_listThread[i].ManagedThreadId.ToString());  
178.                     Trace.WriteLine("スレッド作成時のスタックトレースは次の通りです。");  
179.                     Trace.WriteLine(m_listStackTrace[i].ToString());  
180.                 }  
181.             }  
182.         }  
183.     }  
184. }  

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Reflection;

namespace Diagnostics
{
    /// <summary>
    /// スレッドの追跡を行えます。
    /// 終了していないスレッドを調べるのに役立ちます。
    /// </summary>
    public static class TraceableThread
    {
        private static List<Thread> m_listThread;
        private static List<StackTrace> m_listStackTrace;
        private static Timer m_timerRemove;
        private static Timer m_timerTrace;
        private static Object m_sync;

        /// <summary>
        /// 静的コンストラクタ
        /// </summary>
        static TraceableThread()
        {
            // 初期化
            m_listThread = new List<Thread>();
            m_listStackTrace = new List<StackTrace>();
            m_sync = new Object();

            // スレッド終了監視タイマー
            m_timerRemove = new Timer(new TimerCallback(TimerProcRemove), null, 1000, 1000);
        }

        /// <summary>
        /// スレッドの終了を監視し、スレッドリストを更新します。
        /// </summary>
        private static void TimerProcRemove(Object obj)
        {
            lock (m_sync)
            {
                List<Thread> remove = new List<Thread>();

                // 終了しているスレッドを探す
                foreach (Thread trd in m_listThread)
                {
                    try
                    {
                        if (trd.Join(0) == true)
                        {
                            remove.Add(trd);
                        }
                    }
                    catch (ThreadStateException)
                    {
                        // スレッドが開始されていない場合
                        continue;
                    }
                }

                // リストから削除する
                foreach (Thread trd in remove)
                {
                    int nIndex = m_listThread.IndexOf(trd);
                    m_listThread.RemoveAt(nIndex);
                    m_listStackTrace.RemoveAt(nIndex);
                }
            }
        }

        /// <summary>
        /// new Thread(ParameterizedThreadStart start)の代わりに呼んでください
        /// </summary>
        public static Thread CreateThread(ParameterizedThreadStart start)
        {
            StackTrace trace = new StackTrace(true);
            Thread thread;

            lock (m_sync)
            {
                m_listStackTrace.Add(trace);

                thread = new Thread(start);

                m_listThread.Add(thread);
            }

            return thread;
        }

        /// <summary>
        /// new Thread(ThreadStart start)の代わりに呼んでください
        /// </summary>
        public static Thread CreateThread(ThreadStart start)
        {
            StackTrace trace = new StackTrace(true);
            Thread thread;

            lock (m_sync)
            {
                m_listStackTrace.Add(trace);

                thread = new Thread(start);

                m_listThread.Add(thread);
            }

            return thread;
        }

        /// <summary>
        /// new Thread(ParameterizedThreadStart start, int maxStackSize)の代わりに呼んでください
        /// </summary>
        public static Thread CreateThread(ParameterizedThreadStart start, int maxStackSize)
        {
            StackTrace trace = new StackTrace(true);
            Thread thread;

            lock (m_sync)
            {
                m_listStackTrace.Add(trace);

                thread = new Thread(start, maxStackSize);

                m_listThread.Add(thread);
            }

            return thread;
        }

        /// <summary>
        /// new Thread(ThreadStart start, int maxStackSize)の代わりに呼んでください
        /// </summary>
        public static Thread CreateThread(ThreadStart start, int maxStackSize)
        {
            StackTrace trace = new StackTrace(true);
            Thread thread;

            lock (m_sync)
            {
                m_listStackTrace.Add(trace);

                thread = new Thread(start, maxStackSize);

                m_listThread.Add(thread);
            }

            return thread;
        }

        /// <summary>
        /// スレッドの終了追跡を開始します。
        /// メインウインドウのFormClosedイベントで呼び出すことで、
        /// 終了していないスレッドを検出することができます。
        /// </summary>
        public static void TraceThreadTermination(int interval)
        {
            if (m_timerTrace == null)
            {
                m_timerTrace = new Timer(new TimerCallback(TimerProcTrace), null, interval, interval);
            }
        }

        /// <summary>
        /// 終了していないスレッドをTraceに出力します。
        /// </summary>
        private static void TimerProcTrace(object obj)
        {
            lock (m_sync)
            {
                for (int i = 0; i < m_listThread.Count; i++)
                {
                    Trace.WriteLine("");
                    Trace.WriteLine(DateTime.Now.ToLongTimeString());
                    Trace.WriteLine("■終了していないスレッドを検出しました！");
                    Trace.WriteLine("Name = " + m_listThread[i].Name + ", ManagedThreadId = " + m_listThread[i].ManagedThreadId.ToString());
                    Trace.WriteLine("スレッド作成時のスタックトレースは次の通りです。");
                    Trace.WriteLine(m_listStackTrace[i].ToString());
                }
            }
        }
    }
}