【发布时间】：2009-01-27 12:56:51
【问题描述】：
我似乎在这段代码中有内存泄漏。它是一个控制台应用程序，它创建了几个类（WorkerThread），每个类都以指定的时间间隔写入控制台。 Threading.Timer 用于执行此操作，因此写入控制台是在单独的线程中执行的（在从 ThreadPool 获取的单独线程中调用 TimerCallback）。更复杂的是，MainThread 类与 FileSystemWatcher 的 Changed 事件挂钩；当 test.xml 文件更改时，会重新创建 WorkerThread 类。
每次保存文件时（每次重新创建 WorkerThread 并因此重新创建 Timer），任务管理器中的内存都会增加（Mem Usage，有时还会增加 VM Size）；此外，在 .Net Memory Profiler (v3.1) 中，WorkerThread 类的 Undisposed Instances 增加了两个（但这可能是一个红鲱鱼，因为我读过 .Net Memory Profiler 有一个错误，它很难检测到处理类。
无论如何，这是代码 - 有谁知道出了什么问题？
编辑：我已将类创建移出 FileSystemWatcher.Changed 事件处理程序，这意味着 WorkerThread 类总是在同一个线程中创建。我为静态变量添加了一些保护。我还提供了线程信息以更清楚地显示正在发生的事情，并且一直在使用 Timer 与使用显式线程进行交换；但是，内存仍在泄漏！ Mem Usage 一直在缓慢增加（这仅仅是由于控制台窗口中的额外文本吗？），并且当我更改文件时 VM Size 会增加。这是最新版本的代码：
编辑 这似乎主要是控制台在写入时耗尽内存的问题。显式编写的线程仍然存在增加内存使用量的问题。见my answer below。
class Program
{
private static List<WorkerThread> threads = new List<WorkerThread>();
static void Main(string[] args)
{
MainThread.Start();
}
}
public class MainThread
{
private static int _eventsRaised = 0;
private static int _eventsRespondedTo = 0;
private static bool _reload = false;
private static readonly object _reloadLock = new object();
//to do something once in handler, though
//this code would go in onStart in a windows service.
public static void Start()
{
WorkerThread thread1 = null;
WorkerThread thread2 = null;
Console.WriteLine("Start: thread " + Thread.CurrentThread.ManagedThreadId);
//watch config
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = "../../";
watcher.Filter = "test.xml";
watcher.EnableRaisingEvents = true;
//subscribe to changed event. note that this event can be raised a number of times for each save of the file.
watcher.Changed += (sender, args) => FileChanged(sender, args);
thread1 = new WorkerThread("foo", 10);
thread2 = new WorkerThread("bar", 15);
while (true)
{
if (_reload)
{
//create our two threads.
Console.WriteLine("Start - reload: thread " + Thread.CurrentThread.ManagedThreadId);
//wait, to enable other file changed events to pass
Console.WriteLine("Start - waiting: thread " + Thread.CurrentThread.ManagedThreadId);
thread1.Dispose();
thread2.Dispose();
Thread.Sleep(3000); //each thread lasts 0.5 seconds, so 3 seconds should be plenty to wait for the
//LoadData function to complete.
Monitor.Enter(_reloadLock);
thread1 = new WorkerThread("foo", 10);
thread2 = new WorkerThread("bar", 15);
_reload = false;
Monitor.Exit(_reloadLock);
}
}
}
//this event handler is called in a separate thread to Start()
static void FileChanged(object source, FileSystemEventArgs e)
{
Monitor.Enter(_reloadLock);
_eventsRaised += 1;
//if it was more than a second since the last event (ie, it's a new save), then wait for 3 seconds (to avoid
//multiple events for the same file save) before processing
if (!_reload)
{
Console.WriteLine("FileChanged: thread " + Thread.CurrentThread.ManagedThreadId);
_eventsRespondedTo += 1;
Console.WriteLine("FileChanged. Handled event {0} of {1}.", _eventsRespondedTo, _eventsRaised);
//tell main thread to restart threads
_reload = true;
}
Monitor.Exit(_reloadLock);
}
}
public class WorkerThread : IDisposable
{
private System.Threading.Timer timer; //the timer exists in its own separate thread pool thread.
private string _name = string.Empty;
private int _interval = 0; //thread wait interval in ms.
private Thread _thread = null;
private ThreadStart _job = null;
public WorkerThread(string name, int interval)
{
Console.WriteLine("WorkerThread: thread " + Thread.CurrentThread.ManagedThreadId);
_name = name;
_interval = interval * 1000;
_job = new ThreadStart(LoadData);
_thread = new Thread(_job);
_thread.Start();
//timer = new Timer(Tick, null, 1000, interval * 1000);
}
//this delegate instance does NOT run in the same thread as the thread that created the timer. It runs in its own
//thread, taken from the ThreadPool. Hence, no need to create a new thread for the LoadData method.
private void Tick(object state)
{
//LoadData();
}
//Loads the data. Called from separate thread. Lasts 0.5 seconds.
//
//private void LoadData(object state)
private void LoadData()
{
while (true)
{
for (int i = 0; i < 10; i++)
{
Console.WriteLine(string.Format("Worker thread {0} ({2}): {1}", _name, i, Thread.CurrentThread.ManagedThreadId));
Thread.Sleep(50);
}
Thread.Sleep(_interval);
}
}
public void Stop()
{
Console.WriteLine("Stop: thread " + Thread.CurrentThread.ManagedThreadId);
//timer.Dispose();
_thread.Abort();
}
#region IDisposable Members
public void Dispose()
{
Console.WriteLine("Dispose: thread " + Thread.CurrentThread.ManagedThreadId);
//timer.Dispose();
_thread.Abort();
}
#endregion
}
【问题讨论】：
-
你能在没有计时器的情况下完成这项工作，看看它是否仍然出现泄漏？这将帮助您确定计时器是否是实际问题。
-
好主意。用一个简单地等待的显式线程替换计时器会产生完全相同的结果。
-
一时兴起，我将（新）代码复制到一个新项目中并尝试了它——它似乎完全符合标准垃圾收集行为，以“泄漏”它的方式。在主循环中强制使用 GC.Collect() 可以完全停止泄漏（显然是以性能为代价的）。我错过了什么吗？
-
有趣。大概您正在创建线程，而不是使用计时器（顺便说一句，使用计时器是我的首选）？我不是垃圾回收方面的专家：您希望应用程序占用的内存在多长时间后停止增加？
标签： c# .net multithreading memory timer