4

我有ThreadStatic一个静态类的成员。静态类用于多线程环境。我想确保当线程返回到线程池（或重新使用）时，成员被释放（或重新初始化），因此特定线程的任何后续使用都会获得变量的新副本。该成员必须保持静态，因此实例成员不会真正提供帮助。

我尝试过使用ThreadLocal，AsyncLocal但CallContext这些都没有真正的帮助。（CallContext主要用于概念验证，它是一个 .net 标准应用程序，因此 callcontext 无论如何都不起作用）。

这只是我为重新创建我的问题而编写的示例代码，用于ThreadStatic测试。ThreadLocalAsyncLocalCallContext


    class Program
    {
        static void Main(string[] args)
        {
            var act = new List<Action<int>>()
            {
                v=> ThreadClass.Write(v),
                v=> ThreadClass.Write(v),
            };

            Parallel.ForEach(act, new ParallelOptions { MaxDegreeOfParallelism = 1 }, (val, _, index) => val((int)index));

            Console.WriteLine($"Main: ThreadId: {Thread.CurrentThread.ManagedThreadId} ThreadStatic = {ThreadClass.ThreadStatic} ThreadLocal = {ThreadClass.ThreadLocal.Value} AsyncLocal = {ThreadClass.AsyncLocal.Value} CallContext: {ThreadClass.CallContextData}");

            Console.ReadKey();
        }
    }

    public static class ThreadClass
    {
        static object _lock = new object();

        [ThreadStatic]
        public static string ThreadStatic;

        public static ThreadLocal<string> ThreadLocal = new ThreadLocal<string>(() => "default");


        public static readonly AsyncLocal<string> AsyncLocal = new AsyncLocal<string>();

        public static string CallContextData
        {
            get => CallContext.LogicalGetData("value") as string;
            set => CallContext.LogicalSetData("value", value);
        }

        static ThreadClass()
        {
            AsyncLocal.Value = "default";
        }


        public static void Write(int id)
        {
            lock (_lock)
            {
                Console.WriteLine($"{id} Init: ThreadId: {Thread.CurrentThread.ManagedThreadId} ThreadStatic = {ThreadStatic} ThreadLocal = {ThreadLocal.Value} AsyncLocal = {AsyncLocal.Value} CallContext: {ThreadClass.CallContextData}");

                ThreadStatic = $"Static({id})";
                ThreadLocal.Value = $"Local({id})";
                AsyncLocal.Value = $"Async({id})";
                CallContextData = $"Call({id})";

                Console.WriteLine($"{id} Chng: ThreadId: {Thread.CurrentThread.ManagedThreadId} ThreadStatic = {ThreadStatic} ThreadLocal = {ThreadLocal.Value} AsyncLocal = {AsyncLocal.Value} CallContext: {ThreadClass.CallContextData}");
            }

        }
    }

上面的代码在单个线程中运行，因此可以重复使用该线程。

0 Init: ThreadId: 1 ThreadStatic =  ThreadLocal = default AsyncLocal = default CallContext:
0 Chng: ThreadId: 1 ThreadStatic = Static(0) ThreadLocal = Local(0) AsyncLocal = Async(0) CallContext: Call(0)
--------------------
1 Init: ThreadId: 1 ThreadStatic = Static(0) ThreadLocal = Local(0) AsyncLocal = Async(0) CallContext: Call(0)
1 Chng: ThreadId: 1 ThreadStatic = Static(1) ThreadLocal = Local(1) AsyncLocal = Async(1) CallContext: Call(1)
--------------------
Main: ThreadId: 1 ThreadStatic = Static(1) ThreadLocal = Local(1) AsyncLocal =  CallContext:

但是，从输出中可以看出，当进行第二次调用并重用线程 1 时，它仍然具有线程 0 设置的值。

ThreadStatic重新使用线程时，有什么方法可以将变量重置为默认值或 null？

4

1 回答 1

1

TL;博士

如果不希望多线程应用程序中的多个线程重用变量，则没有理由将其设为静态。

如果我们不希望同一个线程重用一个变量，那么为什么我们会故意使用 是值得怀疑的[ThreadStatic]，因为它允许我们这样做。

我专注于这ThreadStatic方面，因为它似乎是问题的焦点。

因此特定线程的任何后续使用都会获得该变量的新副本。

线程的使用不需要他们自己的变量副本 -使用变量的方法可能需要也可能不需要他们自己的变量副本。这听起来像是一件令人毛骨悚然的事情，但线程本身并不需要任何变量的副本。它可能正在做与这个静态类和这个变量无关的事情。

当我们使用变量时，我们关心它是否是“新副本”。也就是说，当我们调用使用该变量的方法时。

如果，当我们使用静态变量（在方法之外声明）时，我们想要确保在使用它之前它是新实例化的，并在我们用完它时释放它，那么我们可以在方法中完成它使用它。我们可以实例化它，处理它，甚至可以根据null需要设置它。然而，当我们这样做时，显而易见的是，它通常消除了在使用它的方法之外声明变量的任何需要。

如果我们这样做：

public static class HasDisposableThreadStaticThing
{
    [ThreadStatic]
    public static DisposableThing Foo;

    public static void UseDisposableThing()
    {
        try
        {
            using (Foo = new DisposableThing())
            {
                Foo.DoSomething();
            }
        }
        finally
        {
            Foo = null;
        }
    }
}

我们已经完成了目标。

重新使用线程时，有没有办法将 ThreadStatic 变量重置为默认值或 null？

完毕。每次同一个线程进入方法（“线程被重新使用”）它都是空的。

但如果这就是我们想要的，那么为什么不这样做呢？

public static class HasDisposableThreadStaticThing
{
    public static void UseDisposableThing()
    {
        using (var foo = new DisposableThing())
        {
            foo.DoSomething();
        }
    }
}

结果是完全一样的。每个线程都以一个新的实例开始，DisposableThing因为当它执行该方法时，它会声明变量并创建一个新实例。而不是将其设置为null参考超出范围。

两者的唯一区别是，在第一个例子中，DisposableThing是在课外公开暴露的。这意味着其他线程可以使用它而不是声明自己的变量，这很奇怪。既然他们还需要在使用它之前确保它已经实例化，为什么他们不也像第二个示例那样创建自己的实例呢？

确保在静态方法中每次需要变量时都对其进行初始化和处置的最简单和最正常的方法是在静态方法中本地声明该变量并创建一个新实例。然后无论有多少线程同时调用它，它们都将使用一个单独的实例。

于 2019-06-04T14:22:13.877 回答