aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Framework/ThreadTracker.cs
blob: 42e3879e4e2a4a5677dae72c33250cfb363ff223 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace OpenSim.Framework
{
    public static class ThreadTracker
    {
        public static List<ThreadTrackerItem> m_Threads;
        public static System.Threading.Thread ThreadTrackerThread;
        private static readonly long ThreadTimeout = 30 * 10000000;

        static ThreadTracker()
        {
#if DEBUG
            m_Threads = new List<ThreadTrackerItem>();
            ThreadTrackerThread = new Thread(ThreadTrackerThreadLoop);
            ThreadTrackerThread.Name = "ThreadTrackerThread";
            ThreadTrackerThread.IsBackground = true;
            ThreadTrackerThread.Priority = System.Threading.ThreadPriority.BelowNormal;
            ThreadTrackerThread.Start();
#endif
        }

        private static void ThreadTrackerThreadLoop()
        {
            while (true)
            {
                Thread.Sleep(5000);
                CleanUp();
            }
        }

        public static void Add(System.Threading.Thread thread)
        {
#if DEBUG
            lock (m_Threads)
            {
                ThreadTrackerItem tti = new ThreadTrackerItem();
                tti.Thread = thread;
                tti.LastSeenActive = DateTime.Now.Ticks;
                m_Threads.Add(tti);
            }
#endif
        }

        public static void Remove(System.Threading.Thread thread)
        {
#if DEBUG
            lock (m_Threads)
            {
                foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
                {
                    if (tti.Thread == thread)
                        m_Threads.Remove(tti);
                }
            }
#endif
        }

        public static void CleanUp()
        {
            lock (m_Threads)
            {
                foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
                {
                    if (tti.Thread.IsAlive)
                    {
                        // Its active
                        tti.LastSeenActive = DateTime.Now.Ticks;
                    }
                    else
                    {
                        // Its not active -- if its expired then remove it
                        if (tti.LastSeenActive + ThreadTimeout < DateTime.Now.Ticks)
                            m_Threads.Remove(tti);
                    }
                }
            }
        }

        public static List<Thread> GetThreads()
        {
            if (m_Threads == null)
                return null;

            List<Thread> threads = new List<Thread>();
            lock (m_Threads)
            {
                foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
                {
                    threads.Add(tti.Thread);
                }
            }
            return threads;
        }

        public class ThreadTrackerItem
        {
            public System.Threading.Thread Thread;
            public long LastSeenActive;
        }
    }
}