Как работает http keep-alive?

Keep-alives были добавлены в HTTP, чтобы в основном уменьшить значимые накладные расходы на быстрое создание и закрытие соединений сокетов для каждого Новый запрос. Ниже приведен краткий обзор того, как он работает в HTTP 1.0 и 1.1:

HTTP 1.0 Спецификация HTTP 1.0 действительно не вникает в то, как Keep-Alive должен работать. В основном, браузеры, поддерживающие Keep-Alive добавляет дополнительный заголовок к запросу как:

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

Ниже приведено объяснение . Но я ничего не понимаю.

Когда это будет сделано, соединение сокета не будет закрыто, как и раньше, но сохраняются открытыми после отправки ответа.

Как я понимаю, мы просто отправляем tcp-пакеты для запросов и ответов, как это помогает socket connection и как это работает? Нам по-прежнему приходится отправлять пакеты, но как он может каким-то образом установить постоянное соединение? Это кажется нереальным.

Ответ 1

При создании нового TCP-соединения возникают проблемы (поиск DNS, рукопожатие TCP, рукопожатие SSL/TLS и т.д.). Без поддержания работоспособности каждый HTTP-запрос должен установить новое TCP-соединение, а затем закрыть соединение после отправки или получения ответа. Постоянное обновление позволяет повторно использовать существующее TCP-соединение для нескольких запросов/ответов, тем самым избегая всех этих накладных расходов. Именно это делает соединение "постоянным".

В HTTP 0.9 и 1.0 по умолчанию сервер закрывает свой конец TCP-соединения после отправки ответа клиенту. Клиент должен закрыть свой конец TCP-соединения после получения ответа. В HTTP 1.0 (но не в версии 0.9) клиент может явно попросить сервер не закрывать свой конец соединения, включив в запрос заголовок Connection: keep-alive. Если сервер согласен, он включает заголовок Connection: keep-alive в ответе и не закрывает его конец. Затем клиент может повторно использовать одно и то же TCP-соединение для отправки следующего запроса.

В HTTP 1.1, keep-alive является поведением по умолчанию, если только клиент явно не просит сервер закрыть соединение, включив заголовок Connection: close в свой запрос или сервер решит включить заголовок Connection: close в свой ответ.

Ответ 2

Сделаем аналогию. HTTP состоит в отправке запроса и получении ответа. Это похоже на то, чтобы задать кому-то вопрос и получить ответ.

Проблема в том, что вопрос и ответ должны проходить через сеть. Для связи через сеть используется TCP (сокеты). Это похоже на использование телефона, чтобы задать вопрос кому-то и ответить на этот вопрос.

HTTP 1.0 состоит, например, при загрузке страницы, содержащей 2 изображения, в

сделать телефонный звонок
запросить страницу
получить страницу
завершить телефонный звонок
сделать телефонный звонок
запросить первое изображение
получить первое изображение
завершить телефонный звонок
сделать телефонный звонок
запросить второе изображение
получить второе изображение
завершить телефонный звонок

Выполнение телефонного звонка и его окончание требуют времени и ресурсов. Управляющие данные (например, номер телефона) должны проходить через сеть. Было бы более эффективным сделать один телефонный звонок, чтобы получить страницу и два изображения. Это то, что позволяет сохранить жизнь. В режиме keep-alive вышеупомянутое становится

сделать телефонный звонок
запросить страницу
получить страницу
запросить первое изображение
получить первое изображение
запросить второе изображение
получить второе изображение
завершить телефонный звонок

Ответ 3

Это действительно сетевой вопрос, но в конце концов он может быть уместным.

Путаница возникает из-за различия между ориентированными на пакет и ориентированными на поток соединениями.

Интернет часто называют сетью "TCP/IP". На низком уровне (IP, Интернет-протокол) Интернет ориентирован на пакет. Хосты отправляют пакеты другим хостам.

Однако, помимо IP, мы имеем TCP (протокол управления передачей). Вся цель этого уровня Интернета состоит в том, чтобы скрыть пакетно-ориентированный характер базового носителя и представить соединение между двумя хостами (хосты и порты, если быть более правильными) как поток данных, аналогичный файлу или труба. Затем мы можем открыть сокет в OS API для представления этого соединения, и мы можем рассматривать этот сокет как дескриптор файла (буквально FD в Unix, очень похожий на файл HANDLE в Windows).

Большинство остальных протоколов клиент-сервер Интернета (HTTP, Telnet, SSH, SMTP) накладываются поверх TCP. Таким образом, клиент открывает соединение (сокет), записывает свой запрос (который передается как один или несколько карманов в базовом IP) в сокет, считывает ответ сокета (и ответ может содержать данные из нескольких IP-пакетов как хорошо), а затем... Тогда выбор заключается в том, чтобы открыть соединение для следующего запроса или закрыть его. Pre-KeepAlive HTTP всегда закрывал соединение. Новые клиенты и серверы могут оставить его открытым.

Преимущество KeepAlive заключается в том, что установление соединения является дорогостоящим. Для коротких запросов и ответов может потребоваться больше пакетов, чем фактический обмен данными.

Небольшим недостатком может быть то, что сервер теперь должен сообщить клиенту, где заканчивается ответ. Сервер не может просто отправить ответ и закрыть соединение. Он должен сказать клиенту: "читать 20 КБ, и это будет конец моего ответа". Таким образом, размер ответа должен быть заранее известен сервером и передан клиенту как часть протокола более высокого уровня (например, Content-Length: в HTTP). В качестве альтернативы сервер может отправить разделитель для указания конца ответа - все зависит от протокола выше TCP.

Ответ 4

Вы можете понять это так:

HTTP использует TCP как транспорт. Перед отправкой и получением пакетов через TCP,

Клиент должен отправить запрос на подключение
Сервер отвечает
Передача передачи данных выполняется
Соединение закрыто.

Однако, если мы используем функцию keep-alive, соединение не закрывается после получения данных. Соединение остается активным.

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