如何为每个线程模拟专属静态类行为？

你要实现的是线程级别的静态类/配置隔离，核心是绕开静态成员AppDomain全局共享的特性，让不同线程访问静态属性时拿到对应线程的实例数据。下面几个方案可以满足需求，不需要在工具类构造函数传实例：

方案1：用ThreadLocal<T>实现线程本地存储 #

ThreadLocal<T>是.NET专门为线程隔离设计的容器，每个线程会拥有独立的T实例副本。

修改Options类 #

给基类Options添加静态的ThreadLocal<Options>成员，用来存储当前线程对应的配置实例：

public class Options : AbsOptions, IOptions
{
    // 线程本地存储的当前配置实例
    private static readonly ThreadLocal<Options> _current = new ThreadLocal<Options>();

    // 对外暴露的静态访问入口
    public static Options Current
    {
        get => _current.Value ?? throw new InvalidOperationException("当前线程未配置Options实例");
        set => _current.Value = value;
    }

    public int Port { get; set; }
    public string Address { get; set; }
    public int IdleConnectionTimeout { get; set; }
}

线程初始化与使用 #

在启动线程前，给对应线程的Current赋值，线程内部直接通过Options.Current.Port访问：

// 初始化配置
var server1Options = new Server1Options();
server1Options.init();
var server2Options = new Server2Options();
server2Options.init();

// 启动线程1：绑定Server1的配置
Thread server1 = new Thread(() => 
{
    Options.Current = server1Options;
    AsynchronousSocketListener.StartListening();
});
server1.Start();

// 启动线程2：绑定Server2的配置
Thread server2 = new Thread(() => 
{
    Options.Current = server2Options;
    AsynchronousSocketListener.StartListening();
});
server2.Start();

修改StartListening方法 #

直接通过静态入口访问当前线程的配置：

public void StartListening() 
{
    IPAddress ipAddress = IPAddress.Any;
    // 访问当前线程绑定的配置
    IPEndPoint localEndPoint = new IPEndPoint(ipAddress, Options.Current.Port);

    Socket listener = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
    try
    {
        listener.Bind(localEndPoint);
        listener.Listen();
        Console.WriteLine($"Waiting for client connection on port {Options.Current.Port}...");
    }
    // 省略异常处理和后续逻辑
}

方案2：用AsyncLocal<T>适配异步场景 #

如果你的服务器逻辑用异步代码（比如Task代替Thread），ThreadLocal可能因为线程池线程复用导致数据混乱，这时用AsyncLocal<T>更合适——它绑定的是执行上下文，而非物理线程，异步切换线程时会自动延续上下文。

修改Options类的静态成员 #

把ThreadLocal换成AsyncLocal：

public class Options : AbsOptions, IOptions
{
    private static readonly AsyncLocal<Options> _current = new AsyncLocal<Options>();

    public static Options Current
    {
        get => _current.Value ?? throw new InvalidOperationException("当前执行上下文未配置Options实例");
        set => _current.Value = value;
    }

    // 原有属性保留
    public int Port { get; set; }
    public string Address { get; set; }
    public int IdleConnectionTimeout { get; set; }
}

异步线程使用示例 #

如果用Task.Run启动异步任务，上下文会自动传递：

// 初始化配置
var server1Options = new Server1Options();
server1Options.init();
var server2Options = new Server2Options();
server2Options.init();

// 启动异步任务1
_ = Task.Run(() =>
{
    Options.Current = server1Options;
    return AsynchronousSocketListener.StartListeningAsync();
});

// 启动异步任务2
_ = Task.Run(() =>
{
    Options.Current = server2Options;
    return AsynchronousSocketListener.StartListeningAsync();
});

方案3：线程ID映射字典（简易实现） #

如果不想用框架提供的线程本地存储，可以自己维护一个线程ID->配置实例的字典，静态属性访问时根据当前线程ID取对应实例。注意：这个方案只适合长生命周期的专用线程，如果用线程池线程（短线程），线程ID可能被复用，会导致数据错误。

修改Options类 #

public class Options : AbsOptions, IOptions
{
    private static readonly Dictionary<int, Options> _threadOptionsMap = new Dictionary<int, Options>();
    private static readonly object _lock = new object();

    public static Options Current
    {
        get
        {
            var threadId = Thread.CurrentThread.ManagedThreadId;
            lock (_lock)
            {
                if (_threadOptionsMap.TryGetValue(threadId, out var options))
                    return options;
                throw new InvalidOperationException("当前线程未配置Options实例");
            }
        }
    }

    // 给指定线程绑定配置
    public static void BindToThread(int threadId, Options options)
    {
        lock (_lock)
        {
            _threadOptionsMap[threadId] = options;
        }
    }

    // 原有属性保留
    public int Port { get; set; }
    public string Address { get; set; }
    public int IdleConnectionTimeout { get; set; }
}

使用方式 #

// 初始化配置
var server1Options = new Server1Options();
server1Options.init();
var server2Options = new Server2Options();
server2Options.init();

Thread server1 = new Thread(AsynchronousSocketListener.StartListening);
server1.Start();
// 线程启动后绑定配置
Options.BindToThread(server1.ManagedThreadId, server1Options);

Thread server2 = new Thread(AsynchronousSocketListener.StartListening);
server2.Start();
Options.BindToThread(server2.ManagedThreadId, server2Options);

内容的提问来源于stack exchange，提问作者Spanners