ThreadLocal

ThreadLocal

在多线程编程中，我们经常需要为每个线程维护独立的数据副本，以避免线程间的数据竞争和不一致性。在C#中，线程本地存储（Thread Local Storage, TLS）为我们提供了一种简洁而高效的解决方案。

什么是线程本地存储？

线程本地存储是一种机制，允许我们为每个线程创建独立的数据副本。这样，每个线程都可以独立地访问和修改其专属的数据，而不影响其他线程的数据。

为什么需要线程本地存储？

在多线程环境中，共享数据可能会导致竞争条件和数据不一致的问题。线程本地存储通过为每个线程提供独立的数据副本，避免了这些问题。例如，在线程池中处理请求时，我们可能需要为每个请求维护独立的上下文信息，这时TLS就派上了用场。

C#中的线程本地存储

在C#中，实现线程本地存储的方式主要有以下几种：

1. ThreadLocal<T>

ThreadLocal<T>类提供了一种简单的方式来实现线程本地存储。它允许我们为每个线程创建和访问独立的数据副本。

代码语言：javascript代码运行次数：0运行复制

using System;
using System.Threading;

class Program
{
    // 定义一个线程本地变量
    private static ThreadLocal<int> _threadLocalData = new ThreadLocal<int>(() => Thread.CurrentThread.ManagedThreadId);

    static void Main()
    {
        // 启动多个线程，每个线程都会访问自己的线程本地数据
        Thread[] threads = new Thread[];
        for (int i = 0; i < threads.Length; i++)
        {
            threads[i] = new Thread(() =>
            {
                Cole.WriteLine($"Thread ID: {Thread.CurrentThread.ManagedThreadId}, ThreadLocal Value: {_threadLocalData.Value}");
            });
            threads[i].Start();
        }

        // 等待所有线程执行完毕
        foreach (Thread t in threads)
        {
            t.Join();
        }
    }
}

在这个例子中，每个线程都有自己的_threadLocalData副本，并且初始值被设置为线程的ID。

实际可应用场景

在一个多线程的应用程序中，每个线程可能需要与数据库交互。为了提高性能，可以为每个线程缓存一个数据库连接对象，而不是每次都创建新的连接。

实现方式

使用ThreadLocal<T>为每个线程缓存一个数据库连接对象。

代码语言：javascript代码运行次数：0运行复制

using System;
using System.Threading;

class Program
{
    // 模拟数据库连接对象
    class DatabaseConnection
    {
        public string ConnectionId { get; } = ().ToString();
    }

    // 为每个线程缓存一个数据库连接对象
    static ThreadLocal<DatabaseConnection> threadLocalConnection = new ThreadLocal<DatabaseConnection>(() => new DatabaseConnection());

    static void Main()
    {
        // 模拟两个线程进行数据库操作
        Thread thread1 = new Thread(() => AccessDatabase("Thread 1"));
        Thread thread2 = new Thread(() => AccessDatabase("Thread 2"));

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();
    }

    static void AccessDatabase(string threadame)
    {
        // 获取线程本地的数据库连接对象
        var connection = threadLocalConnection.Value;
        Cole.WriteLine($"{threadame} using Connection ID: {connection.ConnectionId}");
        
        // 模拟数据库操作
        Thread.Sleep(new Random().ext(100, 500));

        Cole.WriteLine($"{threadame} finished with Connection ID: {connection.ConnectionId}");
    }
}

解释

• 数据库连接缓存：每个线程在第一次访问threadLocalConnection.Value时，会创建并缓存一个DatabaseConnection对象。
• 线程隔离：ThreadLocal<T>确保每个线程都有自己的连接对象，避免了多个线程共享同一个连接对象的潜在问题。
• 性能优化：通过缓存连接对象，避免了每次操作都创建新的连接，提高了性能。

这种方法在需要线程隔离且重用对象的场景中非常有用，比如数据库连接、会话对象等。

使用注意事项

• 初始化：ThreadLocal<T>允许我们通过委托来初始化每个线程的数据，而ThreadStatic字段需要在每个线程中手动初始化。
• 生命周期：使用ThreadLocal<T>时，要注意调用Dispose方法释放资源。
• 性能：ThreadLocal<T>比ThreadStatic更灵活，但在性能上可能略有损耗。因此，在性能敏感的场合，ThreadStatic可能是更好的选择。

2. ThreadStatic属性

ThreadStatic是另一种实现TLS的方式。它用于静态字段，指示该字段对于每个线程都是唯一的。

代码语言：javascript代码运行次数：0运行复制

using System;
using System.Threading;

class Program
{
    [ThreadStatic]
    private static int _threadStaticData;

    static void Main()
    {
        Thread[] threads = new Thread[];
        for (int i = 0; i < threads.Length; i++)
        {
            threads[i] = new Thread(() =>
            {
                _threadStaticData = Thread.CurrentThread.ManagedThreadId;
                Cole.WriteLine($"Thread ID: {Thread.CurrentThread.ManagedThreadId}, ThreadStatic Value: {_threadStaticData}");
            });
            threads[i].Start();
        }

        foreach (Thread t in threads)
        {
            t.Join();
        }
    }
}

在这个例子中，_threadStaticData字段对于每个线程都是独立的。

.Thread中的GetData或SetData、LocalDataStoreSlot

在.ET中，Thread.GetData 和 Thread.SetData 方法用于在线程本地存储（Thread Local Storage, TLS）中存取数据。这是一种在线程级别存储数据的方式，确保每个线程都有自己的数据副本。

LocalDataStoreSlot

LocalDataStoreSlot 是一个标识符，用于在 TLS 中存取数据。每个线程有自己的数据槽，这样同一标识符在不同线程中可以存储不同的数据。

使用方式

创建 LocalDataStoreSlot

你可以通过 Thread.AllocateDataSlot() 或 Thread.AllocateamedDataSlot(string name) 分配一个数据槽。

代码语言：javascript代码运行次数：0运行复制

LocalDataStoreSlot slot = Thread.AllocateDataSlot();

存储数据

使用 Thread.SetData(LocalDataStoreSlot slot, object data) 将数据存储到特定线程的槽中。

代码语言：javascript代码运行次数：0运行复制

Thread.SetData(slot, "Thread-specific data");

检索数据

使用 Thread.GetData(LocalDataStoreSlot slot) 从线程的槽中检索数据。

代码语言：javascript代码运行次数：0运行复制

object data = Thread.GetData(slot);

示例

代码语言：javascript代码运行次数：0运行复制

using System;
using System.Threading;

class Program
{
    static LocalDataStoreSlot slot = Thread.AllocateDataSlot();

    static void Main()
    {
        Thread thread1 = new Thread(new ThreadStart(ThreadMethod));
        Thread thread2 = new Thread(new ThreadStart(ThreadMethod));

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();
    }

    static void ThreadMethod()
    {
        Thread.SetData(slot, $"Data for {Thread.CurrentThread.ManagedThreadId}");
        Cole.WriteLine(Thread.GetData(slot));
    }
}

注意事项

• TLS 在每个线程中是独立的，数据不会在不同线程之间共享。
• 使用 TLS 可能会增加内存消耗，尤其是在大量线程中存储大量数据时。
• 如果需要在线程之间共享数据，可能需要考虑其他机制，如 ThreadStatic 属性或 ThreadLocal<T> 类。

4. AsyncLocal

文章前面大部分讲的都是基于Thread的概念，那如果在Task也想达到一样的效果如何实现呢？这时候AsyncLocal就登场了。

在多线程编程中，我们常常使用 ThreadLocal<T> 来存储与特定线程关联的数据。然而，在异步编程中，代码可能在不同的线程之间切换，这使得 ThreadLocal<T> 不再适用。

AsyncLocal<T> 的工作原理

AsyncLocal<T> 是一种特殊的存储机制，能够在异步方法调用链中保持数据的可用性。每个异步操作都有自己的上下文，这使得数据能够在异步操作中传递，而不受线程变化的影响。

详细特性

1. 上下文捕获和恢复：
   • AsyncLocal<T> 会在异步方法调用时捕获当前上下文，并在继续执行时恢复这个上下文。
2. 值变更通知：
   • AsyncLocal<T> 提供了 AsyncLocalValueChangedArgs<T> 事件，可以监听值的变更。每当值改变时，这个事件会被触发。
3. 隔离性：
   • 即使在同一个线程中，不同的异步控制流对 AsyncLocal<T> 的访问是隔离的。

代码示例

以下是更复杂的示例，展示了值变更通知的使用：

代码语言：javascript代码运行次数：0运行复制

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static AsyncLocal<string> asyncLocalValue = new AsyncLocal<string>(args =>
    {
        Cole.WriteLine($"Value changed: {args.PreviousValue} -> {args.CurrentValue}, Thread Id: {Thread.CurrentThread.ManagedThreadId}");
    });

    static async Task Main(string[] args)
    {
        asyncLocalValue.Value = "Initial Value";
        Cole.WriteLine($"Main Method: {asyncLocalValue.Value}, Thread Id: {Thread.CurrentThread.ManagedThreadId}");

        await Task.Run(() =>
        {
            Cole.WriteLine($"Task 1 Start: {asyncLocalValue.Value}, Thread Id: {Thread.CurrentThread.ManagedThreadId}");
            asyncLocalValue.Value = "Task 1 Value";
            Cole.WriteLine($"Task 1 End: {asyncLocalValue.Value}, Thread Id: {Thread.CurrentThread.ManagedThreadId}");
        });

        Cole.WriteLine($"Main Method After Task 1: {asyncLocalValue.Value}, Thread Id: {Thread.CurrentThread.ManagedThreadId}");

        await Task.Run(() =>
        {
            Cole.WriteLine($"Task 2 Start: {asyncLocalValue.Value}, Thread Id: {Thread.CurrentThread.ManagedThreadId}");
            asyncLocalValue.Value = "Task 2 Value";
            Cole.WriteLine($"Task 2 End: {asyncLocalValue.Value}, Thread Id: {Thread.CurrentThread.ManagedThreadId}");
        });

        Cole.WriteLine($"Main Method After Task 2: {asyncLocalValue.Value}, Thread Id: {Thread.CurrentThread.ManagedThreadId}");
    }
}

输出示例

代码语言：javascript代码运行次数：0运行复制

Main Method: Initial Value, Thread Id: 1
Task 1 Start: Initial Value, Thread Id: 
Value changed: Initial Value -> Task 1 Value, Thread Id: 
Task 1 End: Task 1 Value, Thread Id: 
Main Method After Task 1: Initial Value, Thread Id: 1
Task 2 Start: Initial Value, Thread Id: 4
Value changed: Initial Value -> Task 2 Value, Thread Id: 4
Task 2 End: Task 2 Value, Thread Id: 4
Main Method After Task 2: Initial Value, Thread Id: 1

使用注意

• 性能：频繁更改 AsyncLocal<T> 的值可能导致性能下降，因为每次更改都会触发上下文切换。
• 调试：在调试时，注意上下文切换可能导致的值变更，以避免意外行为。

本文参与 腾讯云自媒体同步曝光计划，分享自。原始发表：2024-09-18，如有侵权请联系 cloudcommunity@tencent 删除存储对象连接数据线程