I've got a resource that is shared across potentially many processes and needs to be cleaned up when no longer in use.
What's the easiest way in C# to maintain a usage count across processes so that the resource may be cleaned up when no longer used?
(If the last process to use the resources dies, it is ok to leave the resource unfreed so long as the next to use has a valid usage count).
You are describing a pattern implemented in .net remoting, where the consumer of a resource may be on a different machine. This works by forcing the consumer to release the object explicitly, backed up with a Lifetime Lease which automatically times the consumer out if they have not refreshed the lease.
Given that all of this is already in the .net framework I'd recommend using remoting to generate your framework.
If all processes are on the same machine, I'd create a file that contains the instance count. When the resource is provisioned by a process, the file should be opened for writing, effectively locking the file. The instance count should be read and incremented, then the write lock released on the file.
When a process exits (or is done with the resource), grab a write lock to the file and decrement the resource count. If the resource count is zero after the decrement, then initiate your cleanup procedure.
You will have to have retry logic in case a second process tries to grab a write lock on the shared file while the file is already open for writing by another process.
The important point is that the OS can give you an exclusive write lock, which is effectively your critical section.
The code I used:
internal sealed class InterProcessResource {
private static readonly string MutexNameThisProcess = "IPR-" + Guid.NewGuid().ToString();
private static readonly Mutex MutexThisProcess = new Mutex(true, MutexNameThisProcess);
private readonly MemoryMappedFile mmf;
private readonly string mutexName;
public InterProcessResource(string resourceName) {
this.mutexName = resourceName + "-mtx";
this.mmf = MemoryMappedFile.CreateOrOpen(resourceName + "-mmf", 16 * 1024, MemoryMappedFileAccess.ReadWrite);
}
public void Acquire(Action initAction) {
using (new Mutex(true, this.mutexName)) {
var currentList = ReadStringList(mmf);
if (currentList.Count == 0) {
initAction();
}
var newList = PruneMutexList(currentList);
newList.Add(MutexNameThisProcess);
WriteStringList(this.mmf, newList);
}
}
public void Release(Action freeAction) {
using (new Mutex(true, this.mutexName)) {
var currentList = ReadStringList(this.mmf);
var newList = PruneMutexList(currentList);
WriteStringList(this.mmf, newList);
if (newList.Count == 0) {
freeAction();
}
}
}
private static List<string> ReadStringList(MemoryMappedFile mmf) {
var list = new List<string>();
using (var stream = mmf.CreateViewStream()) {
var reader = new BinaryReader(stream);
int count = reader.ReadInt32();
for (int i = 0; i < count; i++) {
list.Add(reader.ReadString());
}
}
return list;
}
private static void WriteStringList(MemoryMappedFile mmf, List<string> newList) {
using (var stream = mmf.CreateViewStream()) {
var writer = new BinaryWriter(stream);
int count = newList.Count;
writer.Write(count);
for (int i = 0; i < count; i++) {
writer.Write(newList[i]);
}
}
}
// removes our mutex name AND any dead processes mutex names
private static List<string> PruneMutexList(List<string> list) {
var newList = new List<string>();
foreach (var s in list) {
if (s != MutexNameThisProcess) {
Mutex m;
if (Mutex.TryOpenExisting(s, out m)) {
newList.Add(s);
m.Dispose();
}
}
}
return newList;
}
}