ASP.NET Core 3.1服务的生命周期可以通过使用依赖注入容器和服务生命周期管理器来控制。下面是一个示例代码，展示了如何在ASP.NET Core 3.1中注册和使用一个服务：

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddScoped(); // 注册服务
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRouting();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

// MyService.cs
public interface IMyService
{
    void DoSomething();
}

public class MyService : IMyService
{
    public MyService()
    {
        // 在服务实例化时进行初始化，这个方法只会在服务被首次使用时调用
    }

    public void DoSomething()
    {
        // 执行服务的逻辑
    }
}

// MyController.cs
[ApiController]
[Route("api/[controller]")]
public class MyController : ControllerBase
{
    private readonly IMyService _myService;

    public MyController(IMyService myService)
    {
        _myService = myService;
    }

    [HttpGet]
    public IActionResult Get()
    {
        _myService.DoSomething();
        return Ok();
    }
}

在上面的示例中，IMyService是一个服务接口，MyService是一个实现了该接口的具体服务类。在ConfigureServices方法中，我们使用AddScoped方法将IMyService注册为一个作用域服务，这意味着每个请求都会获得一个新的IMyService实例。这样，我们就可以在控制器中通过依赖注入来使用IMyService。

关于SignalR Hub中的Observable订阅，可以在SignalR Hub的构造函数中初始化Observable，并在需要的时候订阅和取消订阅。下面是一个简单的示例代码：

public class MyHub : Hub
{
    private IDisposable _subscription;
    private readonly MyObservable _myObservable;

    public MyHub(MyObservable myObservable)
    {
        _myObservable = myObservable;
    }

    public void StartSubscription()
    {
        _subscription = _myObservable.Subscribe(OnNext);
    }

    public void StopSubscription()
    {
        _subscription.Dispose();
    }

    private void OnNext(string value)
    {
        Clients.All.SendAsync("ReceiveMessage", value);
    }
}

public class MyObservable : IObservable
{
    private readonly List> _observers;

    public MyObservable()
    {
        _observers = new List>();
    }

    public IDisposable Subscribe(IObserver observer)
    {
        _observers.Add(observer);
        return new MySubscription(_observers, observer);
    }

    public void DoSomething(string value)
    {
        foreach (var observer in _observers)
        {
            observer.OnNext(value);
        }
    }
}

public class MySubscription : IDisposable
{
    private readonly List> _observers;
    private readonly IObserver _observer;

    public MySubscription(List> observers, IObserver observer)
    {
        _observers = observers;
        _observer = observer;
    }

    public void Dispose()
    {
        _observers.Remove(_observer);
    }
}

在上面的示例中，MyObservable是一个实现了IObservable接口的可观察对象。在MyHub中，我们通过依赖注入将MyObservable注入到Hub中，并在需要的时候调用Subscribe方法来订阅Observable。订阅时会返回一个IDisposable对象，在不需要订阅的时候可以调用Dispose方法来取消订阅。

当MyObservable中的数据产生变化时，我们可以通过调用观察者的OnNext方法来通知所有订阅者。在上面的示例中，我们通过调用Clients.All.SendAsync方法来将数据发送给所有客户端。

希望以上示例代码能够对您有所帮助！