每线程单例模式

Question

在我的工作中，我偶然发现了这样一个设计问题：

• 每个线程我需要一个 Manager 类的实例
• 这些实例应该是全局可访问的，就像通过静态函数在单例模式中一样
• 每个线程可能需要初始化具有不同参数的实例
• 这些实例的生命周期应该是可控的，有时删除实例并允许 GC 收集它会是有益的。

如果存在这种情况，前两点将使其成为“每线程单例”。

这就是我的想法（代码被简化，我省略了安全检查等）：

public class Manager {
  private final static ThreadLocal<Manager> local = new ThreadLocal<Manager>();

  private int x;
  Manager(int argument) { x = argument; }

  public static void start(int argument) { local.set(new Manager(argument); }
  public static void clean() { local.remove(); }

  private void doSomething1() { x++; .... }
  private int doSomething2() { if (--x == 0) clean(); ... }

  public static void function1() { local.get().doSomething1(); }
  public static int function2() { return local.get().doSomething2(); }
}

正如您所看到的，也可以从私有方法中调用 clean 函数。 另请注意，通过使用静态函数，对实例的引用永远不会泄漏，因此分配给不同线程的实例不会混合。

这工作得很好，但后来我得到了另一个要求：

• 不同的线程可能需要利用 Manager 类的不同实现

所以我定义了一个接口：

public interface ManagerHandler {
  void method1();
  int method2();
}

并修改了 Manager 类：

public class Manager {
  private final static ThreadLocal<ManagerHandler> local = new ThreadLocal<ManagerHandler>();

  public static void start(int argument) {
    ManagerHandler handler;
    // depending on the context initialize handler to whatever class it is necessary
    local.set(handler); 
  }
  public static void clean() { local.remove(); }

  public static void function1() { local.get().method1(); }
  public static int function2() { return local.get().method2(); }
}

示例实现如下所示：

public class ExampleManagerImplementation implements ManagerHandler {
  private int x;
  public ExampleManagerImplementation(int argument) { x = argument; }
  public void method1() { x++; .... }
  public int method2() { if (--x == 0) Manager.clean(); ... }
}

管理器类在这里作为外观，将所有调用转发到适当的处理程序。这种方法有一个大问题：我需要在 Manager 类和 ManagerHandler 接口中定义所有函数。不幸的是，Manager 类无法实现 ManagerHandler 接口，因为它具有静态函数而不是方法。

问题是：您能想出一种更好/更简单的方法来实现我上面列出的所有目标，并且不会出现此问题吗？

Answer 1

您无能为力，因为您基本上需要通过静态方法代理接口方法。我只能想到两种方法来以不同的方式实现相同的功能：

1. 如果您使用 DI 框架，则可以摆脱静态 Manager 并使用 ManagerHandler 的注入实现code> 将包含 ThreadLocal。
2. 使用 ManagerHandler 接口中的方法生成（如“字节码生成”）静态 ManagerAccess 类。

就我个人而言，我不认为静态 ManagerAccess 类（其中包含 ThreadLocal）是一个严重的设计问题。至少只要它遵守自己的职责（访问线程范围的实例和代理调用）并且不冒险到其他地方。

Answer 2

如果您要采用这种设计，Manager 是否有必要完全隐藏 ManagerHandler 接口，或者您可以公开它以便不必委托每个方法吗？

class Manager {
    public static ManagerHandler getHandler() { return local.get(); }
}

Answer 3

每个线程类创建单例的技巧是使用 ThreadStatic 私有 static _current 字段上的属性，使其范围为 线。这样，_current 字段将存储在线程内存中，其他线程无法访问该内存，也不是 AppDomain 的共享内存。因此，它仅在线程范围内可用。另一方面，Current 属性可以在该 AppDomain 中的所有线程中访问，但是当调用它时，它将返回该线程的正确实例。这是您需要的代码：

public sealed class Manager
{
    // As you are using the ThreadStatic here you cannot
    // call the static constructor or use the Lazy implimentation for 
    // thread-safty and you have to use the old fashin Lock and anti-pattern.
    private static readonly object _criticalArea = new object();

    [ThreadStatic]
    private static Manager _current;
    public static Manager Current
    {
        get
        {
            if (_current == null)
            {
                lock (_criticalArea)
                {
                    if (_current == null)
                    {
                        _current = new Manager();
                    }
                }
            }
            return _current;
        }
    }

    private Manager()
    {
    }

    public string WhatThreadIsThis { get; set; }
}

[TestClass]
public class SingeltonPerThreadTest
{
    private readonly EventWaitHandle _threadHandler = new EventWaitHandle(false, EventResetMode.AutoReset);
    private string _sharedMemory = "I am the shared memory and yet in main thread :(";

    [TestMethod]
    public void TestSingeltonPerThread()
    {
        // Creates a _current for main thread.
        Manager.Current.WhatThreadIsThis = "I am the main thread :)";

        // Start another thread.
        (new Thread(CallTheThreadBaseSingelton)).Start();

        // Wait for it to be finished.
        _threadHandler.WaitOne();

        Assert.AreEqual("I am the main thread :)", Manager.Current.WhatThreadIsThis, "I am not the main thread :( ");
        Assert.AreEqual("I am the other thread ;)", _sharedMemory, _sharedMemory);
    }

    private void CallTheThreadBaseSingelton()
    {
        // Creates a _current for this thread (this thread is the other one :)) ).
        Manager.Current.WhatThreadIsThis = "I am the other thread ;)";
        _sharedMemory = Manager.Current.WhatThreadIsThis;
        _threadHandler.Set();
    }
}

干杯。