Ressourcenverwaltung (Computing)

Im Computerprogrammierung, Resourcenmanagement bezieht sich auf Techniken für die Verwaltung Ressourcen (Komponenten mit begrenzter Verfügbarkeit).

Computerprogramme kann ihre eigenen Ressourcen verwalten[die?] Durch die Verwendung von Funktionen durchgesetzt von Programmiersprachen (Elder, Jackson & Liblit (2008) ist ein Umfrageartikel, der unterschiedliche Ansätze kontrastiert) oder kann sich dafür entscheiden, sie mit einem Host zu verwalten - und eine Betriebssystem oder virtuelle Maschine - oder ein anderes Programm.

Host-basiertes Management ist bekannt als als Ressourcenverfolgung, und besteht aus der Reinigung von Ressourcenlecks: Beendigung des Zugangs zu Ressourcen, die nach Gebrauch erworben, aber nicht freigegeben wurden. Dies ist bekannt als als Rückgewinnung Ressourcen und ist analog zu Müllsammlung für die Erinnerung. Auf vielen Systemen rebobt das Betriebssystem die Ressourcen, nachdem der Prozess das macht Ausfahrt Systemanruf.

Zugriff kontrollieren

Die Auslassung der Veröffentlichung einer Ressource, wenn ein Programm beendet wurde Ressourcenleckund ist ein Problem im sequentiellen Computer. Mehrere Prozesse möchten auf eine begrenzte Ressource zugreifen Gleichzeitiges Computerund ist bekannt als als Ressourcenkonkurrenz.

Das Ressourcenmanagement versucht, den Zugriff zu kontrollieren, um beide Situationen zu verhindern.

Ressourcenleck

Formal besteht das Ressourcenmanagement (Verhinderung von Ressourcenlecks) darin, sicherzustellen, dass eine Ressource nur dann freigegeben wird, wenn sie erfolgreich erworben wird. Dieses allgemeine Problem kann als "abstrahiert werden"Vor, Karosserie, und nach"Code, der normalerweise in dieser Reihenfolge ausgeführt wird, mit der Bedingung, dass die nach Code wird nur dann aufgerufen, wenn der Vor Der Code schließt erfolgreich ab, unabhängig davon, ob die Karosserie Code wird erfolgreich ausgeführt oder nicht. Dies ist auch als bekannt als herumführen[1] oder ein Code -Sandwich, und tritt in verschiedenen anderen Kontexten auf,[2] wie eine vorübergehende Änderung des Programmstaates oder Verfolgung Eintritt und Ausgang in a Subroutine. Das Ressourcenmanagement ist jedoch die am häufigsten zitierte Anwendung. Im Aspekt-orientiertes Programmieren, solche Ausführung um Logik ist eine Form von Rat.

In der Terminologie von Kontrollflussanalyse, Ressourcenveröffentlichung muss postdomin erfolgreicher Ressourcenerwerb;[3] Wenn dies nicht sichergestellt wird, dass dies ein Fehler ist, und ein Codepfad, der gegen diesen Zustand verstößt, führt ein Ressourcenleck. Ressourcenlecks sind häufig geringfügige Probleme, im Allgemeinen nicht das Programm abgestürzt, sondern zu einer Verlangsamung des Programms oder des Gesamtsystems.[2] Sie können jedoch zu Abstürzen führen - entweder das Programm selbst oder andere Programme - aufgrund Ressourcenerschöpfung: Wenn dem System die Ressourcen ausgeht, fehlen Akquisitionsanfragen. Dies kann a präsentieren Sicherheitsfehler Wenn ein Angriff Ressourcenschöpfung verursachen kann. Ressourcenlecks können unter dem regulären Programmfluss auftreten - z. B. einfach zu vergessen, eine Ressource freizugeben - oder nur unter außergewöhnlichen Umständen, z. B. wenn eine Ressource nicht veröffentlicht wird, wenn in einem anderen Teil des Programms eine Ausnahme vorhanden ist. Ressourcenlecks werden sehr häufig durch verursacht durch Früher Ausgang von einem Unterprogramm, entweder durch a Rückkehr Aussage oder eine Ausnahme, die entweder durch die Unterroutine selbst oder eine tiefere Unterroutine, die sie aufruft, hervorgerufen wird. Während die Ressourcenveröffentlichung aufgrund von Rückgabeberechnungen durch sorgfältige Freisetzung innerhalb der Unterroutine vor der Rückkehr behandelt werden kann, können Ausnahmen nicht ohne zusätzliche Spracheinrichtung behandelt werden, die garantiert, dass der Freigabescode ausgeführt wird.

Subtiler, erfolgreicher Ressourcenakquisition muss dominieren Ressourcenveröffentlichung, da der Code sonst versucht, eine Ressource zu veröffentlichen, die er nicht erworben hat. Die Folgen einer solchen falschen Freigabe reichen von stillschweigend ignoriert bis zum Absturz des Programms oder unvorhersehbares Verhalten. Diese Fehler manifestieren sich im Allgemeinen selten, da sie eine Ressourcenzuweisung erfordern, um zuerst zu scheitern, was im Allgemeinen ein außergewöhnlicher Fall ist. Darüber hinaus sind die Konsequenzen möglicherweise nicht schwerwiegend, da das Programm möglicherweise bereits abstürzt, da keine wesentliche Ressource erfasst wird. Diese können jedoch die Wiederherstellung des Fehlers verhindern oder ein geordnetes Herunterfahren in eine ungeordnete Abschaltung verwandeln. Diese Bedingung wird im Allgemeinen sichergestellt, indem zuerst überprüft wird, ob die Ressource vor der Veröffentlichung erfolgreich erworben wurde, entweder durch eine booleale Variable, die "erfolgreich erworben" aufzeichnet - oder durch den Griff zur Ressource ist a Nullierstyp, wo "null" angibt "nicht erfolgreich erworben", was die Atomizität gewährleistet.

Ressourcenkonkurrenz

Speicherverwaltung

Speicher kann als Ressource behandelt werden, aber Speicherverwaltung wird normalerweise getrennt betrachtet, vor allem, weil die Speicherzuweisung und Deallokation erheblich häufiger sind als die Erfassung und Freisetzung anderer Ressourcen, wie z. B. Dateihandles. Speicher, der von einem verwaltet wird extern Das System hat Ähnlichkeiten sowohl mit der (internen) Speicherverwaltung (da es Speicher ist) als auch mit der Ressourcenverwaltung (da es von einem externen System verwaltet wird). Beispiele hierfür sind Speicher, der über nativen Code verwaltet und von Java verwendet wird (via " Java Native Interface); und Objekte in der Dokumentobjektmodell (DOM), verwendet von JavaScript. In beiden Fällen die Speichermanager (Müllsammler) des Laufzeitumgebung (Virtual Machine) kann den externen Speicher nicht verwalten (es gibt keine gemeinsame Speicherverwaltung), und daher wird der externe Speicher als Ressource behandelt und analog verwaltet. Zyklen zwischen Systemen (JavaScript, die sich auf die DOM beziehen, die sich auf JavaScript beziehen) können das Management jedoch schwierig oder unmöglich machen.

Lexikalmanagement und explizites Management

Eine zentrale Unterscheidung im Ressourcenmanagement innerhalb eines Programms liegt dazwischen Lexikalmanagement und Explizites Management - Ob eine Ressource mit einem lexikalischen Bereich wie einer Stapelvariablen gehandhabt werden kann (die Lebensdauer ist auf einen einzelnen lexikalischen Bereich beschränkt, wird beim Eintritt in oder innerhalb eines bestimmten Bereichs erworben und beim Ausführen des Ausgangs aus diesem Bereich freigegeben) oder ob Eine Ressource muss explizit zugeteilt und freigegeben werden, z. B. eine Ressource, die innerhalb einer Funktion erworben und dann zurückgegeben wird, die dann außerhalb der Erwerbsfunktion freigegeben werden muss. Das lexikalische Management ermöglicht gegebenenfalls eine bessere Trennung von Bedenken und ist weniger fehleranfällig.

Grundtechniken

Der grundlegende Ansatz für das Ressourcenmanagement besteht darin, eine Ressource zu erwerben, etwas damit zu tun, sie dann zu veröffentlichen und Code des Formulars zu ergeben (illustriert mit Öffnen einer Datei in Python):

f = offen(Dateiname) ... f.nah dran() 

Dies ist richtig, wenn der Intervening ... Code enthält keinen frühen Ausgang (Rückkehr), die Sprache hat keine Ausnahmen und offen ist garantiert Erfolg. Es führt jedoch zu einem Ressourcenleck, wenn eine Rückgabe oder Ausnahme vorliegt, und führt zu einer falschen Freigabe von nicht erworbenen Ressourcen, wenn offen kann scheitern.

Es gibt zwei weitere grundlegende Probleme: Das Akquisitionspreisveröffentlichungspaar ist nicht benachbart (der Release-Code muss weit vom Akquisitionscode entfernt sein) und das Ressourcenmanagement ist nicht eingekapselt. Der Programmierer muss manuell sicherstellen, dass sie immer gepaart werden. In Kombination bedeutet diese, dass Akquisition und Freigabe explizit gepaart werden müssen, aber nicht zusammengestellt werden können, was es so erleichtert, dass diese nicht korrekt gepaart werden.

Das Ressourcenleck kann in Sprachen gelöst werden, die a unterstützen endlich Konstruktion (wie Python), indem der Körper in a gestellt wird Versuchen Klausel und die Veröffentlichung in a endlich Klausel:

f = offen(Dateiname) Versuchen:  ... endlich:  f.nah dran() 

Dies stellt die korrekte Freigabe sicher, auch wenn eine Rückkehr innerhalb des Körpers oder eine Ausnahme ausgelöst wird. Beachten Sie außerdem, dass die Akquisition erfolgt Vor das Versuchen Klausel, um sicherzustellen, dass die endlich Klausel wird nur ausgeführt, wenn die offen Der Code ist erfolgreich (ohne eine Ausnahme) unter der Annahme, dass "keine Ausnahme" "Erfolg" bedeutet (wie dies der Fall ist offen in Python). Wenn der Ressourcenerwerb ohne Ausnahme scheitern kann, z. B. durch Rückgabe einer Form von NullEs muss auch vor der Veröffentlichung überprüft werden, wie beispielsweise:

f = offen(Dateiname) Versuchen:  ... endlich:  wenn f:  f.nah dran() 

Dies stellt zwar das korrekte Ressourcenmanagement sicher, bietet keine Adjazenz oder Kapselung. In vielen Sprachen gibt es Mechanismen, die eine Verkapselung liefern, wie die mit Aussage in Python:

mit offen(Dateiname) wie f:  ... 

Die obigen Techniken - Schutzschutz (Abwicklungendlich) und irgendeine Form der Kapselung - sind der häufigste Ansatz für das Ressourcenmanagement, der in verschiedenen Formen in C#vorkommt. Common Lisp, Java, Python, Ruby, Planen, und Smalltalk,[1] unter anderen; Sie stammen aus den späten 1970er Jahren in der NULL Dialekt von Lisp; sehen Ausnahmebehandlung § Geschichte. Es gibt viele Variationen in der Implementierung, und es gibt auch erheblich unterschiedlich Ansätze.

Ansätze

Schutzschutz

Der häufigste Ansatz für das Ressourcenmanagement in den Sprachen besteht darin, den Abwicklungsschutz zu verwenden, der als Ausführung ein Zielfernrohr genannt wird - durch Ausführung, die am Ende des Blocks abfällt, aus dem Block zurückkehrt oder eine Ausnahme ausgelöst wird. Dies funktioniert für Stack-verwaltete Ressourcen und wird in vielen Sprachen implementiert, darunter C#, Common Lisp, Java, Python, Ruby und Schema. Der Hauptproblem bei diesem Ansatz ist, dass der Release -Code (am häufigsten in a endlich Klausel) kann sehr vom Erfassungscode entfernt sein (es fehlt ihm Adjazenz) und dass der Akquisitions- und Release -Code immer vom Anrufer gepaart werden muss (es fehlt ihm Verkapselung). Diese können entweder funktionell behoben werden, indem Verschluss/Callbacks/Coroutinen (gemeinsames Lisp, Ruby, Schema) oder ein Objekt verwendet werden Ein Umfang (C# Verwendung, Java Versuchen-With-Resources, Python mit); siehe unten.

Ein alternativer, imperativerer Ansatz ist es, asynchronen Code in zu schreiben direkter Stil: Erwerben Sie eine Ressource und dann in der nächsten Zeile eine aufgeschoben Release, die als Ausgang des Umfangs bezeichnet wird - synchrone Akquisition, gefolgt von einer asynchronen Freisetzung. Dies entstand in C ++ als ScopeGuard -Klasse, von Andrei Alexandrescu und Petru -Marginenerie im Jahr 2000,[4] mit Verbesserungen von Joshua Lehrer,[5] und hat direkte Sprachunterstützung in D über die Umfang Stichwort (ScopeGuardStatement), wo es ein Ansatz ist Ausnahmesicherheitzusätzlich zu Raii (siehe unten).[6] Es wurde auch in Go aufgenommen, wie die verschieben Aussage.[7] In diesem Ansatz fehlt die Kapselung-man muss explizit mit der Akquisition und Freigabe übereinstimmen-, vermeiden jedoch, für jede Ressource ein Objekt zu erstellen (Code, das Schreiben einer Klasse für jede Art von Ressource).

Objekt orientierte Programmierung

Im Objekt orientierte Programmierung, Ressourcen werden in Objekten, die sie verwenden, eingekapselt, wie z. Datei Objekt mit a aufstellen deren Wert ist a Dateideskriptor (oder allgemeiner Dateihandle). Auf diese Weise kann das Objekt die Ressource verwenden und verwalten, ohne dass Benutzer des Objekts dies tun müssen. Es gibt jedoch eine Vielzahl von Möglichkeiten, wie Objekte und Ressourcen zusammenhängen können.

Erstens gibt es die Frage des Eigentums: Macht ein Objekt haben eine Ressource?

  • Objekte können besitzen Ressourcen (via Objektzusammensetzung, ein starkes "hat eine" Beziehung).
  • Objekte können Aussicht Ressourcen (via Objektaggregation, eine schwache "hat eine" Beziehung).
  • Objekte können kommunizieren mit anderen Objekten, die Ressourcen haben (über Verband).

Objekte, die eine Ressource haben, können sie an unterschiedlichen Stellen während des Objektlebensdauer; Diese treten paarweise auf, aber in der Praxis werden sie oft nicht symmetrisch verwendet (siehe unten):

  • Erwerben/Freigabe, während das Objekt über (Instanz-) Methoden wie z. B. gültig ist offen oder entsorgen.
  • Erwerben/Freigabe während der Erstellung/Zerstörung von Objekten (im Initialisierer und Finalizer).
  • Weder die Ressource erwerben noch freigeben, stattdessen einfach eine haben Aussicht oder Hinweis zu einer Ressource, die extern zum Objekt verwaltet wurde, wie in Abhängigkeitsspritze; Konkret wird ein Objekt, das eine Ressource hat (oder mit einem, das dies tut), als Argument an eine Methode oder einen Konstruktor übergeben wird.

Am häufigsten besteht darin, eine Ressource während der Erstellung von Objekten zu erwerben und sie dann explizit über eine Instanzmethode freizugeben, die allgemein genannt wird entsorgen. Dies ist analog zum traditionellen Dateimanagement (erwerben Sie während offen, veröffentlicht von explizit nah dran) und ist als die bekannt Muster entsorgen. Dies ist der grundlegende Ansatz in mehreren wichtigen modernen objektorientierten Sprachen, einschließlich Java, C# und PythonUnd diese Sprachen verfügen über zusätzliche Konstrukte, um das Ressourcenmanagement zu automatisieren. Selbst in diesen Sprachen führen komplexere Objektbeziehungen jedoch zu komplexerem Ressourcenmanagement, wie nachstehend erläutert.

Raii

Ein natürlicher Ansatz ist es, das Halten einer Ressource ein Klasseninvariante: Ressourcen werden während der Objekterstellung (insbesondere in der Initialisierung) erfasst und während der Objektzerstörung (insbesondere in der Abschluss) freigegeben. Dies ist bekannt als als Ressourcenerwerb ist die Initialisierung (Raii) und bindet das Ressourcenmanagement zu Objektlebensdauersicherstellen, dass lebende Objekte alle notwendigen Ressourcen haben. Andere Ansätze machen das Halten der Ressource nicht invariant, und daher haben Objekte möglicherweise keine notwendigen Ressourcen (da sie noch nicht erworben wurden, bereits freigegeben wurden oder extern verwaltet werden), was zu Fehlern wie dem Versuch zu lesen ist Aus einer geschlossenen Datei. Dieser Ansatz verbindet die Ressourcenverwaltung mit dem Speichermanagement (insbesondere der Objektverwaltung). Wenn also keine Speicherlecks (keine Objektlecks) vorhanden sind, gibt es keine Ressourcenlecks. Raii arbeitet auf natürliche Weise für haufensbezogene Ressourcen, nicht nur stapelgeführte Ressourcen und ist komponierbar: Ressourcen, die von Objekten in willkürlich komplizierten Beziehungen gehalten werden (ein komplizierter Objektdiagramm) werden transparent einfach durch Objektzerstörung freigegeben (solange dies richtig gemacht wird!).

Raii ist der Standardansatz für Ressourcenmanagement in C ++, ist trotz seiner Attraktivität jedoch nur wenig genutzt, da es sich nur schlecht mit modernem automatischem Speichermanagement zusammenzieht Verfolgung von Müllsammlung: Raii Krawatten Ressourcenverwaltung zum Speichermanagement, aber diese haben erhebliche Unterschiede. Erstens, da Ressourcen teuer sind, ist es wünschenswert, sie umgehend freizugeben, sodass Objekte, die Ressourcen halten, zerstört werden, sobald sie Müll werden (nicht mehr in Gebrauch). Die Zerstörung der Objekte ist in der deterministischen Speicherverwaltung schnell, z. löschen oder automatisch verwenden Unique_ptr) oder in deterministischer Referenzzählung (wo Objekte sofort zerstört werden, wenn ihre Referenzzahl auf 0 fällt), und daher funktioniert Raii in diesen Situationen gut. Das moderne automatische Speichermanagement ist jedoch nicht deterministisch, was keine Garantien dafür macht, dass Objekte sofort oder überhaupt zerstört werden! Dies liegt daran, dass es billiger ist, einen Müll zugewiesen zu lassen, als jedes Objekt sofort zu sammeln, wenn es Müll wird. Zweitens bedeutet das Freigeben von Ressourcen während der Zerstörung von Objekten, dass ein Objekt a haben muss Finalizer (im deterministischen Gedächtnismanagement, der als a bekannt ist Zerstörer) - Das Objekt kann nicht einfach behandelt werden - was die Müllsammlung erheblich kompliziert und verlangsamt.

Komplexe Beziehungen

Wenn mehrere Objekte auf einer einzelnen Ressource angewiesen sind, kann das Ressourcenmanagement kompliziert werden.

Eine grundlegende Frage ist, ob ein "eine" eine Beziehung hat besitzen ein anderes Objekt (Objektzusammensetzung), oder Betrachtung ein anderes Objekt (Objektaggregation). Ein häufiger Fall ist, wenn ein zwei Objekte wie in angekettet werden Pfeife und Filter Muster, die Delegationsmuster, das Dekorateurmuster, oder der Adaptermuster. Wenn das zweite Objekt (das nicht direkt verwendet wird) eine Ressource enthält, ist das erste Objekt (das direkt verwendet wird) für die Verwaltung der Ressource verantwortlich? Dies wird im Allgemeinen identisch mit der Frage beantwortet, ob das erste Objekt besitzt Das zweite Objekt: Wenn ja, ist das Besitzobjekt auch für das Ressourcenmanagement verantwortlich ("eine Ressource" ist transitiv), wenn nicht, dann ist es nicht. Darüber hinaus kann ein einzelnes Objekt mehrere andere Objekte haben, die einige besitzen und andere betrachten.

Beide Fälle werden häufig gefunden und Konventionen unterscheiden sich. Objekte, die Ressourcen verwenden, sind indirekt für die Ressource (Komposition) verantwortlich Verkapselung (Man benötigt nur das Objekt, das Clients ohne separate Objekte für die Ressourcen verwenden.) Wenn nur das Objekt, das die Ressource direkt verwendet, für die Ressource (Aggregation) verantwortlich ist, können Beziehungen zwischen anderen Objekten, die die Ressourcen verwenden, ignoriert werden, es gibt jedoch keine Kapselung (über das direkte Verwendung hinaus): Die Ressource muss direkt verwaltet werden. und ist möglicherweise nicht indirekt mit dem Objekt zur Verfügung (wenn es separat freigegeben wurde).

In Bezug auf die Implementierung wird in der Objektzusammensetzung das Besitzobjekt somit auch a entsorgen Methode, die wiederum die aufruft entsorgen Methoden von Objekten, die entsorgt werden müssen; In Raii wird dies automatisch behandelt (solange Eigentum Objekte selbst automatisch zerstört werden: in C ++, wenn sie ein Wert sind oder a Unique_ptr, aber kein roher Zeiger: Siehe Zeigerbesitz). In der Objektaggregation muss vom Betrachtungsobjekt nichts getan werden, da es nicht für die Ressource verantwortlich ist.

Beide sind allgemein gefunden. Zum Beispiel in der Java -Klassenbibliothek, Leser#close () Schließt den zugrunde liegenden Strom und diese können angekettet werden. Zum Beispiel a BufferedReader Kann a enthalten InputStreamReader, was wiederum a enthält a FileInputStreamund rufen nah dran auf der BufferedReader schließt wiederum die InputStreamReader, was wiederum die schließt FileInputStream, was wiederum die Systemdateiressource freigibt. In der Tat kann das Objekt, das die Ressource direkt verwendet, dank der Kapselung sogar anonym:

Versuchen (BufferedReader Leser = Neu BufferedReader(Neu InputStreamReader(Neu FileInputStream(Dateiname)))) {  // Leser verwenden. } // Der Leser wird geschlossen, wenn der Block mit Try-with-Ressourcen beendet wird, der jedes der enthaltenen Objekte nacheinander schließt. 

Es ist jedoch auch möglich, nur das Objekt zu verwalten, das die Ressource direkt verwendet, und keine Ressourcenverwaltung für Wrapper -Objekte verwenden:

Versuchen (FileInputStream Strom = Neu FileInputStream(Dateiname)))) {  BufferedReader Leser = Neu BufferedReader(Neu InputStreamReader(Strom));  // Leser verwenden. } // Stream ist geschlossen, wenn der Block mit Try-with-Ressourcen beendet ist. // Der Leser ist nach dem Schließen des Streams nicht mehr verwendbar, aber solange er dem Block nicht entkommt, ist dies kein Problem. 

Im Gegensatz dazu in Python, a csv.reader besitzt das nicht Datei dass es liest, so dass es nicht nötig ist (und es ist nicht möglich), den Leser zu schließen, und stattdessen die Datei selbst muss geschlossen sein.[8]

mit offen(Dateiname) wie f:  r = CSV.Leser(f)  # Benutzer. # f ist geschlossen, wenn das mit dem Nachdruck ausgestrahlt wird und nicht mehr verwendet werden kann. # Mit R wird nichts angetan, aber das zugrunde liegende F ist geschlossen, so dass R auch nicht verwendet werden kann. 

Im .NETZDie Übereinkommen besteht darin, nur einen direkten Benutzer von Ressourcen zu verantwortlich sein: "Sie sollten idisposable nur dann implementieren, wenn Ihr Typ nicht verwaltete Ressourcen direkt verwendet."[9]

Im Falle einer komplizierteren Objektdiagramm, wie z. B. mehrere Objekte, die eine Ressource oder Zyklen zwischen Objekten mit Ressourcen teilen, das ordnungsgemäße Ressourcenverwaltung kann ziemlich kompliziert sein, und genau dieselben Probleme ergeben sich wie bei der Objektabschluss (über Destruktoren oder Finalizer). Zum Beispiel die Verfälschtes Hörerproblem kann auftreten und Ressourcenlecks verursachen, wenn die Verwendung der VerwendungBeobachtermuster (und Beobachter halten Ressourcen). Es gibt verschiedene Mechanismen, um eine stärkere Kontrolle des Ressourcenmanagements zu ermöglichen. Zum Beispiel in der Google Closure Library, das goog.disposable Klasse bietet a RegisterDisposable Methode, um andere Objekte zu registrieren, die dieses Objekt zusammen mit verschiedenen Instanz- und Klassenmethoden auf niedrigerer Ebene zur Verwaltung der Entsorgung zur Verfügung stellen.

Strukturierte Programmierung

Im Strukturierte Programmierung, Stack Resource Management erfolgt einfach durch die Verschachtung des Codes ausreichend, um alle Fälle zu verarbeiten. Dies erfordert nur eine einzige Rendite am Ende des Code Anti-Muster von einigen - die Pfeil Anti -Muster,[10] Aufgrund der dreieckigen Form aus dem aufeinanderfolgenden Nist.

Reinigungsklausel

Ein weiterer Ansatz, der eine frühzeitige Rückkehr ermöglicht, aber die Reinigung an einem Ort konsolidiert, besteht darin, eine einzige Ausstiegsrendite einer Funktion zu erzielen, deren Aufräumcode vorangestellt und verwendet werden gehe zu vor dem Ausgang zur Reinigung springen. Dies ist im modernen Code selten zu sehen, tritt jedoch in einigen Verwendungen von C auf.

Siehe auch

Verweise

  1. ^ a b Beck 1997, S. 37–39.
  2. ^ a b Elder, Jackson & Liblit 2008, p. 3.
  3. ^ Elder, Jackson & Liblit 2008, p. 2.
  4. ^ "Generikum: Ändern Sie die Art und Weise, wie Sie ausnahmssicherer Code schreiben-für immer", durch Andrei Alexandrescu und Petru Marginean, 01. Dezember 2000, Dr. Dobbs
  5. ^ ScopeGuard 2.0, Joshua Lehrer
  6. ^ D: Ausnahmesicherheit
  7. ^ Verschiebung, Panik und erholenAndrew Gerrand, Der Go -Blog, 4. August 2010
  8. ^ Python: no csv.close ()?
  9. ^ "Idisposable Schnittstelle". Abgerufen 2016-04-03.
  10. ^ Abflachung des Pfeilcodes, Jeff Atwood, 10. Januar 2006

Weitere Lektüre

Externe Links