设计分布式应用：实战Akka模式

需积分: 10 100 浏览量更新于2024-07-20 收藏 2.97MB PDF 举报

"《Applied Akka Patterns》是一本实践导向的手册，专为设计分布式应用程序而编写的，作者是Michael Nash和Wade Waldron。这本书于2017年出版，由O'Reilly Media公司发行，享有版权。它深入探讨了Akka框架中的模式和最佳实践，旨在帮助开发者创建出更健壮和优雅的分布式系统。 Akka是一个强大的并行与分布式计算框架，特别适合在现代高性能、高并发的环境中构建可扩展的应用。本书将读者带入实际应用Akka Pattern的世界，这些模式包括但不限于Actor模型、Mailbox策略、事件驱动编程、以及如何处理错误和故障恢复。通过实例分析和详细步骤，读者能够理解和掌握如何有效地设计和实现分布式任务处理、消息传递、协调和容错机制。书中涵盖了诸如发布/订阅模式（Publish/Subscribe）、管道和扇出（Pipeline and Fanout）、路由器（Router）、Supervision Hierarchies等核心Akka模式，同时还会介绍如何利用这些模式解决常见的分布式挑战，如负载均衡、数据一致性问题和复杂系统的组织架构。《Applied Akka Patterns》不仅提供理论知识，还提供了丰富的实战经验，使读者能够将其应用于自己的项目中，提升代码的可靠性和性能。此外，它还包含了针对最新版本的Akka的实用指导，确保读者能够跟上技术的发展。对于那些希望在分布式系统设计中运用Akka的开发者来说，这本书是一本不可或缺的参考书籍。它不仅适合有经验的Akka用户，也对初学者来说是一个逐步学习和理解高级模式的好资源。无论你是正在寻找优化现有系统的方法，还是想探索新的分布式计算技术，都能在这本书中找到有价值的见解和实践技巧。"

AllComputationIsPerformedWithinanActor

CarlHewittcalledtheactorthefundamentalunitofcomputation.

Whatdoesitmeantobethe

fundamentalunitofcomputation?ItmeansthatwhenyoubuildasystemusingtheActor

Model,everythingisanactor.WhetheryouarecomputingaFibonaccisequenceor

maintainingthestateofauserinyoursystem,youdosowithinanactor,ormultipleactors.

Thisideathateverythingisanactorisnotwithoutdifficulties,though.Ifeverycomputation

needstohappenwithinanactor,thisimpliesthateveryfunctionandeverystatevariablecould

beitsownactor.Andeventhoughthisistechnicallypossible,it’snotalwayspragmatic.Often,

wehavegroupsofrelatedfunctionsanditisusuallymoreconvenienttowrapallthose

functionswithinasingleactor.Doingsodoesn’tviolatetheActorModel.Buthowdowe

decidewheretodrawtheline?WewilldiscussthisinmoredetailinChapter3whenwelearn

aboutdomain-drivendesign(DDD).ThebuildingblocksweintroduceforDDDareexcellent

candidatestoturnintoactorsandwecanusethemasguidingprinciplesforwhentocreatea

newactor.

ActorsintheActorModelembodynotonlystatebutalsobehavior.Thismightsound

suspiciouslylikethedefinitionofOOP—infactthetwoareverycloselyrelated.AlanKay,

whocoinedtheterm“object-orientedprogramming”andwasoneoftheoriginalcreatorsof

theSmalltalklanguage,waslargelyinfluencedbytheActorModel.AndwhileSmalltalkand

OOPeventuallyevolvedawayfromtheirActorModelroots,manyofthebasicprinciplesof

theActorModelremaininourmoderninterpretationofOOP.Intruth,theoriginalfocusof

OOPwasnottheobjectsthemselvesbutratherthemessagesflowingbetweenthem.

NOT E

OOPmodelsthefundamentalunitofcomputationasanobject(aninstanceofaclass),andisfamiliarto

developerscomingfromJavaandsimilarlanguages.Functionalprogramming,ontheotherhand,models

computationaroundfunctionsandtheirapplications,andisseeninlanguagessuchasLispandHaskell.

Anotheraspectofthemodelthatisusefulforhighlyconcurrentapplicationsistheideathatan

actor ’sstateisisolated.Itisneverdirectlyexposedtotheoutsideworld.Wedon’tallow

actorstolookatormodifythestateofanotheractor,exceptindirectlythroughmessages.

Thisisolationappliesequallytotheactor ’sbehavior.Theinternalmethodsormechanismsof

theactorareneverexposedtootheractors.Infact,stateandbehaviorcanlargelybetreatedas

thesamethingwithinanactor(moreonthislater).

Actorsinthemodelcantakemanydifferentforms.Theycanexistashighlytechnical

constructslikeadatabaseaccesslayer,ortheycanbedomain-specificconstructslikeaperson

orschedule.Theycanevenbeusedtoperformsimplemathematicaloperations.Anythingin

thesystemthatneedstoperformanyamountofcomputationisanactor.

ActorsCanCommunicateOnlyThroughMessages

Wehavecreatedouractorsinanisolatedfashionsothattheyneverexposetheirstateortheir

behavior.ThisisanimportantelementoftheActorModel.Becausewehaveisolatedthemin

thisway,weneedtofindotherwaysbywhichwecancommunicatewiththemandlearnabout

thestateofthesystem.

MessagesarethebackboneofallcommunicationintheActorModel.Theyarewhatenables

communicationbetweenactors.

Everyactor,whencreated,isgivenanaddress.Thisaddressistheentrypointfor

communicationwiththatactor.Youcannotusetheaddresstoaccesstheactordirectly,butyou

canuseittosendmessagestothatactor.

NOT E

Akkaseparatestheconceptofanaddressfromareference.Mostactorcommunicationisdoneusingreferences.

Akkaactorsalsohaveanaddressthatcanbeusedinsomecircumstances;however,theyaregenerallyavoided.

Nonetheless,whetheryouareusingareferenceoranaddress,thebasicprincipleisthesame:youhaveameansto

locatethemailboxfortheactorsothatyoucandeliveramessagetoit.

Messagesthataresenttoanactorarepiecesofimmutabledata.Thesemessagesaresenttoa

mailboxthatexistsattheaddressprovidedforthedestinationactor.Whathappensafterthe

messagereachesthemailboxisbeyondthecontrolofthesender.Messagescanbedelivered

outoforder,ortheymightnotevenbedeliveredatall.TheActorModelprovidesanAtMost

Onceguaranteeofdelivery.Thismeansthatfailureisanoption,andifweneedtoguarantee

delivery,wewillneedothertoolstoenablethat.

NOT E

AtMostOncedeliveryisthedefaultguaranteeprovidedbytheActorModelandbyAkka.However,AtLeast

OncedeliverycanbebuiltontopofAtMostOncedelivery,andtherearemechanismswithinAkkatoprovide

that.

Akkafurtherprovidesaslightlystrongerguaranteeofordering.InAkka,messageorderisguaranteedbetween

anypairofactors.Thatis,ifoneactorsendsmultiplemessagestoanother,wecanguaranteethattheorderof

thosemessageswillbepreserved.

Afterthemessagesareinthemailbox,theactorcanreceivethosemessages.However,

messagesarereceivedoneatatime.Nosingleactorcanprocesstwomessages

simultaneously.Thisisacriticalguaranteebecauseitallowsustooperatewithintheactorina

single-threadedillusion.Actorsarefreetomodifytheirinternalstatewithnoworriesabout

whetheranotherthreadmightalsobeoperatingonthatstate.Aslongaswemaintainthe

single-threadedillusion,ourstateisprotectedagainstanyofthenormalconcernsof

ActorsCanCreateChildActors

IntheActorModel,everythingisanactor,andactorscancommunicateonlythrough

messages.Butactorsalsoneedtoknowthatotheractorsexist.

Oneoftheactionsthatisavailabletoanactorwhenitreceivesamessageisthatitcancreatea

finitenumberofchildactors.Theparentwillthenknowaboutthechildactor(s)andwillhave

accesstothechild’saddress.Thismeansthataparentactorcansendmessagestoachildactor.

Inadditiontoknowingaboutactorsbycreatingthemaschildren,anactorcanpassthe

addresstoanotheractorthroughamessage.Inthisway,aparentcouldinformachildabout

anyotheractortheparentisawareof,includingitself.Thus,achildactorcanknowthe

addressofitsparentorsiblingswithverylittledifficulty.Withalittlemorework,thechild

canknowaboutotheractorsthatexistinthehierarchy,aswell.Inaddition,iftheaddressused

fortheactorfollowsasetpattern,itispossibletosynthesizeaddressesforotheractors,

thoughthiscancreateundesirablecomplexity,andpossiblysecurityconcerns,ifnotused

carefully.

Thishierarchyofactorsmeansthatwiththeexceptionoftheroot,allactorswillhaveaparent

andanyactorcanhaveoneormorechildren.Thecollectionoftheseactors,startingfromthe

rootandworkingdownthroughthetree,iscalledanactorsystem.

Eachactorintheactorsystemcanalwaysbeuniquelyidentifiedbyitsaddress.Itisnotcritical

thatitfollowanyparticularpattern,solongastheaddresscanbeguaranteedtouniquely

identifyanactor.Akkausesahierarchicalpatternofnaming,muchlikeadirectorystructure

(similartothatshowninFigure1-2),oryoucoulduserandomlygenerateduniquekeys.

剩余293页未读，继续阅读

knowledgehacker

粉丝: 0
资源: 9

设计分布式应用：实战Akka模式

Applied Akka Patterns A Hands-On Guide to Designing Distributed 无水印pdf

Applied Akka Patterns A Hands-On Guide to Designing Distributed azw3

Applied.Akka.Patterns

akka 远程调用 代码实现

akka in action pdf

akka 2.4.14.zip

akka的配置文件

spark和akka关系

Akka实现分布式锁

akka.net中文文档

最新资源

akka 远程调用代码实现