线程退出时如何处理 ThreadLocal 值？

Question

假设我有一个一次性类型：

class MyDisposable : IDisposable
{
    public void Dispose() { }
}

然后我希望每个线程都有自己的此类的本地副本，每个线程一个：

private readonly ThreadLocal<MyDisposable> localMyDisposable
    = new ThreadLocal<MyDisposable>(() => new MyDisposable());

现在我想确保在线程退出之前，我在该值上调用Dispose()如果它是创建的）。 有没有办法做到这一点？ 我的应用程序中的某些线程是短暂的，而有些则是长期存在的。 我想确保任何短命的人处理他们的价值观。

Answer 1

CLR 中没有用于通知线程退出的钩子。 GC 最终将删除线程本地值，但您似乎对快速处理感兴趣。

唯一的方法是让线程自己执行清理。

如果您使用任务而不是线程，您可以将延续附加到该任务，并确保在任务完成后清理和重置资源。 但是，您不能在此处使用ThreadLocal ，因为永远不能保证继续在同一线程上运行。

Answer 2

我最终实现了我自己的名为ThreadLocalDisposable<T> 。 它所做的是在创建时启动一个“清理”线程，并在ConcurrentDictionary跟踪每个线程创建的所有对象。 一旦一个线程停止，它最终会调用Action<T> cleanupMethod ，如果你愿意，它可以简单地是x => x.Dispose() 。

请注意，清理代码是在清理线程上调用的，而不是在实际创建和使用它的线程上调用的，因此无论您在那里做什么，都必须是线程安全的。

public class ThreadLocalDisposable<T> : IDisposable
    where T : IDisposable
{
    private readonly ConcurrentDictionary<Thread, T> valuesByThread
        = new ConcurrentDictionary<Thread, T>();
    private readonly Func<T> factoryMethod;
    private object disposedLock = new object();
    private bool disposed = false;

    public ThreadLocalDisposable(
        Func<T> factoryMethod,
        Action<T> cleanupMethod)
    {
        if (factoryMethod == null) throw new ArgumentNullException("factoryMethod");
        if (cleanupMethod == null) throw new ArgumentNullException("cleanupMethod");
        this.factoryMethod = factoryMethod;

        var disposerThread = new Thread(() =>
        {
            bool exit = false;
            while (!exit)
            {
                Thread.Sleep(1000);
                var removedValuesByThread = new List<KeyValuePair<Thread, T>>();
                foreach (var valueByThread in this.valuesByThread)
                {
                    if ((valueByThread.Key.ThreadState & ThreadState.Stopped) == ThreadState.Stopped)
                    {
                        removedValuesByThread.Add(valueByThread);
                    }
                }
                foreach (var removedValueByThread in removedValuesByThread)
                {
                    T value;
                    while (!this.valuesByThread.TryRemove(removedValueByThread.Key, out value))
                    {
                        Thread.Sleep(2);
                    }
                    cleanupMethod(value);
                }
                lock (this.disposedLock)
                {
                    exit = this.disposed;
                }
            }

            foreach (var valueByThread in this.valuesByThread)
            {
                var value = valueByThread.Value;
                cleanupMethod(value);
            }
            this.valuesByThread.Clear();
        });
        disposerThread.Start();
    }

    public T Value
    {
        get
        {
            if (!this.valuesByThread.ContainsKey(Thread.CurrentThread))
            {
                var newValue = this.factoryMethod();
                while (!this.valuesByThread.TryAdd(Thread.CurrentThread, newValue))
                {
                    Thread.Sleep(2);
                }
            }
            var result = this.valuesByThread[Thread.CurrentThread];
            return result;
        }
    }

    public void Dispose()
    {
        lock (this.disposedLock)
        {
            this.disposed = true; // tells disposer thread to shut down
        }
    }
}

已知问题：我的意思是让这个类在应用程序的整个生命周期都存在，所以当你处理它时，它只是尽力清理，但不一定清理整个对象列表，因为其他在处理线程获得最后一个可枚举副本后，线程仍然可以调用Value getter 并创建新对象。