Actor-model: hoe onafhankelijke ‘actoren’ software schaalbaar en robuust maken

Bijgewerkt: 21 september 2026 · 5 min leestijd

Stel je een groot kantoor voor waar niemand een gedeeld archiefkastje deelt. Iedere medewerker heeft alleen zijn eigen postbakje en werkt volledig op eigen tempo. Wil je iets van een collega weten, dan stuur je een briefje naar zijn postbakje; je loopt nooit zelf zijn kamer binnen om iets uit zijn kast te pakken. Zo'n medewerker met eigen postbakje en eigen taken is in de informatica een actor, en het geheel van regels waarmee die medewerkers met elkaar samenwerken heet het actor-model.

Het actor-model is een manier om computerprogramma's te bouwen die uit heel veel kleine, onafhankelijke onderdelen bestaan die alleen via berichten met elkaar communiceren, nooit door rechtstreeks bij elkaars gegevens te grabbelen. Dat klinkt misschien als een detail voor programmeurs, maar het is precies de aanpak achter systemen die miljoenen mensen tegelijk moeten bedienen, zoals chat-apps, telefooncentrales en game-servers, zonder dat één foutje de hele boel laat vastlopen.

Wat is het precies?

In gewone programma's delen verschillende onderdelen vaak dezelfde gegevens in het geheugen. Als twee onderdelen tegelijk diezelfde gegevens willen aanpassen, moet je met ingewikkelde vergrendelingen ("locks") voorkomen dat ze elkaar in de weg zitten. Dat soort code is berucht foutgevoelig: kleine fouten leiden tot een deadlock, een situatie waarin onderdelen elkaar blokkeren en het programma vastloopt.

Het actor-model lost dit anders op. Een actor is de kleinste bouwsteen van een programma en heeft drie vaste eigenschappen. Ten eerste heeft hij eigen, privé-gegevens (zijn "staat") die niemand anders rechtstreeks kan inzien of wijzigen. Ten tweede heeft hij een mailbox: een wachtrij waarin binnenkomende berichten van andere actoren worden opgeslagen totdat hij er tijd voor heeft. Ten derde reageert een actor op een bericht door precies drie dingen te mogen doen: zijn eigen gegevens aanpassen, berichten naar andere actoren sturen, of nieuwe actoren aanmaken.

Omdat actoren nooit rechtstreeks bij elkaars geheugen kunnen, is er ook geen vergrendeling nodig. Twee actoren kunnen volledig tegelijk (parallel) draaien zonder dat ze elkaar kunnen beschadigen. Berichten worden bovendien asynchroon verstuurd: de verzendende actor wacht niet op een antwoord, maar gaat gewoon door met zijn eigen werk.

Een tweede belangrijk onderdeel is supervisie. Actoren worden vaak in een boomstructuur georganiseerd, waarbij een "ouder"-actor de "kind"-actoren onder zich in de gaten houdt. Crasht een kind-actor door een fout, dan grijpt de ouder in: hij kan de actor herstarten met een schone lei. Deze filosofie staat bekend als "let it crash" (laat het maar crashen): in plaats van elke mogelijke fout vooraf op te vangen, laat je een klein onderdeel gecontroleerd falen en herstel je het automatisch, zodat de rest van het systeem gewoon doordraait.

Wat wil men ermee bereiken?

De kernbelofte van het actor-model is dat je software kunt bouwen die tegelijk schaalbaar en fouttolerant is, zonder dat programmeurs zich blind moeten staren op vergrendelingen en gedeeld geheugen. Schaalbaar betekent hier: het systeem kan met meer processorkernen, of zelfs meer computers tegelijk, meer werk verzetten, simpelweg door meer actoren te laten draaien.

Fouttolerant betekent dat een storing in één onderdeel niet het hele systeem meesleurt. Dat was oorspronkelijk geen academische wens, maar een keiharde praktijkeis: het model werd populair gemaakt in de telecomsector, waar een telefooncentrale nooit volledig mag uitvallen, ook niet als er ergens een softwarefoutje optreedt terwijl duizenden gesprekken tegelijk lopen.

Daarnaast wil men de programmeercomplexiteit van gelijktijdige ("concurrent") systemen terugbrengen. Het idee is dat losse, kleine actoren met een duidelijke verantwoordelijkheid makkelijker te begrijpen en te testen zijn dan één groot programma vol gedeelde toestand.

Voorbeelden uit de praktijk

Het actor-model werd in 1973 als theoretisch idee beschreven door de Amerikaanse informaticus Carl Hewitt, samen met Peter Bishop en Richard Steiger, in een paper over kunstmatige intelligentie. Het duurde daarna nog jaren voordat het idee praktisch werd toegepast.

De bekendste toepassing is de programmeertaal Erlang, ontwikkeld vanaf 1986 door Joe Armstrong, Robert Virding en Mike Williams bij telecombedrijf Ericsson in Zweden. Erlang bouwt actoren in als basisonderdeel van de taal zelf. Het bekendste succesverhaal is de Ericsson AXD301-telefooncentrale (eind jaren negentig), waarvan werd geclaimd dat hij een beschikbaarheid van 99,9999999 procent haalde, ofwel "negen negens" uptime.

Chatdienst WhatsApp gebruikte Erlang om met een opvallend klein team miljarden berichten per dag te verwerken, iets waar het bedrijf in de jaren 2009-2014 bekend om werd voordat het in 2014 door Facebook werd overgenomen.

Gamechat-platform Discord gebruikt sinds 2015 de taal Elixir, die bovenop dezelfde Erlang-virtuele machine draait en dus ook het actor-model gebruikt, om tegelijk miljoenen chat- en spraakverbindingen te verwerken.

Op de Java-taalfamilie is Akka het bekendste actor-framework, gemaakt door Jonas Bonér en sinds 2009 ontwikkeld door het bedrijf Lightbend. Akka wordt onder meer gebruikt in financiële en streaming-toepassingen waar veel gelijktijdige gebeurtenissen verwerkt moeten worden.

Microsoft ontwikkelde met Orleans een variant met "virtuele actoren", die is ingezet als achterliggend platform voor de cloud-diensten van de Halo-games van 343 Industries, vanaf Halo 4 in 2012.

Hoe ver is de techniek?

Het actor-model is geen nieuwe hype maar een volwassen, decennia beproefde aanpak: de theorie stamt uit 1973, en Erlang draait al sinds de jaren tachtig in productieomgevingen. Het model wordt dus niet meer onderzocht in de zin van "werkt dit wel", maar wordt vooral verder verfijnd en breder toegankelijk gemaakt.

Recente ontwikkelingen richten zich op typeveiligheid: nieuwere versies van Akka ("Akka Typed") controleren tijdens het programmeren al of berichten wel het juiste soort zijn, waar oudere actor-systemen dat pas tijdens het draaien ontdekten. Ook zie je steeds meer integratie met cloud- en serverless-platforms, waarbij actoren automatisch over meerdere datacenters worden verdeeld.

Toch blijven er reële obstakels. Het debuggen van een systeem met duizenden losse actoren die elkaar asynchroon berichten sturen is lastiger dan bij een klassiek, lineair programma: fouten kunnen zich pas laat en op onverwachte plekken openbaren. Berichten komen bovendien niet altijd in de verzonden volgorde aan, en de meeste actor-systemen garanderen alleen dat een bericht "minstens één keer" wordt afgeleverd, niet precies één keer, wat programmeurs dwingt zelf rekening te houden met dubbele berichten. Ten slotte vereist het actor-model een andere manier van denken over programmeren dan de meeste ontwikkelaars gewend zijn, wat de instapdrempel verhoogt.

Wie werken eraan?

Ericsson (Zweden) is de bakermat van Erlang en onderhoudt via de Erlang/OTP-organisatie nog altijd de kernontwikkeling van de taal. Rond Erlang is bovendien een levendige open source-gemeenschap ontstaan, mede via de taal Elixir, bedacht door de Braziliaanse ontwikkelaar José Valim.

Lightbend (voorheen Typesafe), het bedrijf van Jonas Bonér, is de belangrijkste drijvende kracht achter Akka in de Java- en Scala-wereld.

Microsoft Research en het Orleans-team zetten de ontwikkeling van virtuele actoren voort, met toepassingen binnen Microsofts eigen cloudplatform Azure.

Op academisch vlak blijven de theoretische grondslagen verbonden aan Carl Hewitt (MIT), de bedenker van het model, en aan hoogleraar Gul Agha (University of Illinois), wiens werk in de jaren tachtig het actor-model formeel verder uitwerkte en nog altijd als standaardreferentie geldt.