Väljakutse

Kirjutamine samaaegsed programmid on raske. Keermete, lukkude, võistlustingimuste ja muu probleemiga tegelemine on väga veaohtlik ja võib viia koodini, mida on raske lugeda, testida ja hooldada.

Seetõttu eelistavad paljud mitmikeermelist vältimist. Selle asemel kasutavad nad ainult üheahelalisi protsesse, tuginedes vajalike samaaegsete või asünkroonsete toimingute haldamisele välisteenustele (nagu andmebaasid, järjekorrad jne). Kuigi see lähenemine on mõnel juhul seaduslik alternatiiv, on palju stsenaariume, kus see pole lihtsalt otstarbekas valik. Paljud reaalajas olevad süsteemid - näiteks kauplemis- või pangarakendused või reaalajas mängud - ei oma luksust oodata ühe keermega protsessi lõpuleviimist (neile on vaja vastust kohe!). Teised süsteemid on nii arvutus- kui ka ressursimahukad, et nende töötamiseks kuluks ülemäära palju aega (mõnel juhul tunde või isegi päevi), ilma et nende koodi sisse viidaks paralleelsus.

Üks üsna tavaline üheahelaline lähenemine (kasutatakse laialdaselt Node.js maailmas) on kasutada sündmusepõhist, mitteblokeerivat paradigmat. Ehkki see aitab tulemuslikkust, vältides kontekstilülitusi, lukustamist ja blokeerimist, ei lahenda see siiski mitme protsessori samaaegse kasutamise probleeme (see eeldaks mitme sõltumatu protsessi käivitamist ja kooskõlastamist).

discord bot keeles c++

Niisiis, kas see tähendab, et teil pole muud valikut, kui teete samaaegse rakenduse loomiseks sügavale niitide, lukkude ja võistlustingimuste sisemusse?

Tänu Akka raamistikule on vastus eitav. Selles õpetuses tutvustatakse Akka näiteid ja uuritakse viise, kuidas see hõlbustab ja lihtsustab samaaegsete hajutatud rakenduste rakendamist.

Mis on Akka raamistik?

Selles postituses tutvustatakse Akkat ja uuritakse viise, kuidas see hõlbustab ja lihtsustab samaaegsete hajutatud rakenduste rakendamist.

Akka on tööriistakomplekt ja käitusaeg JVM-i väga samaaegsete, hajutatud ja rikketaluvate rakenduste loomiseks. Akka on kirjutatud aastal Redel , nii Scala kui ka Java jaoks ette nähtud keelköited.

Akka lähenemine samaaegsuse käsitlemisele põhineb Näitleja mudel . Näitlejapõhises süsteemis on kõik näitleja, umbes samamoodi nagu kõik on objektile suunatud kujunduses objekt. Peamine erinevus - ehkki meie arutelu seisukohalt on see eriti oluline - on see, et näitlejamudel on spetsiaalselt välja töötatud ja ehitatud selleks, et olla samaaegne mudel, samas kui objektorienteeritud mudel seda pole. Täpsemalt öeldes: Scala näitlejate süsteemis suhtlevad näitlejad ja jagavad teavet, ilma et oleks vaja järjestikkust. Mehhanism, mille kaudu osalejad omavahel teavet jagavad ja üksteisele ülesandeid annavad, on sõnumi edastamine.

Kogu lõimede loomise ja ajastamise, sõnumite vastuvõtmise ja saatmise ning võistlustingimuste ja sünkroonimise keerukus on raamistikus läbipaistvaks käsitsemiseks.

Akka loob näitlejate ja alussüsteemi vahele kihi, nii et näitlejad peavad lihtsalt sõnumeid töötlema. Kogu lõimede loomise ja ajastamise, sõnumite vastuvõtmise ja saatmise ning võistlustingimuste ja sünkroonimise keerukus on raamistikus läbipaistvaks käsitsemiseks.

Akka peab rangelt kinni Reaktiivne manifest . Reaktiivsete rakenduste eesmärk on asendada traditsioonilised mitme lõimega rakendused arhitektuuriga, mis vastab ühele või mitmele järgmisest nõudest:

• Üritusel põhinev. Aktiivide abil saab kirjutada koodi, mis käsitleb päringuid asünkroonselt ja kasutab ainult blokeerimata toiminguid.
• Skaalautuv. Akkas on tänu sõnumite edastamisele ja asukoha läbipaistvusele sõlmede lisamine ilma koodi muutmata.
• Elastne. Mis tahes rakenduses ilmnevad mingil ajahetkel vead ja tõrge. Akka pakub enesetervendussüsteemi hõlbustamiseks „järelevalve” (rikketaluvuse) strateegiaid.
• Tundlik. Paljud tänapäevased suure jõudlusega ja kiirreageerimisrakendused peavad andma kasutajale kiiret tagasisidet ja seetõttu reageerima sündmustele äärmiselt õigeaegselt. Akka mitteblokeeriv sõnumipõhine strateegia aitab seda saavutada.

Mis on Akkas näitleja?

Näitleja pole sisuliselt midagi muud kui objekt, mis võtab vastu sõnumeid ja võtab nende käsitsemiseks tegevusi. See on sõnumi allikast lahti ühendatud ja selle ainus vastutus on vastuvõetud sõnumi tüüp korralikult ära tunda ja vastavalt sellele tegutseda.

Sõnumi saamisel võib näitleja teha ühe või mitu järgmistest toimingutest:

• Mõne toimingu sooritamine ise (näiteks arvutuste tegemine, andmete püsimine, välisele veebiteenusele helistamine jne)
• Edastage sõnum või tuletatud sõnum teisele osalejale
• Käivitage uus näitleja ja edastage talle sõnum

Teise võimalusena võib näitleja otsustada sõnumit täielikult ignoreerida (st võib valida tegevusetuse), kui ta peab seda asjakohaseks.

Näitleja rakendamiseks on vaja laiendada akka.actor.Actori omadust ja rakendada vastuvõtu meetodit. Näitleja vastuvõtmismeetodile tugineb (Akka), kui sellele näitlejale saadetakse sõnum. Selle tüüpiline teostus koosneb mustri sobitamisest, nagu on näidatud järgmises Akka näites, sõnumi tüübi tuvastamiseks ja vastavalt reageerimiseks:

import akka.actor.Actor import akka.actor.Props import akka.event.Logging class MyActor extends Actor { def receive = { case value: String => doSomething(value) case _ => println('received unknown message') } }

Mustrite sobitamine on sõnumite käsitlemiseks suhteliselt elegantne tehnika, mis kipub tootma 'puhtamat' ja hõlpsamini navigeeritavat koodi kui tagasihelistamistel põhinev võrreldav rakendus. Mõelgem näiteks lihtsustatud HTTP-päringu / vastuse rakendamisele.

Kõigepealt rakendame seda JavaScripti tagasihelistuspõhise paradigma abil:

route(url, function(request){ var query = buildQuery(request); dbCall(query, function(dbResponse){ var wsRequest = buildWebServiceRequest(dbResponse); wsCall(wsRequest, function(wsResponse) { sendReply(wsResponse); }); }); });

Nüüd võrdleme seda mustrivastamise põhise rakendusega:

msg match { case HttpRequest(request) => { val query = buildQuery(request) dbCall(query) } case DbResponse(dbResponse) => { var wsRequest = buildWebServiceRequest(dbResponse); wsCall(dbResponse) } case WsResponse(wsResponse) => sendReply(wsResponse) }

Kuigi tagasihelistamispõhine JavaScripti kood on küll kompaktne, on seda kindlasti raskem lugeda ja navigeerida. Võrdluseks - mustrivastamise põhine kood teeb kohe selgemaks, milliseid juhtumeid kaalutakse ja kuidas neid iga käsitletakse.

Näitleja süsteem

Kompleksse probleemi võtmine ja rekursiivne jagamine väiksemateks alamprobleemideks on üldjuhul mõistlik probleemide lahendamise tehnika. See lähenemisviis võib olla eriti kasulik arvutiteaduses (kooskõlas programmiga Ühe vastutuse põhimõte ), kuna see kipub andma puhta, moduleeritud koodi, vähese või ilma üleliigseteta, seda on suhteliselt lihtne hooldada.

Näitlejapõhises kujunduses hõlbustab selle tehnika kasutamine näitlejate loogilist korrastamist hierarhilisse struktuuri, mida tuntakse kui Näitleja süsteem . Näitleja süsteem pakub infrastruktuuri, mille kaudu osalejad üksteisega suhtlevad.

Akkas on ainus viis näitlejaga suhelda ActorRef kaudu. An ActorRef tähistab viidet näitlejale, mis välistab teiste objektide juurdepääsu selle näitleja sisemusele ja olekule või sellega manipuleerimise. Näitlejale võib näitlejale saata ActorRef kasutades ühte järgmistest süntaksiprotokollidest:

• ! (“Öelda”) - saadab sõnumi ja naaseb kohe
• ? (“Küsi”) - saadab sõnumi ja tagastab a Tulevik mis esindab võimalikku vastust

Igal näitlejal on postkast, kuhu tema saabuvad sõnumid edastatakse. Postkasti rakendusi on mitu, millest valida, vaikimisi rakenduseks on FIFO.

Näitleja sisaldab paljude eksemplaride muutujaid oleku säilitamiseks mitme sõnumi töötlemise ajal. Akka tagab, et näitleja iga eksemplar töötab oma kergekaalulises vormis ja sõnumeid töödeldakse ükshaaval. Nii saab iga osaleja seisundit usaldusväärselt säilitada, ilma et arendajal oleks vaja sünkroonimise või võistlustingimuste pärast selgesõnaliselt muretseda.

punase värvi psühholoogilised mõjud

Igale näitlejale antakse Akka Actori API kaudu ülesannete täitmiseks järgmine kasulik teave:

• sender: an ActorRef praegu töödeldava sõnumi saatjale
• context: teave ja meetodid, mis on seotud kontekstiga, milles osaleja töötab (sisaldab näiteks actorOf meetodit uue osaleja esilekutsumiseks)
• supervisionStrategy: määratleb strateegia, mida tuleb vigadest taastuda
• self: the ActorRef näitleja enda jaoks

Akka tagab, et näitleja iga eksemplar töötab oma kergekaalulises vormis ja sõnumeid töödeldakse ükshaaval. Nii saab iga näitleja seisundit usaldusväärselt säilitada, ilma et arendajal oleks vaja sünkroonimise või võistlustingimuste pärast selgesõnaliselt muretseda.

Nende õpetuste omavahelise sidumise huvides kaalume lihtsat näidet sõnade arvu lugemiseks tekstifailis.

Akka näite jaoks jaotame probleemi kaheks alamülesandeks; nimelt: (1) 'lapse' ülesanne loendada sõnade arv ühel real ja (2) 'vanem' ülesanne nende ridade kaupa kokku lugeda, et saada failis olevate sõnade koguarv.

Vanemnäitleja laadib failist iga rea ​​ja delegeerib seejärel alamnäitlejale ülesande selles reas olevad sõnad kokku lugeda. Kui laps on valmis, saadab ta selle tulemusega vanemale tagasi. Lapsevanem saab sõnumid loenditega (iga rea ​​kohta) ja hoiab loendurit kogu failis olevate sõnade koguarvu kohta, mille ta pärast lõpetamist tagasi kutsub.

(Pange tähele, et allpool toodud Akka õpetuse koodi näidised on mõeldud ainult didaktiliseks ja seetõttu ei puuduta need tingimata kõiki servatingimusi, jõudluse optimeerimist jne. Samuti on allpool näidatud koodinäidiste täielik kompileeritav versioon saadaval seda põhisisu .)

Vaatame kõigepealt lapse näidisrakendust StringCounterActor klass:

case class ProcessStringMsg(string: String) case class StringProcessedMsg(words: Integer) class StringCounterActor extends Actor { def receive = { case ProcessStringMsg(string) => { val wordsInLine = string.split(' ').length sender ! StringProcessedMsg(wordsInLine) } case _ => println('Error: message not recognized') } }

Sellel näitlejal on väga lihtne ülesanne: tarbida ProcessStringMsg sõnumeid (mis sisaldavad tekstirida), loendage määratud rea sõnade arv ja tagastage tulemus saatjale StringProcessedMsg sõnum. Pange tähele, et oleme oma klassi juurutanud ! ('Tell') meetod StringProcessedMsg saatmiseks sõnum (st sõnumi saatmiseks ja viivitamatuks naasmiseks).

OK, pöörame nüüd tähelepanu vanemale WordCounterActor klass:

1. case class StartProcessFileMsg() 2. 3. class WordCounterActor(filename: String) extends Actor { 4. 5. private var running = false 6. private var totalLines = 0 7. private var linesProcessed = 0 8. private var result = 0 9. private var fileSender: Option[ActorRef] = None 10. 11. def receive = { 12. case StartProcessFileMsg() => { 13. if (running) { 14. // println just used for example purposes; 15. // Akka logger should be used instead 16. println('Warning: duplicate start message received') 17. } else { 18. running = true 19. fileSender = Some(sender) // save reference to process invoker 20. import scala.io.Source._ 21. fromFile(filename).getLines.foreach { line => 22. context.actorOf(Props[StringCounterActor]) ! ProcessStringMsg(line) 23. totalLines += 1 24. } 25. } 26. } 27. case StringProcessedMsg(words) => { 28. result += words 29. linesProcessed += 1 30. if (linesProcessed == totalLines) { 31. fileSender.map(_ ! result) // provide result to process invoker 32. } 33. } 34. case _ => println('message not recognized!') 35. } 36. }

Siin toimub palju asju, nii et uurime neid kõiki üksikasjalikumalt (pange tähele, et järgnevas arutelus viidatud reanumbrid põhinevad ülaltoodud koodinäidisel) ...

Kõigepealt pange tähele, et töödeldava faili nimi edastatakse WordCounterActor konstruktor (rida 3). See näitab, et näitlejat saab kasutada ainult ühe faili töötlemiseks. See lihtsustab ka arendaja kodeerimistööd, vältides oleku muutujate lähtestamise vajadust (running, totalLines, linesProcessed ja result), kui töö on lõpule viidud, kuna eksemplari kasutatakse ainult üks kord (st ühe faili töötlemiseks) ja seejärel visatakse ära.

Järgmisena jälgige, et WordCounterActor tegeleb kahte tüüpi sõnumitega:

• StartProcessFileMsg (rida 12)
  • Saadud väliselt tegutsejalt, kes algatas algatuse WordCounterActor
  • Kui see on kätte saadud, WordCounterActor kõigepealt kontrollib, kas ta ei saa üleliigset taotlust.
  • Kui taotlus on üleliigne, WordCounterActor genereerib hoiatuse ja midagi enamat ei tehta (rida 16).
  • Kui taotlus pole üleliigne:
    • WordCounterActor salvestab saatjale viite kausta fileSender eksemplari muutuja (pange tähele, et see on pigem Option[ActorRef] kui Option[Actor] - vt rida 9). See ActorRef on vajalik selleks, et hiljem StringProcessedMsg töötlemisel sellele juurde pääseda ja sellele vastata (mis saadakse StringCounterActor lapselt, nagu allpool kirjeldatud).
    • WordCounterActor siis loeb faili ja kui faili iga rida laaditakse, siis StringCounterActor laps luuakse ja talle edastatakse sõnum, mis sisaldab töödeldavat rida (read 21–24).
• StringProcessedMsg (rida 27)
  • Saadud lapselt StringCounterActor kui see lõpetab talle määratud liini töötlemise.
  • Kui see on kätte saadud, WordCounterActor suurendab faili realoendurit ja kui kõik faili read on töödeldud (st kui totalLines ja linesProcessed on võrdsed), saadab see lõpptulemuse algsele fileSender (read 28-31).

Veelkord pange tähele, et Akkas on ainus näitlejatevahelise suhtlemise mehhanism sõnumi edastamine. Näitlejad on ainsad, mida näitlejad jagavad, ja kuna näitlejad võivad samadele sõnumitele samaaegselt juurde pääseda, on rassitingimuste ja ootamatu käitumise vältimiseks oluline, et nad oleksid muutumatud.

Juhtumiklassid Scalas on tavalised klassid, mis tagavad mustrite sobitamise kaudu rekursiivse lagunemismehhanismi.

Seetõttu on sõnumite edastamine juhtumiklassidena tavaline, kuna need on vaikimisi muutumatud ja selle tõttu, kui sujuvalt nad mustrite sobitamisega integreeruvad.

Lõpetame näite koodinäidisega kogu rakenduse käitamiseks.

object Sample extends App { import akka.util.Timeout import scala.concurrent.duration._ import akka.pattern.ask import akka.dispatch.ExecutionContexts._ implicit val ec = global override def main(args: Array[String]) { val system = ActorSystem('System') val actor = system.actorOf(Props(new WordCounterActor(args(0)))) implicit val timeout = Timeout(25 seconds) val future = actor ? StartProcessFileMsg() future.map { result => println('Total number of words ' + result) system.shutdown } } } Samaaegsel programmeerimisel on „tulevik“ sisuliselt kohatäite objekt tulemuse jaoks, mis pole veel teada.

Pange tähele, kuidas seekord ? meetodit kasutatakse sõnumi saatmiseks. Sel moel saab helistaja tagastatut kasutada Tulevik lõpptulemuse printimiseks, kui see on saadaval, ja programmist väljumiseks ActorSystem välja lülitades.

Akka rikketaluvus ja juhendaja strateegiad

Näitlejate süsteemis on iga näitleja oma laste juhendaja. Kui näitleja sõnumiga hakkama ei saa, peatab ta ennast ja kõik oma lapsed ning saadab oma juhendajale tavaliselt erandina sõnumi.

Akkas on juhendaja strateegiad peamine ja sirgjooneline mehhanism teie süsteemi rikketaluva käitumise määratlemiseks.

Akkas nimetatakse seda, kuidas juhendaja reageerib ja tegeleb eranditega, mis tema juurest läbi imbuvad, kui juhendaja strateegiat. Juhendaja strateegiad on peamine ja otsene mehhanism, mille abil saate määratleda oma süsteemi rikketaluva käitumise.

tehisintellekt äriintellektis

Kui ebaõnnestumist tähistav teade jõuab juhendajani, võib ta teha ühe järgmistest toimingutest.

• Taastage laps (ja tema lapsed), hoides tema sisemist seisundit. Seda strateegiat saab rakendada siis, kui viga ei rikkunud alamriiki ja see saab õigesti edasi töötada.
• Taaskäivitage laps (ja tema lapsed), puhastades tema sisemise oleku. Seda strateegiat saab kasutada äsja kirjeldatud stsenaariumi vastupidises stsenaariumis. Kui lapseseisund on tõrke tõttu rikutud, tuleb selle olek enne tulevases kasutamiseks lähtestada.
• Peatage laps (ja tema lapsed) jäädavalt. Seda strateegiat saab kasutada juhtudel, kui arvatakse, et veatingimust ei saa parandada, kuid see ei ohusta ülejäänud toimingut, mida saab teha, kui ebaõnnestunud laps puudub.
• Peatage ennast ja suurendage viga. Töötatakse siis, kui juhendaja ei tea, kuidas rikke korral käituda, ja seepärast laieneb see enda juhendajale.

Veelgi enam, näitleja võib otsustada rakendada tegevust ainult ebaõnnestunud lastele või ka oma õdedele-vendadele. Selleks on kaks eelnevalt määratletud strateegiat:

• OneForOneStrategy: Rakendab määratud toimingu ainult nurjunud lapsele
• AllForOneStrategy: Rakendab määratud toimingut kõigile oma lastele

Siin on lihtne näide OneForOneStrategy

import akka.actor.OneForOneStrategy import akka.actor.SupervisorStrategy._ import scala.concurrent.duration._ override val supervisorStrategy = OneForOneStrategy() { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: IllegalArgumentException => Stop case _: Exception => Escalate }

Kui strateegiat pole määratud, kasutatakse järgmist vaikestrateegiat:

• Kui näitleja lähtestamisel tekkis viga või kui näitleja tapeti, peatatakse näitleja.
• Kui oli mingisuguseid muid erandeid, alustatakse näitlejat lihtsalt uuesti.

Selle vaikestrateegia Akka poolt pakutav rakendus on järgmine:

final val defaultStrategy: SupervisorStrategy = { def defaultDecider: Decider = { case _: ActorInitializationException ⇒ Stop case _: ActorKilledException ⇒ Stop case _: Exception ⇒ Restart } OneForOneStrategy()(defaultDecider) }

Akka võimaldab rakendada kohandatud juhendaja strateegiad , kuid nagu Akka dokumentatsioon hoiatab, tehke seda ettevaatlikult, kuna vale rakendamine võib põhjustada selliseid probleeme nagu blokeeritud näitleja süsteemid (s.t alaliselt peatatud osalejad).

Asukoha läbipaistvus

Akka arhitektuur toetab asukoha läbipaistvus , mis võimaldab näitlejatel olla täielikult agnostiline nende sõnumite päritolu suhtes. Sõnumi saatja võib elada näitlejaga samas JVM-is või eraldi JVM-is (kas töötab samal või teisel sõlmel). Akka võimaldab kõigi nende juhtumite käsitlemist näitlejale (ja seega ka arendajale) täiesti läbipaistval viisil. Ainus hoiatus on see, et mitme sõlme kaudu saadetud sõnumid peavad olema jadatav.

Akka arhitektuur toetab asukoha läbipaistvust, võimaldades osalejatel olla täielikult agnostiline nende sõnumite päritolu suhtes.

Näitlejate süsteemid on loodud töötama hajutatud keskkonnas ilma spetsiaalset koodi nõudmata. Akka nõuab ainult konfiguratsioonifaili (application.conf) olemasolu, mis määrab sõlmed, kuhu sõnumeid saata. Siin on lihtne näide konfiguratsioonifailist:

akka { actor { provider = 'akka.remote.RemoteActorRefProvider' } remote { transport = 'akka.remote.netty.NettyRemoteTransport' netty { hostname = '127.0.0.1' port = 2552 } } }

Mõned näpunäited lahkuminekuks ...

Oleme näinud, kuidas Akka raamistik aitab saavutada samaaegsust ja kõrget jõudlust. Kuid nagu see õpetus märkis, on teie süsteemi kujundamisel ja juurutamisel meeles pidada mõningaid punkte, et Akka jõudu täiel määral ära kasutada:

• Igale osalejale tuleks võimalikult suures ulatuses anda võimalikult väike ülesanne (nagu eelnevalt arutletud, järgides Ühe vastutuse põhimõte )

• Näitlejad peaksid sündmusi (st töötlema sõnumeid) käsitsema asünkroonselt ega tohiks blokeerida, vastasel juhul toimuvad kontekstivahetused, mis võivad jõudlust negatiivselt mõjutada. Täpsemalt on kõige parem teha blokeerimisoperatsioone (IO jne) tulevikus, et mitte blokeerida näitlejat; st .:

  case evt => blockingCall() // BAD case evt => Future { blockingCall() // GOOD }
• Veenduge, et teie sõnumid oleksid kõik muutumatud, sest näitlejad, kes neid üksteisele edastavad, jooksevad kõik samaaegselt oma lõimetes. Muutuvad sõnumid põhjustavad tõenäoliselt ootamatut käitumist.
• Kuna sõlmede vahel saadetud sõnumid peavad olema järjestikustatavad, on oluline arvestada, et mida suuremad on sõnumid, seda kauem kulub nende järjestamiseks, saatmiseks ja deserialiseerimiseks, mis võib jõudlust negatiivselt mõjutada.

Järeldus

Akka, kirjutatud aastal Redel , lihtsustab ja hõlbustab väga samaaegsete, hajutatud ja rikketaluvate rakenduste väljatöötamist, varjates suure osa keerukusest arendaja eest. Akka täieliku õigluse tagamine nõuaks palju enamat kui see ainus õpetus, kuid loodetavasti olid see sissejuhatus ja selle näited piisavalt köitvad, et tekiks soov rohkem lugeda.

Amazon, VMWare ja CSC on vaid mõned näited juhtivatest ettevõtetest, kes Akkat aktiivselt kasutavad. Külastage Akka ametlik veebisait rohkem teada saada ja uurida, kas Akka võiks olla ka teie projekti jaoks õige vastus.