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

البرمجة المتزامنة مع Cats Effect

هذه المقالة دليل تعليمي للمبتدئين يغطي ميزات التزامن التي توفرها مكتبة Cats Effect.

8 دقائق قراءة
التزامنCats EffectFiber

التزامن أمر صعب. وكما يقول Brian Goetz في كتاب “Java Concurrency in Practice”:

من الصعب كتابة برامج صحيحة، ومن الأصعب كتابة برامج متزامنة صحيحة. فالبرنامج المتزامن لديه ببساطة طرق أكثر للفشل من البرنامج التسلسلي.

لحسن الحظ، توفر Scala أدوات ممتازة كثيرة تساعد على ترويض البرمجة المتزامنة، مثل Akka و ZIO و Finagle و Cats Effect. في هذه المقالة سأركز على ما تقدمه الأخيرة.

ما هو Fiber؟

اللبنة الأساسية للتزامن في CE هي الـ fiber. ببساطة، الـ fiber هو خيط منطقي خفيف يمثل سلسلة من الإجراءات. وفي CE يعني ذلك قائمة من العمليات المعلّقة داخل IO monad والمتسلسلة معًا باستخدام flatMap.

مقارنة بخيوط النظام، للـ fibers بصمة صغيرة. فهي، قبل كل شيء، تستهلك ذاكرة قليلة جدًا، ولذلك فهي ليست مورِدًا نادرًا مثل الخيوط. لا حاجة إلى مجمّعات fibers – يمكننا ببساطة إنشاء fiber جديد كلما احتجنا إليه.

وعلى عكس خيوط النظام، لا تعتمد الـ fibers على مجدول نظام التشغيل في تبديل السياق. بل تعتمد على مجدول على مستوى إطار العمل، يقرر متى وكيف تعمل. والـ fiber الواحد غير مرتبط بخيط محدد. يستطيع وقت تشغيل Cats Effect توزيع عشرات الآلاف من الـ fibers على عدد قليل من خيوط النظام. وعلى JVM يستخدم وقت التشغيل عادةً مجمّع خيوط ثابت الحجم موجّهًا للمعالج، بينما في البيئات أحادية الخيط مثل Scala.js يمكنه العمل حتى على خيط واحد فقط.
الصورة 1

إدارة الـ fibers

يتيح لنا CE تفريع الحسابات باستخدام الدالة start. وهي تُرجع كائنًا من النوع Fiber يوفر الدالة join. استدعاؤها يجعل الـ fiber الموجود في موضع الاستدعاء ينتظر حتى ينتهي الـ fiber المنضمّ إليه.

import cats.effect.*
import scala.concurrent.duration.*

val task = for {
  _ <- IO.println("Task started")
  _ <- IO.sleep(1.second)
  _ <- IO.println("Task completed")
} yield ()

for {
  fiber <- task.start
  _ <- IO.println("Hello from main fiber")
  //we wait approx. 1s till forked fiber completes
  _ <- fiber.join
} yield ()

يوفر Fiber أيضًا الدالة cancel، التي تلغي الـ fiber مع الحسابات الجارية عليه. ولا تُعيد cancel التحكم حتى يتم إنهاء كل مورد خُصّص في الـ fiber بشكل صحيح وإلغاء جميع العمليات الأساسية.

باستخدام onCancel(fin: IO[Unit]) يمكننا إعداد دالة إنهاء تعمل كلما أُلغيت مهمة.

import cats.effect.*
import scala.concurrent.duration.*

val task = for {
  _ <- IO.sleep(5.seconds)
  _ <- IO.println("Computations complete")
} yield ()

for {
  fiber <- task.onCancel(IO.println("Task canceled!")).start
  _ <- IO.sleep(1.second)
  //fiber would complete after 5s, but is canceled after 1s
  _ <- fiber.cancel
} yield ()

تُرجع join قيمة من النوع Outcome، وأنواعها الفرعية هي Succeeded و Errored و Canceled. ومطابقة الأنماط على النتيجة تتيح لنا فحص حالة الـ fiber المنتهي.

أي قيمة يُرجعها الـ fiber تُعرض كحقل في نتيجة Succeeded. هكذا يمكننا تمرير القيم من المهمة المفرّعة إلى موضع الاستدعاء.

import cats.effect.*
import scala.concurrent.duration.*

val task = IO.sleep(500.millis) *> IO.pure("Hello world!")

for {
 fiber <- task.start
 _ <- fiber.join.flatMap {
   case Outcome.Succeeded(value) => value.flatMap(
      v => IO.println(s"Computed value: $v")
   )
   case Outcome.Errored(e) => IO.println(s"Error: $e")
   case Outcome.Canceled() => IO.println("Task was canceled!")
 }
} yield ()

هناك أيضًا نسخة بديلة من join: وهي joinWith(onCancel: F[A]). تتيح لنا تقديم حساب بديل في حال أُلغي الـ fiber. ولها شكلان متخصصان: joinWithNever، وهو اختصار لـ joinWith(IO.never)، و joinWithUnit (اختصار لـ joinWith(IO.unit)).

المهلات الزمنية

تتيح لنا الدالة timeout تحديد حد زمني يُلغى بعده الـ fiber.

task
  .onCancel(IO.println("Task has timed out!"))
  .timeout(500.millis)
  .start

وباستخدام timeoutTo يمكننا تقديم بديل للحساب الملغى.

task
  .onCancel(IO.println("Task has timed out!"))
  .timeoutTo(500.millis, planB)
  .start

تمامًا مثل cancel، تنتظر دوال المهلة دائمًا حتى يتم إغلاق كل مورد خُصّص في الـ fiber بشكل صحيح. ولتجنب الانتظار يمكننا استخدام timeoutAndForget. فبمجرد استدعائها تُعيد التحكم إلى موضع الاستدعاء فورًا وتشغّل دوال الإنهاء بشكل غير متزامن. تذكّر أنه إذا لم تكتمل دوال الإنهاء أبدًا فسيحدث تسرّب في الـ fiber.

التزامن المنظَّم

الـ fiber الذي لا يُنضمّ إليه ولا يُلغى يعمل بالتوازي مع الـ fiber الموجود في موضع الاستدعاء. ولا ينتهي إلا عندما تكتمل حساباته أو تُطلق خطأ. وإذا كان الحساب على الـ fiber لا ينتهي أبدًا، فلن ينتهي الـ fiber أيضًا.

val task = for {
 time <- IO.realTimeInstant
 _ <- IO.println(f"Current date and time is $time")
 _ <- IO.sleep(1.second)
} yield ()

for {
 _ <- task.foreverM.start //task is running as an infinite loop
                          //and fiber is never canceled
 _ <- IO.sleep(5.seconds)
 _ <- IO.println("Bye")
} yield ()

قد يؤدي هذا إلى تسرّب الموارد. الـ fibers خفيفة جدًا، لكن إنشاء عدد كافٍ منها قد يستنزف الذاكرة المتاحة.

start و join والدوال المشابهة هي الأساسيات البدائية للتزامن في CE. وهي مفيدة، لكن يجب التعامل معها بحذر. يكفي القليل من الإهمال لتسريب الموارد أو الوقوع في حالات جمود (deadlock).

ولتجنب التسرّب، علينا إما إلغاء الـ fibers غير المطلوبة صراحةً أو الاعتماد على دوال أكثر أمانًا مثل background. تربط background دورة حياة الـ fiber بنوع البيانات Resource. وبمجرد إنهاء المورد يُلغى الـ fiber الأساسي أيضًا.

val backgroundTask: Resource[IO, Unit] = task
  .onCancel(IO.println("Closing the background task"))
  .background
  .void

backgroundTask.surround {
  for {
    _ <- IO.sleep(5.seconds)
    _ <- IO.println("Bye") //after foreground task is complete 
                           //the background fiber will be canceled
  } yield ()
}

حالة الـ fiber تتبع البنية النحوية للشيفرة. وتُعرف إدارة دورات حياة الـ fibers بهذه الطريقة باسم التزامن المنظَّم (structured concurrency).

يقدم CE أداة أخرى للتزامن المنظَّم: Supervisor. المشرف (supervisor) هو مورد قادر على إنشاء fibers ترتبط دورة حياتها بدورة حياته. وعند إنهاء المشرف، يضمن أيضًا إنهاء جميع الـ fibers التابعة له.

للمشرف وضعان، يُحدَّدان بتمرير العلم await عند إنشاء المورد. عندما يكون await مساويًا لـ false يلغي المشرف جميع خيوطه الحية عند إغلاقه، وهذا هو الوضع الافتراضي. وعندما يكون await مساويًا لـ true يظل إنهاء المشرف معلّقًا حتى ينتهي كل fiber.

Supervisor[IO](await = false).use { supervisor =>
  for {
    _ <- supervisor.supervise(
      IO.println("A").andWait(1.second).foreverM
    )
    _ <- supervisor.supervise(
      IO.println("B").andWait(2.second).foreverM
    )
    _ <- IO.sleep(5.seconds) //fibers will print A and B 
                             //for 5 seconds and then terminate
  } yield ()
}

إضافة عبارة الاستيراد import cats.effect.implicits.* تُدخل أيضًا إلى النطاق دالة الامتداد supervise للنوع IO. وتتيح لنا استدعاء supervise بطريقة مشابهة جدًا لاستدعاء start.

import cats.effect.implicits.*

Supervisor[IO](await = true).use { supervisor =>
   IO.println("Hello")
     .andWait(1.second)
     .foreverM
     .timeout(5.seconds)
     .supervise(supervisor)
}

عوامل التزامن

يقدم CE عددًا من التجريدات المفيدة عالية المستوى للعمليات المتعلقة بالتزامن.

مثلًا، تأخذ IO.race قيمتين من النوع IO، وتشغّلهما بالتوازي وتنتظر أيهما ينتهي أولًا. أما الأبطأ فيُلغى. وتُرجع race نتيجة من النوع IO[Either[A, B]].

val raced: IO[Either[String, Int]] = IO.race(
 IO("Faster").delayBy(5.seconds),
 IO(999).delayBy(10.seconds)
)

تمنحنا IO.racePair تحكمًا أدق فيما يحدث للـ fiber الخاسر. فهي تُرجع Outcome للمهمة الفائزة مع نسخة من كائن Fiber، التي يمكننا استخدامها لإلغاء الـ fiber الأبطأ أو الانضمام إليه. للوهلة الأولى قد يبدو نوع الإرجاع معقدًا إلى حد ما: Either[(OutcomeIO[A], FiberIO[B]), (FiberIO[A, OutcomeIO[B])]. عندما تفوز المهمة اليسرى نحصل على القيمة اليسرى من Either: وهي زوج مرتب يضم نتيجة الـ fiber الأيسر ومقبضًا للـ fiber الأيمن. وعندما تفوز اليمنى نحصل على القيمة اليمنى، وهذه المرة تحمل نتيجة الـ fiber الأيمن ومقبضًا للأيسر.

IO.racePair(IO(10), IO(5).delayBy(2.seconds)).flatMap {
 case Left((resL, fibR))  => 
   fibR.cancel *> IO(s"Left fiber outcome: $resL")
 case Right((fibL, resR)) => 
   fibL.cancel *> IO(s"Right fiber outcome: $resR")
}

عندما يلزم تشغيل حسابين بالتوازي وعلينا انتظار انتهائهما معًا، توجد عدة خيارات. تُرجع IO.both زوجًا مرتبًا يحوي النتيجتين: IO[(A, B)]. وإذا أُلغيت إحدى العمليتين أو فشلت، تُلغى الأخرى أيضًا.

IO.both(IO(1).delayBy(1.second), IO("Hello"))

لا توقف IO.bothOutcome الـ fiber الآخر، حتى لو أُلغي الأول. وتُرجع زوجًا مرتبًا بنتيجتي الـ fiberين.

توفر مكتبة Cats مجموعة من العوامل لتشغيل التأثيرات بالتوازي. ولأنها منفذة كدوال امتداد، فإن استخدامها يتطلب الاستيرادات المناسبة لإدخال الـ implicits المطلوبة إلى النطاق.

import cats.syntax.all.*

parTupled قريبة جدًا من IO.both. تُستدعى على زوج من قيمتين IO وتشغّلهما معًا بالتوازي، وتنتج نتيجة من النوع IO[(A, B)]. ودلالاتها مطابقة لدلالات tupled، باستثناء أن tupled تشغّل التأثيرات واحدًا بعد الآخر.

ولتشغيل أي عدد من التأثيرات بالتزامن، يمكننا اللجوء إلى النسخ المتوازية من traverse و sequence: وهي parTraverse و parSequence.

val r: IO[List[Int]] = List(
 IO(1).delayBy(1.second),
 IO(2).delayBy(2.seconds),
 IO(3).delayBy(3.seconds)
).parSequence

تتيح لنا الصيغتان parTraverseN و parSequenceN تحديد عدد المهام التي تعمل في وقت واحد. وهما تأخذان معاملًا إضافيًا من النوع Int يحدد أقصى درجة من التوازي.

افتراضيًا، تحافظ كل من parTraverse و parSequence على ترتيب المهام، وقد يضيف ذلك عبئًا طفيفًا على الأداء. أما parTraverseUnordered و parSequenceUnordered، في المقابل، فلا تحافظان على الترتيب، لذا قد تعملان أسرع.

وأخيرًا، هناك عاملان رمزيان مفيدان: &> و <&. وهما أيضًا يشغّلان تأثيرين بالتوازي. إذا فشل أي IO يُلغى الآخر، وإذا أُلغي الحساب بأكمله تُلغى العمليتان معًا. ويُرجع &> القيمة اليمنى، و <& القيمة اليسرى.

//we'll get 1 after approx. 2s
IO(1).delayBy(1.second) <& IO(2).delayBy(2.seconds)

يمكن اعتبار هذه العوامل مكافئات متوازية للعوامل التسلسلية *> و <* و << و >>.

الخلاصة

الهدف من هذه المقالة هو تقديم مدخل بمستوى المبتدئين إلى ميزات التزامن المتاحة في Cats Effect. وهناك الكثير في CE يتجاوز ما غُطي هنا. فمثلًا، تركت جانبًا بنى البيانات القوية المصممة لإدارة الوصول المتزامن إلى البيانات، مثل Ref أو Queue. وقد يكون ذلك موضوعًا جيدًا لمقالة منفصلة. آمل أن تكون هذه المقالة مفيدة لك. إلى اللقاء!