ASP.NET (MVC) Кэш вывода и параллельные запросы

Ну, это зависит от того, как вы настроили IIS. Если у вас менее 100 рабочих потоков (скажем, 50), то «тяжелая работа» выполняется 50 раз, выводя из строя ваш сервер, а затем оставшиеся 50 запросов будут обслуживаться из кеша.

Но нет, для кешированного результата действия нет «механизма блокировки»; это было бы контрпродуктивно, по большей части.

Редактировать: я считаю, что это правда, но тесты Ника говорят об обратном, и у меня сейчас нет времени на тесты. Попробуй сам! Однако остальная часть ответа не зависит от вышеизложенного, и я думаю, что это более важно.

Однако, вообще говоря, ни один веб-запрос, кэшированный или иной, не должен возвращаться в течение 10 секунд. Если бы я был на вашем месте, я бы посмотрел на то, как предварительно вычислить сложную часть запроса. Вы все еще можете кэшировать результат действия, если хотите кэшировать HTML, но похоже, что ваша проблема несколько серьезнее.

Вы можете также захотеть учитывайте асинхронные контроллеры. Наконец, обратите внимание, что, хотя IIS и ASP.NET MVC не блокируют эти тяжелые вычисления, вы можете это сделать. Если вы используете асинхронные контроллеры в сочетании с блокировкой вычислений, вы получите эффективное поведение, о котором просите. Я не могу сказать, является ли это лучшим решением, не зная больше о том, что вы делаете.

Кажется, здесь блокируется, выполняя простой тест:

<%@ OutputCache Duration="10" VaryByParam="*" %>

protected void Page_Load(object sender, EventArgs e)
{
    System.Threading.Thread.Sleep(new Random().Next(1000, 30000));
}

Первая страница достигает там точки останова, даже если она остается спящей... никакой другой запрос не достигает точки останова в методе Page_Load... он ждет завершения первой и возвращает этот результат всем, кто запросил эту страницу.

Примечание: это было проще протестировать в сценарии веб-форм, но, учитывая, что это общий аспект фреймворков, вы можете выполнить тот же тест в MVC с тем же результатом.

Вот альтернативный способ проверки:

<asp:Literal ID="litCount" runat="server" />

public static int Count = 0;

protected void Page_Load(object sender, EventArgs e)
{
  litCount.Text = Count++.ToString();
  System.Threading.Thread.Sleep(10000);
}

Все страницы, находящиеся в очереди, когда первый запрос переходит в спящий режим, будут иметь одинаковый вывод счетчика.

Старый вопрос, но я столкнулся с этой проблемой и провел некоторое расследование.

Пример кода:

public static int Count;
[OutputCache(Duration = 20, VaryByParam = "*")]
public ActionResult Test()
{
    var i = Int32.MaxValue;
    System.Threading.Thread.Sleep(4000);
    return Content(Count++);
}

Запустите его в одном браузере, и он, кажется, заблокируется и ждет.

Запустите его в разных браузерах (я тестировал в IE и firefox), и запросы не задерживаются.

Таким образом, «правильное» поведение больше связано с тем, какой браузер вы используете, чем с функцией IIS.

Изменить: уточнить - нет блокировки. Сервер получает удар по всем запросам, которые успевают попасть до того, как первый результат будет кэширован, что может привести к сильному удару по серверу для тяжелых запросов. (Или, если вы вызываете внешнюю систему, эта система может быть отключена, если ваш сервер обслуживает много запросов...)

Я сделал небольшой тест, который может помочь. Я считаю, что я обнаружил, что некэшированные запросы не блокируются, и каждый запрос, который поступает, когда срок действия кеша истек и до завершения задачи, ТАКЖЕ запускает эту задачу.

Например, приведенный ниже код занимает около 6-9 секунд в моей системе с использованием Cassini. Если вы отправите два запроса с разницей примерно в 2 секунды (т. е. две вкладки браузера), оба получат уникальные результаты. Последний запрос для завершения также является ответом, который кэшируется для последующих запросов.

// CachedController.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace HttpCacheTest.Controllers
{
    public class CachedController : Controller
    {
        //
        // GET: /Cached/

        [OutputCache(Duration=20, VaryByParam="*")]
        public ActionResult Index()
        {
            var start = DateTime.Now;

            var i = Int32.MaxValue;
            while (i > 0)
            {
                i--;
            }
            var end = DateTime.Now;

            return Content( end.Subtract(start).ToString() );
        }

    }
}

Вам следует проверить эту информацию здесь: "У вас есть один клиент, делающий несколько одновременных запросов к серверу. По умолчанию эти запросы будут сериализованы;"

Таким образом, если параллельный запрос от одного клиента сериализуется, последующий запрос будет использовать кеш. Это объясняет некоторое поведение в каком-то ответе выше (@mats-nilsson и @nick-craver)

Контекст, который вы нам показали, - это несколько пользователей, которые будут попадать на ваш сервер одновременно, и ваш сервер будет занят до тех пор, пока не выполнит хотя бы один запрос и не создаст выходной кеш и не будет использовать его для следующего запроса. Поэтому, если вы хотите сериализовать несколько пользователей, запрашивающих один и тот же ресурс, нам нужно понять, как сериализованный запрос работает для одного пользователя. Это то, что вы хотите?