I am going NUTS here! I just changed the code so the thread does not
actually die, simply goes into a WaitHandle.WaitAny until there are
more images to downsize and the handles STILL are going up and not
coming down!!!!!!!!!!!!!!!!
I have looked in MSDN and don't see anything about having to do any
clean up on WaitHandle. Am I missing something? Come on, this has to
be something brain dead simple, I know how to code and debug, from
everything I can tell, I am crossing all the T's and dotting all the
i's in my clean up code.
Willy, in your very first post of this thread, you said: "My guess is
that they are no thread handles, but event handles." It HAS to be
event handles, the problem is I cannot find any information on
cleaning up event handles in managed code. Can you elaborate on the
concept of leaking event handles?
Cartoper
Here is my complete WebUpdate class:
/// <summary>
/// Updates the web site images
/// </summary>
public class WebUpdate : IDisposable
{
private static readonly log4net.ILog log =
log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
private readonly string rootDir;
private readonly string webRoot;
private IDictionary<string, IFileProcessor> filesToProcess = new
SortedDictionary<string, IFileProcessor> ();
private Thread webUpdateThread = null;
private ReaderWriterLock filesToProcessRWL = new
ReaderWriterLock();
private AutoResetEvent goEvent = new AutoResetEvent(false);
private AutoResetEvent stopEvent = new AutoResetEvent(false);
private AutoResetEvent killEvent = new AutoResetEvent(false);
private volatile bool isUpdating = false;
private ImageFolder thumbnailFld = null;
private ImageFolder imageFld = null;
public event ProcessStepHandler FilesUpdateProgress;
public event ProcessCompleteHandler FileUpdateComplete;
internal WebUpdate(string rootDir, string webRoot)
{
this.rootDir = rootDir;
this.webRoot = webRoot;
}
public void Dispose()
{
if (this.ThreadingStopped == false)
{
this.killEvent.Set();
this.webUpdateThread.Join();
}
goEvent.Close();
stopEvent.Close();
killEvent.Close();
}
/// <summary>
/// This is true when the thread is actively updating the web site
/// </summary>
public bool IsUpdating
{
get { return isUpdating; }
}
/// <summary>
///
/// </summary>
/// <param name="filesToProcess"></param>
internal void SetFilesToProcess(IDictionary<string,
IFileProcessor> filesToProcess)
{
this.filesToProcessRWL.AcquireWriterLock(-1);
try
{
foreach(KeyValuePair<string, IFileProcessor> kvp in
filesToProcess)
{
this.filesToProcess[kvp.Key] = kvp.Value;
}
}
finally
{
this.filesToProcessRWL.ReleaseWriterLock();
}
}
/// <summary>
/// The total number of images to process
/// </summary>
public int TotalCount
{
get {
this.filesToProcessRWL.AcquireReaderLock(-1);
try
{
return this.filesToProcess.Count;
}
finally
{
this.filesToProcessRWL.ReleaseReaderLock();
}
}
}
/// <summary>
/// Deletes a folder from the web server system
/// </summary>
static public void DeleteWebFolder(string webRoot, string
relativePath)
{
string fullpath = webRoot + relativePath;
DirectoryInfo di = new DirectoryInfo(fullpath);
if (di.Exists)
{
di.Delete(true);
}
}
/// <summary>
/// Starts the background thread that will update the images.
/// </summary>
/// <param name="thumbnail">This size of the thumbnail image</
param>
/// <param name="image">The size of the large preview image</
param>
public void Start(int thumbnail, int image)
{
if (this.IsUpdating == false)
{
log.InfoFormat("Start({0}, {1})", thumbnail, image);
this.thumbnailFld = new ImageFolder("tn", thumbnail);
this.imageFld = new ImageFolder("imgs", image);
if (this.webUpdateThread == null)
{
// Debug.WriteLine(String.Format("1 handle count
before new ThreadStart(): {0}", General.HandleNThreadCount));
this.webUpdateThread = new Thread(new
ThreadStart(ProcessFileList));
this.webUpdateThread.Start();
// Debug.WriteLine(String.Format("2 handle count after
this.webUpdateThread.Start(): {0}", General.HandleNThreadCount));
}
else
{
Debug.Assert(ThreadingStopped == false);
this.stopEvent.Reset();
this.goEvent.Set();
}
}
}
/// <summary>
///
/// </summary>
public void Stop()
{
Debug.Assert(ThreadingStopped == false);
if (this.IsUpdating)
{
this.stopEvent.Set();
}
}
/// <summary>
/// true if the background thread is *NOT* running
/// </summary>
private bool ThreadingStopped
{
get
{
return this.webUpdateThread == null ||
(this.webUpdateThread.ThreadState &
System.Threading.ThreadState.Stopped) ==
System.Threading.ThreadState.Stopped;
}
}
/// <summary>
/// The background thread
/// </summary>
private void ProcessFileList()
{
while (true)
{
isUpdating = true;
List<IFileProcessDataError> errorList = new
List<IFileProcessDataError>();
long totalTicks = 0;
int cnt = 0;
log.Info("ProcessFileList() started");
while(this.filesToProcess.Count > 0)
{
string filepath = string.Empty;
IFileProcessor fileProcessor = null;
this.filesToProcessRWL.AcquireWriterLock(-1);
try
{
IEnumerator<KeyValuePair<string, IFileProcessor>>
enumerator = this.filesToProcess.GetEnumerator();
enumerator.Reset();
enumerator.MoveNext();
KeyValuePair<string, IFileProcessor> kvp =
enumerator.Current;
this.filesToProcess.Remove(kvp);
filepath = kvp.Key;
fileProcessor = kvp.Value;
}
finally
{
this.filesToProcessRWL.ReleaseWriterLock();
}
DateTime start = DateTime.Now;
FileInfo fi = new FileInfo(filepath);
string srcFolder = fi.FullName.Substring(0,
fi.FullName.Length - fi.Name.Length - 1);
string dstFolder = this.webRoot +
fi.Directory.FullName.Substring(this.rootDir.Length);
// log.DebugFormat("{0} --> file: [{1}] src := [{2}]
dest := [{3}]", General.GetClassNameWONS(fileProcessor), fi.Name,
srcFolder, dstFolder);
FileProcessData fpd = new FileProcessData(srcFolder,
dstFolder, fi.Name);
try
{
fileProcessor.Process(fpd, this.ImageFolderList);
}
catch (Exception ex)
{
log.FatalFormat("Process Image Exception: {0} -->
{1}\n srcFolder => {2}\n dstFolder => {3} \n filename => {4}",
General.GetClassNameWONS(ex), ex.Message, srcFolder, dstFolder,
fpd.Filename);
errorList.Add(new FileProcessDataError(fpd,
fileProcessor, ex));
}
TimeSpan processTime = DateTime.Now - start;
totalTicks += processTime.Ticks;
long averageTicks = totalTicks / ++cnt;
TimeSpan averageTime = new TimeSpan(averageTicks);
FireFilesUpdateProgress(this.TotalCount, averageTime);
if (this.stopEvent.WaitOne(1, false))
{
break;
}
}
isUpdating = false;
if (FileUpdateComplete != null)
{
FileUpdateComplete(this, new
CrunchImageErrorEventArgs(cnt, errorList));
}
WaitHandle[] waitHandles = new WaitHandle[2];
waitHandles[0] = this.killEvent;
waitHandles[1] = this.goEvent;
if (WaitHandle.WaitAny(waitHandles) == 0)
return;
}
//log.Info("ProcessFileList() ended.");
}
/// <summary>
/// The collection of folders in which to copy the images to
/// </summary>
/// <remarks>
/// It is very important that the order of these folders go from
largest image size to smallest.
/// </remarks>
private IEnumerable<ImageFolder> ImageFolderList
{
get
{
yield return this.imageFld;
yield return this.thumbnailFld;
}
}
/// <summary>
///
/// </summary>
/// <param name="count"></param>
private void FireFilesUpdateProgress(int count, TimeSpan
processTime)
{
if (FilesUpdateProgress != null)
{
FilesUpdateProgress(this, new CruchImageEventArgs(count,
processTime));
}
}
}
