基于IMemoryCache实现独占式缓存与按需程序实例池化的技术问询

针对你的场景——依赖带静态变量的COBOL程序（必须独占实例）、启动成本高需要复用、不同程序调用频率差异大——直接用IMemoryCache存实例会导致多调用冲突，必须把缓存改成按程序标识分组的实例池，每个池管理一组可复用的独占实例。

核心设计思路 #

每个COBOL程序对应一个缓存键，缓存值是该程序的实例池。池内每个实例都绑定一个独占锁，确保同一时间只有一个调用者能使用；当池内无可用实例时，自动新建实例补充；同时支持闲置实例自动清理，适配不同程序的调用频率。

具体实现步骤 #

1. 定义池化实例封装类 #

首先封装COBOL实例的状态，用SemaphoreSlim实现线程安全的独占锁，同时记录最后使用时间用于闲置清理：

public class PooledCobolInstance
{
    // 实际的COBOL程序实例（替换成你的COBOL对象类型）
    public object CobolInstance { get; }
    // 独占锁：初始计数1，确保同一时间只有一个调用者获取
    private readonly SemaphoreSlim _lock = new(1, 1);
    // 最后使用时间，用于清理闲置实例
    public DateTimeOffset LastUsedTime { get; private set; }

    public PooledCobolInstance(object cobolInstance)
    {
        CobolInstance = cobolInstance;
        LastUsedTime = DateTimeOffset.UtcNow;
    }

    // 尝试获取实例的独占使用权
    public async Task<bool> TryAcquireAsync(CancellationToken cancellationToken = default)
    {
        var acquired = await _lock.WaitAsync(0, cancellationToken);
        if (acquired)
        {
            LastUsedTime = DateTimeOffset.UtcNow;
        }
        return acquired;
    }

    // 释放实例的独占使用权
    public void Release()
    {
        LastUsedTime = DateTimeOffset.UtcNow;
        _lock.Release();
    }

    // 销毁实例（关闭COBOL程序进程/释放资源）
    public void Dispose()
    {
        _lock.Dispose();
        // 这里添加COBOL实例的销毁逻辑，比如关闭进程
        // ((ICobolInstance)CobolInstance).Shutdown();
    }
}

2. 实现实例池管理器 #

注入IMemoryCache，负责实例池的创建、实例获取/释放、闲置清理：

public class CobolInstancePoolManager
{
    private readonly IMemoryCache _cache;
    // 实例池的缓存键前缀，避免和其他缓存冲突
    private const string PoolCacheKeyPrefix = "CobolInstancePool_";
    // 闲置实例超时时间（可配置）
    private readonly TimeSpan _idleTimeout = TimeSpan.FromMinutes(10);
    // 每个池的最大实例数（可配置，避免资源耗尽）
    private readonly int _maxInstancesPerPool = 5;

    public CobolInstancePoolManager(IMemoryCache cache)
    {
        _cache = cache;
        // 启动后台定时清理任务，每5分钟清理一次闲置实例
        Task.Run(async () =>
        {
            while (true)
            {
                await Task.Delay(TimeSpan.FromMinutes(5));
                CleanupIdleInstances();
            }
        });
    }

    // 获取COBOL实例：优先从池里拿可用的，没有则新建
    public async Task<PooledCobolInstance> GetInstanceAsync(string programKey, CancellationToken cancellationToken = default)
    {
        var poolKey = $"{PoolCacheKeyPrefix}{programKey}";
        // 获取或创建实例池（用ConcurrentBag存储，支持线程安全的添加/遍历）
        var pool = _cache.GetOrCreate(poolKey, entry =>
        {
            entry.SlidingExpiration = TimeSpan.FromHours(1); // 程序1小时无调用则销毁整个池
            return new ConcurrentBag<PooledCobolInstance>();
        });

        // 遍历池内实例，尝试获取可用的
        foreach (var instance in pool)
        {
            if (await instance.TryAcquireAsync(cancellationToken))
            {
                return instance;
            }
        }

        // 池内无可用实例，且未达最大数则新建
        if (pool.Count < _maxInstancesPerPool)
        {
            var newCobolInstance = CreateCobolInstance(programKey); // 替换成你的COBOL实例启动逻辑
            var newPooledInstance = new PooledCobolInstance(newCobolInstance);
            await newPooledInstance.TryAcquireAsync(cancellationToken);
            pool.Add(newPooledInstance);
            return newPooledInstance;
        }

        // 可选：超过最大实例数时，可抛出异常或让调用者等待，根据业务调整
        throw new InvalidOperationException($"Program {programKey} has reached max instance limit of {_maxInstancesPerPool}");
    }

    // 释放实例回池
    public void ReleaseInstance(PooledCobolInstance instance)
    {
        instance.Release();
    }

    // 清理池内闲置实例
    private void CleanupIdleInstances()
    {
        // 遍历所有缓存的实例池
        foreach (var entry in _cache.GetCurrentEntries())
        {
            if (entry.Key.StartsWith(PoolCacheKeyPrefix) && entry.Value is ConcurrentBag<PooledCobolInstance> pool)
            {
                var idleInstances = pool.Where(i => DateTimeOffset.UtcNow - i.LastUsedTime > _idleTimeout).ToList();
                foreach (var instance in idleInstances)
                {
                    if (pool.TryTake(out instance))
                    {
                        instance.Dispose();
                    }
                }
            }
        }
    }

    // 自定义COBOL实例启动逻辑（替换成你的实际代码）
    private object CreateCobolInstance(string programKey)
    {
        // 这里写启动COBOL程序、初始化实例的代码
        // 比如：return new CobolProgramExecutor(programKey);
        throw new NotImplementedException();
    }
}

3. 业务代码中使用 #

在API接口中注入CobolInstancePoolManager，按以下流程使用：

[ApiController]
[Route("api/cobol")]
public class CobolController : ControllerBase
{
    private readonly CobolInstancePoolManager _poolManager;

    public CobolController(CobolInstancePoolManager poolManager)
    {
        _poolManager = poolManager;
    }

    [HttpPost("{programKey}")]
    public async Task<IActionResult> ExecuteProgram(string programKey, [FromBody] object input)
    {
        PooledCobolInstance pooledInstance = null;
        try
        {
            pooledInstance = await _poolManager.GetInstanceAsync(programKey);
            // 使用COBOL实例执行逻辑
            var cobolInstance = (ICobolInstance)pooledInstance.CobolInstance;
            var result = cobolInstance.Execute(input);
            return Ok(result);
        }
        finally
        {
            // 必须释放实例回池，否则会导致实例一直被占用
            pooledInstance?.ReleaseInstance();
        }
    }
}

关键注意事项 #

• COBOL实例的隔离性：因为COBOL程序带静态变量，必须确保每个PooledCobolInstance对应一个独立的程序进程/实例，不能共享内存空间。
• 资源限制：通过_maxInstancesPerPool控制每个程序的最大实例数，避免高并发下无限制创建实例导致服务器资源耗尽。
• 清理策略：后台定时清理闲置实例，同时给实例池设置滑动过期，长时间无调用的程序会自动销毁整个池，释放资源。
• 异常处理：如果COBOL实例在执行中崩溃，需要在ExecuteProgram中捕获异常，销毁该实例并从池中移除，避免后续调用拿到损坏的实例。

内容的提问来源于stack exchange，提问作者Jeppe