Dieser Artikel oder nachfolgende Abschnitt ist nicht hinreichend mit Belegen (beispielsweise Einzelnachweisen) ausgestattet. Angaben ohne ausreichenden Beleg könnten demnächst entfernt werden. Bitte hilf Wikipedia, indem du die Angaben recherchierst und gute Belege einfügst.

Unter Jacketing versteht man die Möglichkeit, einen blockierenden Systemaufruf zu umgehen.

Ein Aufruf heißt blockierend, wenn er nicht nur rechnet, sondern stattdessen wartet, bis irgendein Ereignis eintritt, und erst dann weiterarbeitet. In einem System ohne Multitasking ist das fatal, der Computer ist bis zum Eintreten des Ereignisses nicht benutzbar. Aber auch wenn Multitasking unterstützt wird, kann ein blockierender Funktionsaufruf stören. Zum Beispiel sollte der Thread, der die grafische Oberfläche aktuell hält, prompt auf Benutzereingaben reagieren.

Viele Systemaufrufe, die auf externe Geräte zugreifen, sind blockierend.

Liefert der blockierende Systemaufruf keinen Rückgabewert, kann man den Aufruf in einen neuen Thread verschieben, den aufrufenden Thread aber gleichzeitig weiterlaufen lassen.

Als Klassenmethode von Object:

 unblock: selector
    "Macht den blockierenden Aufruf selector unblockierend."
    |bs|
    bs := (#blocking , selector) asSymbol. "Der alte Aufruf wird umbenannt"
    self
        addSelector: bs
              withMethod: (self methodAt: selector) ; removeSelector: selector.
    self addSelector: selector
        withMethod: (self class compile:
            '[self ', (self standardMethodHeaderFor: bs), '] fork')

Durch den Aufruf Test unblock: #tuWas würde die Methode

 tuWas
       Transcript show: 'Yippie!'

durch die zwei Methoden

 blockingtuWas
       Transcript show: 'Yippie!'

und

 tuWas
     [self blockingtuWas] fork

ersetzt.

Der Aufruf tuWas würde nun in wenigen Millisekunden abschließen, allerdings käme die Ausgabe auf dem Transcript erst etwas später.

Soll eine blockierende Routine aus einem Thread aufgerufen werden, in dem auch das Ergebnis benötigt wird, aber nicht notwendig sofort, verwendet man wieder obige Vorgehensweise, ändert aber die blockierende Routine, sodass sie Bescheid gibt, sobald sie abgearbeitet wurde. Die Kommunikation zwischen zwei Prozessen kann durch einen Semaphor geschehen. Der aufrufende Thread lauscht regelmäßig am Semaphor, ob eine Antwort vorliegt. Falls ja, lässt er sie sich geben und verwendet sie. Falls nein, rechnet er unbehelligt weiter.

Sei tuWas also ein blockierender Aufruf, der nach einer gewissen Zeit ein Ergebnis e zurückliefert. Bis das zur Verfügung steht, soll regelmäßig self tuWasAnderesInDerZwischenzeit ausgeführt werden

 |e s|
 s := Semaphore new.
 [e := self tuWas. s signal] fork.
 [self tuWasAnderesInDerZwischenzeit] doWhileFalse: [s isSignaled].
 "Hier steht e zur Verfügung"