Question

In my work I stumbled upon such a design issue:

• I need one instance of a Manager class per thread
• These instances should be globally accessible, like in the singleton pattern via a static function
• Each thread might need to initialize its instance with different arguments
• The lifetime of these instances should be controllable, sometimes it would be beneficiary to remove an instance and allow GC to collect it

The first two points would make it a ‘per thread singleton’ if such a thing exists.

This is what I came up with (the code is simplified, I’ve omitted safety checks and so on):

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(); }
}

As you can see the clean function can be also called from within the private methods.
Also notice that through the use of static functions the reference to the instance is never leaked, so instances assigned to different threads won’t get mixed.

This works quite ok, but then I got another requirement:

• Different threads may need to utilize different implementations of Manager class

So I defined an interface:

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

And modified the Manager class:

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(); }
}

An example implementation would look like this:

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 class works here as a facade, forwarding all the calls to the appropriate handler. There is one big issue with this approach: I need to define all the functions both in the Manager class and in the ManagerHandler interface. Unfurtunately Manager class can’t implement ManagerHandler interface, because it has static functions rather than methods.

The question is: can you think of a better/easier way to accomplish all the goals I’ve listed above that would be free of this issue?

Answer 1

There is not much you can do, as you basically need to proxy interface methods through static methods. I could only think of two ways to achieve the same functionality differently:

1. If you’re using a DI framework, you can get rid of the static Manager and use an injected implementation of ManagerHandler which will contain the ThreadLocal.
2. Generate (as in ‘bytecode generation’) the static ManagerAccess class using the methods found in the ManagerHandler interface.

Personally, I wouldn’t think of having the static ManagerAccess class (which contains the ThreadLocal) around as a serious design issue. At least as long as it keeps to its own set of responsibilities (accessing thread-scoped instances and proxying calls) and doesn’t venture anywhere else.