Զուգահեռ ծրագրավորում Cats Effect-ով
Այս հոդվածը սկսնակների համար նախատեսված ձեռնարկ է, որն ընդգրկում է Cats Effect-ի առաջարկած զուգահեռության հնարավորությունները։
Զուգահեռությունը դժվար է։ Ինչպես Բրայան Գյոցը գրում է «Java Concurrency in Practice» գրքում.
Ճիշտ ծրագրեր գրելը դժվար է, իսկ ճիշտ զուգահեռ ծրագրեր գրելն էլ ավելի դժվար է։ Զուգահեռ ծրագիրը պարզապես ավելի շատ եղանակներ ունի սխալվելու, քան հաջորդականը։
Մեր բախտը բերել է. Scala-ն առաջարկում է բազմաթիվ գերազանց գործիքներ, որոնք օգնում են սանձել զուգահեռ ծրագրավորումը, ինչպիսիք են Akka-ն, ZIO-ն, Finagle-ը կամ Cats Effect-ը։ Այս հոդվածում ես կկենտրոնանամ վերջինիս հնարավորությունների վրա։
Ի՞նչ է Fiber-ը
CE-ում զուգահեռության հիմնարար կառուցողական բլոկը fiber-ն է։ Պարզ ասած՝ fiber-ը թեթև տրամաբանական թել է, որը ներկայացնում է գործողությունների հաջորդականություն։ CE-ում դա նշանակում է IO մոնադում կասեցված և flatMap-ով իրար կապված գործողությունների ցանկ։
Համակարգային թելերի համեմատ fiber-ները փոքր հետք ունեն։ Առաջին հերթին դրանք շատ քիչ հիշողություն են օգտագործում, ուստի թելերի պես սակավ ռեսուրս չեն։ Fiber-ների լողավազաններ պետք չեն. կարող ենք պարզապես ստեղծել նոր fiber, երբ որ պետք լինի։
Համակարգային թելերից տարբերվելով՝ fiber-ները համատեքստի փոխարկման համար կախված չեն օպերացիոն համակարգի պլանավորիչից։ Փոխարենը դրանք ապավինում են ֆրեյմվորքի մակարդակի պլանավորիչին, որը որոշում է՝ երբ և ինչպես դրանք աշխատեն։ Տվյալ fiber-ը կապված չէ որևէ կոնկրետ թելի հետ։ Cats Effect-ի runtime-ը կարող է տասնյակ հազարավոր fiber-ներ մուլտիպլեքսավորել մի բուռ համակարգային թելերի վրա։ JVM-ում runtime-ը սովորաբար օգտագործում է ֆիքսված չափի, պրոցեսորից կախված թելերի լողավազան, իսկ մեկ թելով միջավայրերում, ինչպիսին Scala.js-ն է, կարող է աշխատել նույնիսկ միայն մեկ թելի վրա։

Fiber-ների կառավարումը
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])-ի օգնությամբ կարող ենք սահմանել ավարտիչ (finalizer), որը կաշխատի ամեն անգամ, երբ առաջադրանքը չեղարկվի։
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-ը։ Արդյունքի վրա pattern matching կատարելով՝ կարող ենք ստուգել ավարտված 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)-ի կրճատ գրառումը)։
Ժամկետներ (timeouts)
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-ը, timeout-ի մեթոդները նույնպես միշտ սպասում են, մինչև fiber-ում հատկացված բոլոր ռեսուրսները ճիշտ փակվեն։ Սպասելուց խուսափելու համար կարող ենք օգտագործել timeoutAndForget-ը։ Կանչվելուց հետո այն անմիջապես վերադարձնում է կառավարումը կանչի վայրին, իսկ ավարտիչները աշխատեցնում է ասինխրոն կերպով։ Հիշեք, որ եթե ավարտիչները երբեք չավարտվեն, fiber-ը կհոսի (leak)։
Կառուցվածքային զուգահեռություն
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 ()
Սա կարող է հանգեցնել ռեսուրսների արտահոսքի։ Fiber-ները բավականին թեթև են, բայց դրանցից բավականաչափ շատը ստեղծելով՝ դեռ կարելի է սպառել հասանելի հիշողությունը։
start-ը, join-ը և նմանատիպ մեթոդները CE-ի զուգահեռության պրիմիտիվներն են։ Դրանք օգտակար են, բայց պետք է զգուշությամբ վարվել։ Փոքր անփութությունը բավական է ռեսուրսներ արտահոսեցնելու կամ փակուղիների (deadlock) հանգեցնելու համար։
Արտահոսքերից խուսափելու համար պետք է կամ ավելորդ fiber-ները բացահայտորեն չեղարկել, կամ ապավինել ավելի անվտանգ մեթոդների, ինչպիսին 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-ի վիճակը հետևում է կոդի շարահյուսական կառուցվածքին։ Fiber-ների կյանքի ցիկլի նման կառավարումը հայտնի է որպես կառուցվածքային զուգահեռություն։
CE-ն առաջարկում է կառուցվածքային զուգահեռության ևս մեկ գործիք՝ Supervisor։ Supervisor-ը ռեսուրս է, որը կարող է ստեղծել fiber-ներ, որոնց կյանքի ցիկլը կապված է իր սեփականի հետ։ Երբ supervisor-ը վերջնականացվում է, այն նաև ապահովում է, որ իր բոլոր ժառանգ fiber-ները ավարտվեն։
Supervisor-ը երկու ռեժիմ ունի, որոնք ընտրվում են ռեսուրս ստեղծելիս await դրոշակ փոխանցելով։ Երբ await-ը false է, supervisor-ը իր անջատման ժամանակ չեղարկում է իր բոլոր կենդանի թելերը. սա լռելյայն ռեժիմն է։ Երբ await-ը true է, supervisor-ի ավարտը արգելափակվում է, մինչև բոլոր 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.* import դրույթ ավելացնելով՝ տիրույթ է մտնում նաև IO-ի համար supervise ընդլայնման մեթոդը։ Այն թույլ է տալիս 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 գրադարանը առաջարկում է օպերատորների շարք էֆեկտները զուգահեռ աշխատեցնելու համար։ Քանի որ դրանք իրականացված են որպես ընդլայնման մեթոդներ, դրանք օգտագործելու համար պետք են համապատասխան import-ներ, որպեսզի համապատասխան implicit-ները մտնեն տիրույթ։
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-ն։ Դա կարող է լավ թեմա լինել առանձին հոդվածի համար։ Հուսով եմ՝ այս գրառումը օգտակար էր։ Կեցե՛ք բարի։