Wat is een actief object?
Bij computerprogrammering en engineering is een actief object een type ontwerppatroon dat kan worden gebruikt om ervoor te zorgen dat bepaalde services altijd beschikbaar zijn in een multi-threaded of gelijktijdig systeem. Een actief object is een object dat een mechanisme implementeert zodat het input van externe objecten kan ontvangen en verwerken zonder dat de externe objecten moeten wachten tot de uitvoering is voltooid. Met dit mechanisme kunnen ook veel objecten die allemaal tegelijkertijd worden uitgevoerd, actieve objecten gebruiken zonder de mogelijkheid van lange blokkeertijden waarin de gelijktijdige processen moeten stoppen en wachten op toegang. Dit wordt meestal bereikt door de actieve objecten in een openbaar toegankelijke interface te plaatsen, een proxy genoemd, en vervolgens een type wachtrijsysteem in de objecten te implementeren, zodat berichten worden opgeslagen voor latere verwerking. Dit creëert een ontwerppatroon waarin objecten berichten naar actieve objecten verzenden en vervolgens doorgaan met verwerken totdat het actieve object het bericht verwerkt en de aanroepende objecten later op de hoogte stelt van de resultaten zodat ze hun status dienovereenkomstig kunnen bijwerken.
Buiten een actief ontwerppatroon kan een normaal object een passief object worden genoemd. In een eenvoudig programmavoorbeeld kan een passief object fungeren als een chatserverrelais, waarbij externe objecten contact opnemen met het passieve object om een bericht naar alle anderen op de server te verzenden. Wanneer het passieve serverobject een chatbericht van een extern object ontvangt, moet het de aanvraag onmiddellijk verwerken en vervolgens onmiddellijk uitvoer verzenden, terwijl het externe object zijn eigen uitvoering stopt totdat het proces is voltooid, een effect dat bekend staat als blokkeren. Het creëren van verschillende threads binnen het programma kan het probleem van het blokkeren van de uitvoering oplossen, maar veroorzaakt vervolgens problemen met synchronisatie.
In een actief objectontwerppatroon zou hetzelfde serverobject in het bovenstaande voorbeeld worden uitgevoerd in zijn eigen thread, gescheiden van de andere objecten. Het zou ook worden verpakt in een soort interface dat bekend staat als een proxy en die ook in een afzonderlijke thread wordt uitgevoerd, soms de thread voor de uitvoering van het hoofdprogramma. Wanneer een extern object wil dat het serverobject een chatbericht verzendt, neemt het contact op met het proxy-object, geeft het alle vereiste informatie door en keert vervolgens terug naar de normale uitvoeringstoestand in plaats van te wachten.
De proxy-interface converteert vervolgens de informatie van het externe object in een bericht dat het doorgeeft aan een wachtrij die het actieve object kan verwerken. Op dit moment kunnen zowel de proxy-interface als het externe object doorgaan met uitvoeren en worden ze niet geblokkeerd. Ondertussen werkt het actieve object om de wachtrij leeg te houden en elk inkomend bericht te verwerken. Als het oproepende object vereist dat enige informatie wordt geretourneerd door het actieve object, kan een callback-structuur worden gebruikt om het externe object op de hoogte te brengen van eventuele statuswijzigingen.