# Isolate API

De Isolate API of Application Isolation API is een API binnen het Java platform. Deze API breidt de definitie van de Java Virtual Machine (JVM) uit zodat er meerdere Java-programma's tegelijkertijd in kunnen draaien. Op het moment van dit schrijven is de Isolate API geaccepteerd door het Java Community Process als JSR-121, maar nog niet opgenomen in implementaties van de JVM.

## Applicatie-isolatie

Sinds de introductie van de programmeertaal Java is de "normale" manier om een Java-programma uit te voeren door gebruik te maken van een JVM. Deze zogeheten "container" voor Java-applicaties leest een verzameling klassen in in het unieke formaat van een Java-klasse, vertaalt de code naar instructies voor de onderliggende hardware en laat ze uitvoeren. Dezelfde JVM is ook een brug tussen het programma en een aantal specifieke onderdelen van het onderliggende platform (diensten binnen het besturingssysteem, hardware zoals netwerkkaarten, muizen, harddisks, enzovoorts).
Dit systeem maakt het mogelijk om een Java programma eenmalig te schrijven en compileren en het resultaat zonder verdere aanpassingen uit te laten voeren op (theoretisch) ieder platform. Het maakt het ook mogelijk om een aantal plezierige abstracties door te voeren waar de ontwikkelaar veel aan heeft. Daar staat tegenover dat het systeem vrij intensief is om te gebruiken: een JVM vergt een redelijk snelle processor en vrij wat geheugen om soepel te draaien. Om die reden is het zonde dat er binnen een enkele JVM-instantie maar één Java-programma kan draaien.
De taaldefinitie van Java definieert namelijk een aantal zaken die uniek zijn binnen de JVM (statische velden, met name). En op basis hiervan zijn ook patronen ontwikkeld die grote, statische structuren kunnen introduceren binnen de JVM (het singleton patroon met name en bijbehorende Factory-klassen). Van al deze zaken is gegarandeerd dat ze uniek zijn binnen de JVM en ook door de taal zo behandeld worden. Om deze reden kunnen twee programma's, zelfs als ze niets met elkaar te maken hebben, niet veilig draaien binnen een enkele JVM: middels de statische structuren in de JVM kunnen ze elkaar toch bijten, want die structuren zijn uniek binnen de gehele JVM.
De Isolate API verandert deze situatie door de JVM uit te breiden met segmenten – isolates geheten – die elk geheel los van elkaar staan. Een segment heeft een geheel eigen, geïsoleerde geheugenruimte en ook een geheel eigen versie van iedere klasse, waardoor het probleem van de statische structuren ook wordt opgelost. Daarnaast kan een isolate ook kind-isolates hebben (kinderen die geheel los van elkaar staan en in principe niets van elkaar weten). De JVM zelf wordt dan een virtuele computer die een primaire isolate start. En de primaire isolate is in staat om meerdere Java-programma's te starten, ieder als een eigen kind-isolate. Het geheel komt er dan een beetje uit te zien als een Unix-machine, waarin programma's als processen parallel aan elkaar draaien op de computer en allemaal kinderen zijn van het Init-proces.

## Isolates versus Threads

De verhouding tussen de nieuwe isolates en de al in Java bekende threads is ook ongeveer hetzelfde als die tussen een Unix-proces en een thread: een isolate is zwaarder van "gewicht", vraagt meer van de JVM qua geheugenruimte en processortijd, maar is wel strikt geïsoleerd van de rest van de machine terwijl een thread samen met andere threads binnen een enkele isolate draait en samen met die threads het geheugen en de klassedefinities van die Isolate deelt – en dus totaal niet van de andere threads in die isolate geïsoleerd is.

## API

De Isolate API is op zich vrij simpel en definieert richting de ontwikkelaar maar drie klassen (en daarbij een paar hulpklassen):

   ### javax.isolate.Isolate

       Een klasse die isolates binnen een JVM voortelt. Voor iedere aangemaakte en nog niet getermineerde isolate binnen een JVM, is er een instantie van deze klasse binnen de JVM. Zo wordt het mogelijk om kind-isolates te beheren en met de JVM te praten over andere isolates binnen de JVM.

   ### javax.isolate.Link

       Een klasse om communicatie tussen twee isolates mogelijk te maken.

   ### javax.isolate.LinkMessage

       Een bericht tussen twee isolates.
We zien hier dat het niet mogelijk is om interferentie tussen twee isolates te hebben (bijvoorbeeld door middel van statische structuren), maar dat het wel mogelijk is om expliciete communicatie tussen isolates op te zetten middels berichten (en met naam en toenaam niet via gedeeld geheugen). Dit is de analogie in de "nieuwe" JVM van interproces-communicatie zoals deze ook bestaat binnen verschillende besturingssystemen. De Link en LinkMessage klassen maken synchrone communicatie mogelijk tussen twee isolates (die uiteraard wel van elkaar af moeten weten), zowel van data als van simpele statusberichten. Omdat de berichten synchroon zijn, maken ze ook synchronisatie mogelijk met de zogeheten rendez-vous semantiek.
Naast dit mechanisme blijven de andere communicatie-mechanismen die Java al kende natuurlijk ook bestaan (communicatie via het bestandssysteem, via RMI, webservices, CORBA, etc.).
Daarnaast bestaat de API uit een aantal hulpklassen; klassen om toestand of toestemming voor toegang van de isolate weer te geven en ook een speciale IsolateException.
* De JSR-121 status page