Saxon

While inspecting key manager code I've seen that you often use weak references. In some cases you even try to model weak reference for two objects at once.

I've tried to model a simple thread safe class to keep objects alive when all its keys alive:

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

public class WeakStore<T>
{
  public T get(Object ...keys)
  {
    poll();
    
    return store.get(new Key(queue, keys));
  }
  
  public T set(T value, Object ...keys)
  {
    poll();
    
    Key key = new Key(queue, keys);
    
    return value == null ? store.remove(key) : store.put(key, value);
  }
  
  public void poll()
  {
    while(true)
    {
      Ref ref = (Ref)queue.poll();
      
      if (ref == null)
      {
        break;
      }
      
      store.remove(ref.key);
    }
  }
  
  private static class Key
  {
    public Key(ReferenceQueue<Object> queue, Object ...keys)
    {
      int hashCode = 0;
      
      refs = new Ref[keys.length];
      
      for(int i = 0; i < keys.length; ++i)
      {
        Object key = Objects.requireNonNull(keys[i]);

        hashCode ^= key.hashCode();
        refs[i] = new Ref(key, queue, this);
      }
      
      this.hashCode = hashCode;
    }
    
    @Override
    public int hashCode()
    {
      return hashCode;
    }
    
    @Override
    public boolean equals(Object obj)
    {
      if (this == obj)
      {
        return true;
      }

      if (!(obj instanceof Key))
      {
        return false;
      }
      
      Key that = (Key)obj;
      
      if (hashCode != that.hashCode)
      {
        return false;
      }
      
      if (refs.length != that.refs.length)
      {
        return false;
      }
      
      for(int i = 0; i < refs.length; ++i)
      {
        Object key = refs[i].get();
        Object thatKey = that.refs[i].get();
        
        if ((key != thatKey) || (key == null))
        {
          return false;
        }
      }
      
      return false;
    }
    
    private final int hashCode;
    private final Ref[] refs;
  }
  
  private static class Ref extends WeakReference<Object>
  {
    public Ref(Object value, ReferenceQueue<Object> queue, Key key)
    {
      super(value, queue);
      this.key = key;
    }
    
    private final Key key;
  }
  
  private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
  private final ConcurrentHashMap<Key, T> store = new ConcurrentHashMap<>();
}

I think you can even create a singleton to keep different associated objects by keys, e.g. index by document and key definition.