c# - SignalR 服务器内存消耗(归咎于 Windsor IHubActivator？)

Question

我正在测试最终将构成数据记录系统基础的 SignalR 服务器(在控制台应用程序中自行托管)。测试客户端每秒向集线器发出大约 180 次调用，而消息本身非常小(只是一个名称/值对)。

我将 CaSTLe Windsor 用于 DI，使用自定义 IHubActivator 来解析 Hub 实例:

internal class WindsorHubActivator : IHubActivator
{
    private readonly IWindsorContainer _container;

    public WindsorHubActivator(IWindsorContainer container)
    {
        _container = container;
    }

    public IHub Create(HubDescriptor descriptor)
    {
        var hubType = descriptor.HubType;
        return _container.Resolve(hubType) as IHub;
    }
}

这是中心类:

public class TelemetryHub : Hub
{
    private readonly TelemetryDataService _telemetryDataService;

    public TelemetryHub(TelemetryDataService telemetryDataService)
    {
        _telemetryDataService = telemetryDataService;
    }

    public void LogTelemetryData(string name, double value)
    {
        _telemetryDataService.LogTelemetryData(name, value);
    }
}

当 hub 类在 Windsor 中注册为“Transient”时，内存消耗稳步攀升，直到达到 2Gb，然后因 OOM 异常而下降。如果我改为将 Hub 注册为“Singleton”，那么应用程序内存消耗将保持非常低且一致。

TelemetryDataService 类不是问题所在。 hub的构造函数和方法代码我都注释掉了，问题依旧。

出于好奇，我将事情更进一步，更改了 WindsorHubActivator 类，将 Windsor 排除在外:

internal class WindsorHubActivator : IHubActivator
{
    ...

    public IHub Create(HubDescriptor descriptor)
    {
        return new TelemetryHub(new TelemetryDataService());
    }
}

这次内存问题消失了，所以我假设 Windsor 正在保留创建的集线器实例并防止它们被垃圾回收。解决办法是什么？我知道不建议使用单例集线器，我不想让 IHubActivator 处于上述“硬编码”状态。

Answer 1

对于从容器显式 Resolved 的 transient 组件，you need to explicitly Release them to let Windsor know it can release its reference to them :

Tran­sient com­po­nents are sim­i­lar to pooled, because there’s no well known end to tran­sient component’s life­time, and Wind­sor will not know if you still want to use a com­po­nent or not, unless you explic­itly tell it (by call­ing Release). Since tran­sient com­po­nents are by def­i­n­i­tion non-shared Wind­sor will imme­di­ately destroy the com­po­nent when you Release it.

所以，我相信你有两个选择:

1. 如果您知道 IHub.Dispose() 将被调用的位置，您可以在那里调用 container.Release。这可能不是最好的方法，因为您会将 IHub 的使用与它的创建方式结合起来，这是大问题之一(如果不是问题) 首先使用 IOC 容器解决。

2. 如果您不知道 IHub.Dispose() 将在何处被调用，您可以将集线器和容器包装在一个对象中以便为您管理。像这样:

   public class HubContainerWrapper : IHub, IDisposable
   {
       IWindsorContainer container;
       IHub hub;
   
       public HubContainerWrapper (IWindsorContainer container, IHub hub)
       {
           this.container = container;
           this.hub = hub;
       }
   
       ~HubContainerWrapper()
       {
           Dispose(false);
       }
   
       public void Dispose()
       {
           Dispose(true);
           GC.SuppressFinalize(this);
       }
   
       protected virtual void Dispose(bool disposing)
       {
           if (disposing)
           {
               if (hub != null)
               {
                   try
                   {
                       hub.Dispose();
                   }
                   finally
                   {
                       container.Release(hub);
                       container = null;
                       hub = null;
                   }
               }                   
           }
       }
   
       // forward all IHub calls to hub member
   }
   

   然后在您的 IHubActivator 中:

   public IHub Create(HubDescriptor descriptor)
   {
       var hubType = descriptor.HubType;
       var hub = _container.Resolve(hubType) as IHub;
       return new HubContainerWrapper(_container, hub);
   }
   

   这样，当 SignalR 处理您的集线器包装器时，它将释放您从容器中解析的实际集线器。