Question

假设我们有许多随机传入的线程并行访问相同的资源。要访问资源线程，需要获取锁。如果我们可以将N个传入线程打包到一个请求资源中，则使用效率将提高N倍。我们还需要尽快回答个别请求。 C＃中最好的方法/模式是什么？

目前我有类似的东西：

//batches lock
var ilock = ModifyBatch.GetTableDeleteBatchLock(table_info.Name);
lock (ilock)
{
    // put the request into requests batch
    if (!ModifyBatch._delete_batch.ContainsKey(table_info.Name))
    {
        ModifyBatch._delete_batch[table_info.Name] = new DeleteData() { Callbacks = new List<Action<string>>(), ids = ids };
    }
    else
    {
        ModifyBatch._delete_batch[table_info.Name].ids.UnionWith(ids);
    }
    //this callback will get called once the job is done by a thread that will acquire resource lock
    ModifyBatch._delete_batch[table_info.Name].Callbacks.Add(f =>
    {
        done = true;
        error = f;
    });
}

bool lockAcquired = false;
int maxWaitMs = 60000;
DeleteData _delete_data = null;

//resource lock
var _write_lock = GetTableWriteLock(typeof(T).Name);
try
{
    DateTime start = DateTime.Now;
    while (!done)
    {
        lockAcquired = Monitor.TryEnter(_write_lock, 100);
        if (lockAcquired)
        {
            if (done) //some other thread did our job
                            {
                Monitor.Exit(_write_lock);
                lockAcquired = false;
                break;
            }
            else
            {
                break;
            }
        }
        Thread.Sleep(100);
        if ((DateTime.Now - start).TotalMilliseconds > maxWaitMs)
        {
            throw new Exception("Waited too long to acquire write lock?");
        }
    }
    if (done) //some other thread did our job
    {
        if (!string.IsNullOrEmpty(error))
        {
            throw new Exception(error);
        }
        else
        {
            return;
        }
    }

    //not done, but have write lock for the table
    lock (ilock)
    {
        _delete_data = ModifyBatch._delete_batch[table_info.Name];
        var oval = new DeleteData();
        ModifyBatch._delete_batch.TryRemove(table_info.Name, out oval);
    }
    if (_delete_data.ids.Any())
    {
        //doing the work with resource 
    }
    foreach (var cb in _delete_data.Callbacks)
    {
        cb(null);
    }
}
catch (Exception ex)
{
    if (_delete_data != null)
    {
        foreach (var cb in _delete_data.Callbacks)
        {
            cb(ex.Message);
        }
    }
    throw;
}
finally
{
    if (lockAcquired)
    {
        Monitor.Exit(_write_lock);
    }
}

Answer 1

如果可以处理当前请求范围之外的任务，即将其排队等待，那么你可以想到这样的序列¹：

实施资源锁定（监控）和List任务。

对于每个请求：
锁定列表，将当前任务添加到列表中，记住nr。列表中的任务，解锁列表。
尝试获取 lock 。
如果不成功：
- 如果是列表中的任务＆lt;阈值X，然后返回。
- Else获取锁定（将阻止）
锁定列表，将其内容移至临时列表，解锁列表。
如果临时列表不为空
- 执行临时列表中的任务。
- 从第5步开始重复。
释放锁。

第一个请求将完成整个序列。如果第一个请求仍在执行，则后续请求将在步骤4发生短路。

调整最佳阈值X（或将其更改为基于时间的阈值）。

¹如果您需要等待来处理请求范围内的任务，那么您需要稍微扩展该过程：

向Task类添加两个字段： completion flag 和 exception 。

在步骤4，在返回之前，等待以完成任务（Monitor.Wait），直到其完成标志变为true。如果 exception 不是null，请将其抛出。

在步骤6，对于每项任务，设置完成标志和可选的例外，然后通知服务员（{{1} }）。

用于将传入的并行请求打包成一个的模式

1 个答案: