如何检测客户端线程何时退出

这是一个有趣的图书馆作家的困境。在我的库中(在我的例子中是 EasyNetQ(，我正在分配线程本地资源。因此，当客户端创建一个新线程，然后在我的库上调用某些方法时，就会创建新的资源。在 EasyNetQ 的情况下，当客户端在新线程上调用"发布"时，会创建一个到 RabbitMQ 服务器的新通道。我希望能够检测客户端线程何时退出，以便清理资源(通道(。

我想出的唯一方法是创建一个新的"观察者"线程，该线程只是阻止对客户端线程的 Join 调用。这里有一个简单的演示：

首先是我的"图书馆"。它获取客户端线程，然后创建一个在"加入"上阻塞的新线程：

public class Library
{
    public void StartSomething()
    {
        Console.WriteLine("Library says: StartSomething called");
        var clientThread = Thread.CurrentThread;
        var exitMonitorThread = new Thread(() =>
        {
            clientThread.Join();
            Console.WriteLine("Libaray says: Client thread existed");
        });
        exitMonitorThread.Start();
    }
}

下面是使用我的库的客户端。它创建一个新线程，然后调用我的库的 StartSomething 方法：

public class Client
{
    private readonly Library library;
    public Client(Library library)
    {
        this.library = library;
    }
    public void DoWorkInAThread()
    {
        var thread = new Thread(() =>
        {
            library.StartSomething();
            Thread.Sleep(10);
            Console.WriteLine("Client thread says: I'm done");
        });
        thread.Start();
    }
}

当我像这样运行客户端时：

var client = new Client(new Library());
client.DoWorkInAThread();
// give the client thread time to complete
Thread.Sleep(100);

我得到这个输出：

Library says: StartSomething called
Client thread says: I'm done
Libaray says: Client thread existed

所以它有效，但它很丑陋。我真的不喜欢所有这些被阻塞的观察者线程徘徊的想法。有没有更好的方法

？

第一种选择。

提供一个返回实现 IDisposable 的工作线程的方法，并在文档中明确指出不应在线程之间共享工作线程。下面是修改后的库：

public class Library
{
    public LibraryWorker GetLibraryWorker()
    {
        return new LibraryWorker();
    }
}
public class LibraryWorker : IDisposable
{
    public void StartSomething()
    {
        Console.WriteLine("Library says: StartSomething called");
    }
    public void Dispose()
    {
        Console.WriteLine("Library says: I can clean up");
    }
}

客户端现在稍微复杂一些：

public class Client
{
    private readonly Library library;
    public Client(Library library)
    {
        this.library = library;
    }
    public void DoWorkInAThread()
    {
        var thread = new Thread(() =>
        {
            using(var worker = library.GetLibraryWorker())
            {
                worker.StartSomething();
                Console.WriteLine("Client thread says: I'm done");
            }
        });
        thread.Start();
    }
}

此更改的主要问题是它是 API 的重大更改。现有客户端将不得不重写。现在这不是一件坏事，这意味着重新访问它们并确保它们正确清理。

不间断的第二种选择。API 为客户端提供了一种声明"工作范围"的方法。范围完成后，库可以清理。该库提供了一个实现 IDisposable 的工作范围，但与上面的第一种替代方法不同，StartSomething 方法保留在 Library 类上：

public class Library
{
    public WorkScope GetWorkScope()
    {
        return new WorkScope();
    }
    public void StartSomething()
    {
        Console.WriteLine("Library says: StartSomething called");
    }
}
public class WorkScope : IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("Library says: I can clean up");
    }
}

客户端只需将 StartSomething 调用放在 WorkScope 中...

public class Client
{
    private readonly Library library;
    public Client(Library library)
    {
        this.library = library;
    }
    public void DoWorkInAThread()
    {
        var thread = new Thread(() =>
        {
            using(library.GetWorkScope())
            {
                library.StartSomething();
                Console.WriteLine("Client thread says: I'm done");
            }
        });
        thread.Start();
    }
}

我比第一种选择更喜欢它，因为它不会强迫库用户考虑范围。

public class ThreadMonitor
{
    public static event Action<int> Finalized = delegate { };
    private readonly int m_threadId = Thread.CurrentThread.ManagedThreadId;
    ~ThreadMonitor()
    {
        Finalized(ThreadId);
    }
    public int ThreadId
    {
        get { return m_threadId; }
    }
}
public static class Test
{
    private readonly static ThreadLocal<ThreadMonitor> s_threadMonitor = 
        new ThreadLocal<ThreadMonitor>(() => new ThreadMonitor());
    public static void Main()
    {
        ThreadMonitor.Finalized += i => Console.WriteLine("thread {0} closed", i);
        var thread = new Thread(() =>
        {
            var threadMonitor = s_threadMonitor.Value;
            Console.WriteLine("start work on thread {0}", threadMonitor.ThreadId);
            Thread.Sleep(1000);
            Console.WriteLine("end work on thread {0}", threadMonitor.ThreadId);
        });
        thread.Start();
        thread.Join();
        // wait for GC to collect and finalize everything
        GC.GetTotalMemory(forceFullCollection: true);
        Console.ReadLine();
    }
}

public interface IThreadCompletedNotifier
{
   event Action ThreadCompleted;
}
public class Library
{
    public void StartSomething(IThreadCompletedNotifier notifier)
    {
        Console.WriteLine("Library says: StartSomething called");
        notifier.ThreadCompleted += () => Console.WriteLine("Libaray says: Client thread existed");
        var clientThread = Thread.CurrentThread;
        exitMonitorThread.Start();
    }
}

public class Client : IThreadCompletedNotifier
{
    private readonly Library library;
    public event Action ThreadCompleted;
    public Client(Library library)
    {
        this.library = library;
    }
    public void DoWorkInAThread()
    {
        var thread = new Thread(() =>
        {
            library.StartSomething();
            Thread.Sleep(10);
            Console.WriteLine("Client thread says: I'm done");
            if(ThreadCompleted != null)
            {
               ThreadCompleted();
            }
        });
        thread.Start();
    }
}