4

我正在尝试为使用异步编程处理图像的 HttpModule 添加速度提升。

虽然看起来我确实获得了性能改进，但我想检查一下我是否正确使用了提供的工具。

我特别担心我处理队列不正确。

我正在采取的方法。

  1. 初始化并发队列
  2. 将 ProcessImage 方法添加到 AddOnBeginRequestAsync 中 BeginEventHandler 上的队列中
  3. 在 AddOnBeginRequestAsync 的 EndEventHandler 上处理队列

有很多代码，所以我提前道歉，但异步编程很难：

字段 

/// <summary>
/// The thread safe fifo queue.
/// </summary>
private static ConcurrentQueue<Action> imageOperations;

/// <summary>
/// A value indicating whether the application has started.
/// </summary>
private static bool hasAppStarted = false;

http模块初始化 

/// <summary>
/// Initializes a module and prepares it to handle requests.
/// </summary>
/// <param name="context">
/// An <see cref="T:System.Web.HttpApplication"/> that provides 
/// access to the methods, properties, and events common to all 
/// application objects within an ASP.NET application
/// </param>
public void Init(HttpApplication context)
{
    if (!hasAppStarted)
    {
        lock (SyncRoot)
        {
            if (!hasAppStarted)
            {
                imageOperations = new ConcurrentQueue<Action>();
                DiskCache.CreateCacheDirectories();
                hasAppStarted = true;
            }
        }
    }

    context.AddOnBeginRequestAsync(OnBeginAsync, OnEndAsync);
    context.PreSendRequestHeaders += this.ContextPreSendRequestHeaders;

}

事件处理程序 

/// <summary>
/// The <see cref="T:System.Web.BeginEventHandler"/>  that starts 
/// asynchronous processing 
/// of the <see cref="T:System.Web.HttpApplication.BeginRequest"/>.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">
/// An <see cref="T:System.EventArgs">EventArgs</see> that contains 
/// the event data.
/// </param>
/// <param name="cb">
/// The delegate to call when the asynchronous method call is complete. 
/// If cb is null, the delegate is not called.
/// </param>
/// <param name="extraData">
/// Any additional data needed to process the request.
/// </param>
/// <returns></returns>
IAsyncResult OnBeginAsync(
object sender, EventArgs e, AsyncCallback cb, object extraData)
{
    HttpContext context = ((HttpApplication)sender).Context;
    EnqueueDelegate enqueueDelegate = new EnqueueDelegate(Enqueue);

    return enqueueDelegate.BeginInvoke(context, cb, extraData);

}

/// <summary>
/// The method that handles asynchronous events such as application events.
/// </summary>
/// <param name="result">
/// The <see cref="T:System.IAsyncResult"/> that is the result of the 
/// <see cref="T:System.Web.BeginEventHandler"/> operation.
/// </param>
public void OnEndAsync(IAsyncResult result)
{
    // An action to consume the ConcurrentQueue.
    Action action = () =>
    {
        Action op;

        while (imageOperations.TryDequeue(out op))
        {
            op();
        }
    };

    // Start 4 concurrent consuming actions.
    Parallel.Invoke(action, action, action, action);
}

委托和处理 

/// <summary>
/// The delegate void representing the Enqueue method.
/// </summary>
/// <param name="context">
/// the <see cref="T:System.Web.HttpContext">HttpContext</see> object that 
/// provides references to the intrinsic server objects 
/// </param>
private delegate void EnqueueDelegate(HttpContext context);

/// <summary>
/// Adds the method to the queue.
/// </summary>
/// <param name="context">
/// the <see cref="T:System.Web.HttpContext">HttpContext</see> object that 
/// provides references to the intrinsic server objects 
/// </param>
private void Enqueue(HttpContext context)
{
    imageOperations.Enqueue(() => ProcessImage(context));
}
4

1 回答 1

2

看起来您的ProcessImage方法适用于HttpContext，每次调用您的 HttpModule 将是一个实例。您的 HttpModule 会根据OnBeginAsync需要在每个 Web 请求中调用，并且您的委托已经为您提供了执行异步操作的逻辑。这意味着，您不需要 4 个并发线程，因为context无论如何您只有一个实例可以处理。我们不需要，ConcurrentQueue因为所有的工作都context应该在请求-响应的生命周期内完成。

总而言之，您不需要，ConcurrentQueue因为：

  1. 通过 HttpModule 的请求已经是并发的（来自 Web 主机架构）。
  2. 每个请求都在单个context实例上工作。
  3. 您需要在从返回之前ProcessImage完成工作。contextOnEndAsync

相反，您只想在方法中开始您的后台工作ProcessImage，OnBeginAsync然后确保在您的OnEndAsync方法中完成该工作。此外，由于所有更改都是直接在context实例上进行的（我假设，因为ProcessImage没有返回类型，所以它正在更新context），您不需要做任何进一步的工作来从您的加工。

您可以放弃ConcurrentQueue并简单地使用：

IAsyncResult OnBeginAsync(object sender, EventArgs e, 
                          AsyncCallback cb, object extraData)
{
    HttpContext context = ((HttpApplication)sender).Context;
    EnqueueDelegate enqueueDelegate = new EnqueueDelegate(ProcessImage);

    return enqueueDelegate.BeginInvoke(context, cb, extraData);
}

public void OnEndAsync(IAsyncResult result)
{
    // Ensure our ProcessImage has completed in the background.
    while (!result.IsComplete)
    {
        System.Threading.Thread.Sleep(1); 
    }
}

您可以删除ConcurrentQueue<Action> imageOperationsandEnqueue并且您也可以重命名EnqueueDelegate为 beProcessImageDelegate因为它现在可以直接使用该方法。

注意：可能是您当时还context没有准备好。如果是这种情况，您将不得不在. 但是，话虽如此，确实有可能通过一些并发来改进。ProcessImageOnBeginAsyncProcessImageOnEndAsyncProcessImage

我要提出的另一个挑剔点是，hasAppStarted可以将其重命名hasModuleInitialized为不那么模棱两可。

于 2013-03-20T17:48:42.317 回答