تقدير المشروع
← كل المقالات

كيف تلغي طلبات HTTP على JVM

يتناول هذا المقال المشكلات التي تسببها استدعاءات HTTP المهجورة، ويستعرض كيف تتيح عملاء HTTP على JVM إلغاء الطلبات أثناء تنفيذها، ما قد يوفّر الموارد.

9 دقائق قراءة
ScalaJavaHTTPالبرمجة غير المتزامنةJVM

يُعدّ HTTP من أبرز وسائل إتاحة التطبيقات للعالم الخارجي ولتخاطب الخدمات المصغّرة داخل النظام الواحد. وعاجلًا أم آجلًا، ترسل كل خدمة خلفية تقريبًا طلب HTTP.

لكن أحيانًا تتوقف نتيجة استدعاء HTTP عن أن تهمّنا. وقد تكون هناك أسباب عدة لذلك، منها:

  • قد نرسل عدة طلبات HTTP بالتوازي ونواصل معالجة نتيجة أول طلب يستجيب فقط (سباق)
  • قد يستغرق طلب HTTP لاحق وقتًا طويلًا، فتُعاد استجابة مهلة إلى الجهة الأعلى أو تُستخدم قيمة افتراضية (مخزّنة مؤقتًا أو محسوبة) بدلًا منه

الطريقة المعتادة للتعامل مع استدعاءات HTTP التي لم نعد نكترث بها هي هجرها ببساطة. فهي تكتمل، لكن لا أحد يستخدم الاستجابة. وقبل هجرها قد تكون هذه الاستجابة قد حُمّلت بالكامل في الذاكرة وحُلّلت، مثلًا إلى JSON – وهذا هدر للذاكرة والمعالج معًا. فهل من نهج أفضل؟

كما تبيّن، يوجد عادةً. فمعظم عملاء HTTP على JVM التي فحصناها تتيح إلغاء طلب HTTP قيد التنفيذ. لنرَ كيف يعمل ذلك.

ماذا يعني إلغاء طلب HTTP؟

بسبب طريقة تصميم HTTP، فبمجرد إرسال الطلب لا يوجد عمومًا ما نستطيع فعله لمنع الخادم من معالجته. لذا، وبأخذ أي آثار جانبية قد يتركها طلبنا على الخادم في الحسبان (إن كان مثلًا POST)، علينا أن نفترض أن الطلب عولج بالكامل.

فما فائدة إلغائه إذن؟ إلى جانب معالجة الخادم للطلب، هناك أيضًا خطوة إرسال الاستجابة إلى العميل، وهي الأهم حين يكون حجم الاستجابة كبيرًا. وإضافة إلى ذلك، كما ذُكر سابقًا، قد يواصل العميل تحليل الاستجابة، وينبغي تخطي هذا العمل إذا كانت النتيجة ستُرمى.

لذا فعند إلغاء طلب HTTP قيد التنفيذ، يكون الهدف تجنّب إرسال الاستجابة، وكذلك أي تحليل لها أو تحميلها في ذاكرة العميل.

اختبارنا

كان اختبارنا بسيطًا: نقطة نهاية واحدة وطلب واحد. بمجرد أن يستقبل الخادم الطلب ينتظر ثانيتين ثم يعيد استجابة حجمها 100MB. يرسل العميل الطلب لكنه يلغيه بعد ثانية واحدة (وعندها لا ينبغي أن تكون أي بيانات استجابة قد أُرسلت). والمعنى الدقيق لـ«الإلغاء» يتوقف على تنفيذ العميل المستخدم.

فحصنا هذه العملاء: async-http-client، وHttpClient المدمج في Java، وOkHttp، وhttp4s. ولمقارنة سلوكها استخدمنا ثلاثة خوادم مبنية على Jetty وHttp4s وakka-http.

TCP: ماذا يحدث عند إلغاء الطلب

على مستوى TCP، يتطابق تسلسل الأحداث أيًّا كان العميل المستخدم. وسنركّز حاليًا على HTTP/1.1.

يجعل إلغاء الطلب العميلَ يغلق اتصال TCP الأساسي من جانبه بإرسال حزمة FIN. يقرّ الخادم باستلامها، لكن يبقى الاتصال نصف مفتوح (فالخادم لا يغلق طرفه بعد).

في اختبارنا يحدث الإلغاء بعد ثانية واحدة، بينما يبدأ الخادم بإرسال البيانات بعد ثانيتين. وعندما يحين ذلك الوقت ويرسل الخادم أولى إطارات البيانات، لا تصل أي إقرارات عنها، لأن المقبس (socket) على جانب العميل مغلق. ويردّ العميل بحزم RST (إعادة تعيين) بدلًا من ذلك.

عند هذه النقطة يتوقف الخادم عن إرسال بقية الاستجابة. وفي الاختبار أُرسل عادةً نحو 32K من البيانات (بدلًا من 100MB كاملة)، وهذا توفير هائل.

لاحظ أن الخادم لا «يعلم» بإغلاق المقبس إلا عندما يحاول إرسال بعض بيانات الاستجابة. وكما ذكرنا في المقدمة، لا يمكن مقاطعة المعالجة على جانب الخادم وهي تعمل عادةً حتى تكتمل.

فيما يلي لقطة لتشغيل اختبار واحد سُجّل باستخدام Wireshark:

بمجرد إلغاء الطلب يُغلق الاتصال، مهما قالت ترويسات Keep-Alive. وقد يضر إنشاء اتصال جديد بدلًا من إعادة استخدام اتصال مفتوح بالأداء. لذا قد يكون من المعقول أيضًا عدم إلغاء الطلبات إطلاقًا وإبقاء الاتصال مفتوحًا بدلًا من ذلك.

async-http-client

فيما يلي تشغيل تجريبي لاختبار باستخدام async-http-client. تنفيذ استدعاء يعيد تنفيذًا مخصصًا لـ Future له دالة cancel (الشيفرة بلغة Scala، لكن يمكنك كتابة ما يعادلها بأي لغة على JVM):

import org.asynchttpclient.DefaultAsyncHttpClient
import org.slf4j.LoggerFactory
import sys.process._

object Run extends App {
  val log = LoggerFactory.getLogger(this.getClass)
  val client = new DefaultAsyncHttpClient()

  val p = "/Applications/Wireshark.app/Contents/MacOS/wireshark -i lo0 -k -a duration:10".run()
  Thread.sleep(3000) // wait for Wireshark to start

  log.info("Sending ...")
  val f = client.executeRequest(
      client.prepareGet("http://localhost:8080/wait").build())
  log.info("Sent ...")
  Thread.sleep(1000)

  f.cancel(true)

  log.info("Done.")
}

إضافة إلى ذلك، نبدأ التقاط Wireshark في البداية. والاستدعاء الأساسي هو بطبيعة الحال f.cancel(true). وأي محاولة لاحقة لـ .get النتيجة تُطلق استثناءً.

يوفّر async-http-client أيضًا .abort(Throwable)، لكنه يبدو أنه ينفّذ بعض المنطق فقط من الذي يعمل عند الإلغاء، ولذا يبدو cancel الخيار الأفضل. أما على مستوى TCP فكلاهما يتصرف بالطريقة نفسها.

ولأن بيانات الاستجابة لا تصل أبدًا، فإن العميل لا يحللها ولا يعالجها بأي شكل.

HttpClient

مع HttpClient المدمج في Java تبدو الشيفرة شبه مطابقة. فإرسال طلب بـ .sendAsync يعيد كذلك تنفيذًا لـ Future يمكن إلغاؤه.

لكن حتى JDK 15 لا يفعل الإلغاء شيئًا. وبدءًا من JDK 16 يتصرف تمامًا كما في async-http-client.

HttpClient باستخدام الخيوط الافتراضية في Loom

الخيوط الافتراضية ميزة معاينة في Java 19 ويُقصد بها إزالة الحاجة إلى التعامل مع الشيفرة غير المتزامنة وكائنات Future إلى حد كبير. فهل يمكن إلغاء طلب HTTP متزامن قيد التنفيذ؟ تبيّن أن ذلك يعمل على أكمل وجه. اختُبر على JDK20:

import org.slf4j.LoggerFactory
import java.net.URI
import java.net.http.HttpResponse.BodyHandlers
import java.net.http.{HttpClient, HttpRequest}
import scala.sys.process._

object Run extends App {
  val log = LoggerFactory.getLogger(this.getClass)
  val client = HttpClient.newHttpClient()

  val p = "/Applications/Wireshark.app/Contents/MacOS/wireshark -i lo0 -k -a duration:10".run()
  Thread.sleep(3000) // wait for Wireshark to start

  log.info("Starting virtual thread ...")

  val t = Thread.startVirtualThread(() => {
    log.info("Sending ...")
    val r = client.send(
      HttpRequest
          .newBuilder(new URI("http://localhost:8080/wait"))
            .GET().version(HttpClient.Version.HTTP_1_1)
              .build(),
      BodyHandlers.ofString()
    )
    log.info(s"Received, body length: ${r.body().length}")
  })

  Thread.sleep(1000)
  log.info("Interrupting ...")
  t.interrupt()

  log.info("Done.")
}

في هذه الحالة، العملية الأساسية هي t.interrupt()، التي تلغي طلب HTTP قيد التنفيذ بالآثار الموصوفة سابقًا.

OkHttp

مع OkHttp، تتصرف الطريقتان المتزامنة وغير المتزامنة لإرسال الطلب بشكل يشبه ما وصفناه أعلاه. فالطلب غير المتزامن يعطينا قيمة شبيهة بـ Future يمكن إلغاؤها، بينما في الحالة المتزامنة يمكننا مقاطعة الخيط الذي ينفّذ الطلب.

لكن عند مقاطعة طلب OkHttp، تبقى راية المقاطعة (interrupted flag) للخيط مرفوعة. ونتيجة لذلك، فإن أي عملية حجب لاحقة (مثلًا داخل كتلة finally) ستطلق InterruptedException فورًا، وقد لا يكون هذا ما نريده.

Http4s

للمقارنة، لنفحص طلبًا أُرسل باستخدام مكتبة من منظومة cats-effect. Cats-effect مكتبة للبرمجة المتزامنة (concurrent) وبيئة تشغيل غير متزامنة (متاحة لـ Scala على JVM وJS وNative). وهي تأتي بمفهومها الخاص للخيوط الخفيفة (تسمى fibers) وتتطلب أسلوب برمجة مختلفًا نوعًا ما.

هذه شيفرة العميل لدينا:

import cats.effect._
import org.http4s.ember.client.EmberClientBuilder
import org.slf4j.LoggerFactory
import scala.concurrent.duration.DurationInt
import sys.process._

object Run extends IOApp {
  private val log = LoggerFactory.getLogger(this.getClass)

  override def run(args: List[String]): IO[ExitCode] = EmberClientBuilder
    .default[IO]
    .build
    .use { client =>
      for {
        _ <- IO("/Applications/Wireshark.app/Contents/MacOS/wireshark -i lo0 -k -a duration:10".run())
        _ <- IO.sleep(3.seconds)
        _ <- IO(log.info("Sending ..."))
        f <- client
          .expect[String]("http://localhost:8080/wait")
          .start
        _ <- IO(log.info("Sent ..."))
        _ <- IO.sleep(1.second)
        _ <- IO(log.info("Cancelling ..."))
        _ <- f.cancel
        _ <- IO(log.info("Done."))
      } yield ()
    }
    .as(ExitCode.Success)
}

بفضل for-comprehension تُنفَّذ أوصاف التأثيرات المتداخلة واحدًا تلو الآخر. وتبدأ العملية .start بتشغيل الحساب الموصوف بالتأثير الذي تُستدعى عليه، في الخلفية على fiber جديد. وفي هذه الحالة يعني ذلك أن طلب HTTP يُنفَّذ بالتزامن.

ويمكن إلغاء fiber بـ f.cancel – وهذا بالضبط ما نعتمد عليه لإلغاء طلب HTTP.

مقاطعة خيط (افتراضي) وإلغاء fiber يختلفان في عدة جوانب مهمة. أحدها أن إلغاء fiber يمارس الضغط العكسي افتراضيًا، أي ينتظر حتى ينتهي الـ fiber (فقد تكون هناك مثلًا بعض دوال التنظيف finalizers). أما مع الخيط فعليك استدعاء .join() بعد .interrupt() للحصول على النتيجة نفسها. ويتيح هذا الخيار التصميمي لـ cats-effect توفير سلامة موارد أقوى حتى من البدائل.

HTTP/2

يكشف تشغيل الاختبار نفسه عبر HTTP/2 (المدعوم في HttpClient من Java وفي Jetty) عن اختلاف رئيسي واحد: بعد إلغاء الطلب يبقى الاتصال مفتوحًا. إذ تُرسل بدلًا من ذلك حزمة RST_STREAM، التي تغلق مجرى واحدًا فقط من المجاري المتعددة على ذلك الاتصال.

ونتيجة لذلك يمكن إعادة استخدام الاتصالات، فنتجنب تكلفة إنشاء اتصال جديد عند إرسال طلب، مع الاستمرار في تفادي إرسال بيانات غير لازمة.

البث (Streaming)

اختبرنا بالإضافة إلى ذلك سيناريو بنقطة نهاية تبثّ البيانات إلى العميل قطعة قطعة. وفي اختبارنا عنى ذلك إرسال أجزاء بيانات حجمها 1KB كل 100 ميلي ثانية على مدى 3 ثوانٍ. وكما في السابق ألغى العميل الطلب بعد ثانية واحدة.

النتيجة متقاربة: تلقى العميل بيانات الثانية الأولى، ثم أرسل حزمة FIN أغلقت المقبس من جانبه. وعندما يصل جزء البيانات التالي، يردّ العميل بـ RST.

وبالنسبة للخادم، نفّذنا البث بنسختين، باستخدام akka-http وhttp4s، لأن كلتا المكتبتين تسهّلان تعريف نقاط نهاية البث. وبمجرد أن يغلق العميل الاتصال، ينتهي البث بـ IOException: Broken pipe.

ففي هذا السيناريو يصل الإلغاء من جانب العميل إلى الخادم، فيتجنب العمل غير الضروري المتمثل في إنتاج عناصر إضافية للبث.

أبرز الخلاصات

فيما يلي ملخص لما كشفه تحقيقنا:

  • عملاء http التي تدعم الإلغاء هي async-http-client وHttpClient المدمج في Java (منذ JDK 16) وOkHttp وhttp4s
  • عملاء http التي لا تدعم الإلغاء تشمل HttpClient المدمج في Java (قبل JDK 16) وakka-http
  • مع HTTP/1.1، يؤدي إلغاء طلب HTTP إلى إغلاق الاتصال. ومع HTTP/2 يبقى الاتصال مفتوحًا ويمكن إعادة استخدامه لطلبات أخرى
  • لا «يعلم» الخادم بأن الاتصال أُغلق إلا عندما يحاول إرسال أولى إطارات الاستجابة، لذا تُرسل بعض البيانات دائمًا
  • مع مشروع Loom (الخيوط الافتراضية) يمكن إلغاء الطلبات المرسلة بـ HttpClient أو OkHttp بمقاطعة الخيط الذي تعمل عليه؛ غير أن OkHttp يترك راية المقاطعة مرفوعة
  • عندما ينتج الخادم بيانات الاستجابة تدريجيًا، قد ينتقل الإلغاء من العميل ويغلق المجرى على جانب الخادم