In einer Bibliothek in Java 7 habe ich eine Klasse, die Dienste für andere Klassen bereitstellt. Nach dem Erstellen einer Instanz dieser Serviceklasse kann eine Methode davon mehrmals aufgerufen werden (nennen wir sie die doWork()Methode). Ich weiß also nicht, wann die Arbeit der Serviceklasse abgeschlossen ist.

Das Problem ist, dass die Serviceklasse schwere Objekte verwendet und diese freigeben sollte. Ich habe diesen Teil in einer Methode festgelegt (nennen wir es release()), aber es ist nicht garantiert, dass andere Entwickler diese Methode verwenden.

Gibt es eine Möglichkeit, andere Entwickler zu zwingen, diese Methode aufzurufen, nachdem die Aufgabe der Serviceklasse abgeschlossen wurde? Natürlich kann ich das dokumentieren, aber ich möchte sie zwingen.

Hinweis: Ich kann die release()Methode in der doWork()Methode nicht aufrufen , da doWork() diese Objekte beim nächsten Aufruf benötigt werden.

Die pragmatische Lösung besteht darin, die Klasse zu erstellen AutoCloseableund eine finalize()Methode als Backstop bereitzustellen (falls zutreffend ... siehe unten!). Dann verlassen Sie sich darauf, dass Benutzer Ihrer Klasse try-with-resource verwenden oder close()explizit anrufen .

Natürlich kann ich das dokumentieren, aber ich möchte sie zwingen.

Leider gibt es in Java keine Möglichkeit ¹ , den Programmierer dazu zu zwingen, das Richtige zu tun. Das Beste, was Sie hoffen können, ist, eine falsche Verwendung in einem statischen Code-Analysator zu erkennen.

Zum Thema Finalizer. Diese Java-Funktion hat nur sehr wenige gute Anwendungsfälle. Wenn Sie sich darauf verlassen, dass die Finalizer aufräumen, besteht das Problem, dass das Aufräumen sehr lange dauern kann. Die Finalizerthread wird nur dann ausgeführt werden , nachdem die GC entscheidet , dass das Objekt nicht mehr erreichbar ist . Dies kann nicht passieren, bis die JVM eine vollständige Sammlung durchführt.

Wenn das Problem, das Sie lösen möchten, darin besteht, Ressourcen zurückzugewinnen, die vorzeitig freigegeben werden müssen , haben Sie das Boot mit der Finalisierung verpasst.

Und nur für den Fall, dass Sie nicht haben, was ich oben sage ... es ist fast nie angebracht, Finalizer im Produktionscode zu verwenden, und Sie sollten sich niemals auf sie verlassen!

^{1 - Es gibt Wege. Wenn Sie zu „verstecken“ vorbereitet sind die Service - Objekte aus Benutzercode oder fest ihren Lebenszyklus steuern (zB https://softwareengineering.stackexchange.com/a/345100/172 ) , dann dem Benutzer - Code nicht brauchen , um Anruf release(). Die API wird jedoch komplizierter, eingeschränkter ... und "hässlicher" IMO. Dies zwingt den Programmierer auch nicht dazu, das Richtige zu tun . Es beseitigt die Fähigkeit des Programmierers, das Falsche zu tun!}

Dies scheint der Anwendungsfall für die AutoCloseableSchnittstelle und die in Java 7 eingeführte try-with-resourcesAnweisung zu sein

public class MyService implements AutoCloseable {
    public void doWork() {
        // ...
    }

    @Override
    public void close() {
        // release resources
    }
}

dann können Ihre Verbraucher es als

public class MyConsumer {
    public void foo() {
        try (MyService myService = new MyService()) {
            //...
            myService.doWork()
            //...
            myService.doWork()
            //...
        }
    }
}

und müssen sich nicht darum kümmern, einen expliziten releaseCode aufzurufen, unabhängig davon, ob sein Code eine Ausnahme auslöst.

Zusätzliche Antwort

Wenn Sie wirklich sicherstellen möchten, dass niemand vergessen kann, Ihre Funktion zu verwenden, müssen Sie einige Dinge tun

1. Stellen Sie sicher, dass alle Konstruktoren von MyServiceprivat sind.
2. Definieren Sie einen einzelnen zu verwendenden Eintrittspunkt MyService, der sicherstellt, dass er nach dem Bereinigen gelöscht wird.

Du würdest sowas machen

public interface MyServiceConsumer {
    void accept(MyService value);
}

public class MyService implements AutoCloseable {
    private MyService() {
    }


    public static void useMyService(MyServiceConsumer consumer) {
        try (MyService myService = new MyService()) {
            consumer.accept(myService)
        }
    }
}

Sie würden es dann als verwenden

public class MyConsumer {
    public void foo() {
        MyService.useMyService(new MyServiceConsumer() {
            public void accept(MyService myService) {
                myService.doWork()
            }
        });
    }
}

Ich habe diesen Pfad ursprünglich nicht empfohlen, da er ohne Java-8-Lambdas und funktionale Schnittstellen (wo MyServiceConsumerwird Consumer<MyService>) abscheulich ist und für Ihre Verbraucher ziemlich imposant ist. Aber wenn Sie nur wollen, dass release()aufgerufen werden muss, wird es funktionieren.

Ja, du kannst

Sie können sie zwingen, neue ServiceInstanzen zu erstellen, und dies zu 100% unmöglich machen, indem Sie es ihnen unmöglich machen, neue Instanzen zu erstellen .

Wenn sie so etwas schon einmal gemacht haben:

Service s = s.new();
try {
  s.doWork("something");
  if (...) s.doWork("something else");
  ...
}
finally {
  s.release(); // oops: easy to forget
}

Ändern Sie es dann so, dass sie so darauf zugreifen müssen.

// Their code

Service.runWithRelease(new ServiceConsumer() {
  void run(Service s) {
    s.doWork("something");
    if (...) s.doWork("something else");
    ...
  }  // yay! no s.release() required.
}

// Your code

interface ServiceConsumer {
  void run(Service s);
}

class Service {

   private Service() { ... }      // now: private
   private void release() { ... } // now: private
   public void doWork() { ... }   // unchanged

   public static void runWithRelease(ServiceConsumer consumer) {
      Service s = new Service();
      try {
        consumer.run(s);
      }
      finally {
        s.release();
      } 
    } 
  }

Vorsichtsmaßnahmen:

• Betrachten Sie diesen Pseudocode, es ist eine Ewigkeit her, seit ich Java geschrieben habe.
• Es könnte heutzutage elegantere Varianten geben, einschließlich der von AutoCloseablejemandem erwähnten Schnittstelle. Aber das gegebene Beispiel sollte sofort funktionieren, und abgesehen von der Eleganz (die ein schönes Ziel für sich ist) sollte es keinen wichtigen Grund geben, es zu ändern. Beachten Sie, dass dies bedeuten soll, dass Sie es AutoCloseablein Ihrer privaten Implementierung verwenden können. Der Vorteil meiner Lösung gegenüber der Verwendung durch Ihre Benutzer AutoCloseablebesteht darin, dass sie nicht vergessen werden kann.
• Sie müssen es nach Bedarf ausarbeiten, um beispielsweise Argumente in den new ServiceAufruf einzufügen.
• Wie in den Kommentaren erwähnt, liegt die Frage, ob ein solches Konstrukt (dh der Prozess des Erzeugens und Zerstörens von a Service) in der Hand des Aufrufers liegt oder nicht, außerhalb des Bereichs dieser Antwort. Aber wenn Sie sich dazu entschließen, dass Sie das unbedingt brauchen, können Sie es so machen.
• Ein Kommentator lieferte diese Informationen zur Ausnahmebehandlung: Google Books

Sie können versuchen, das Befehlsmuster zu verwenden.

class MyServiceManager {

    public void execute(MyServiceTask tasks...) {
        // set up everyting
        MyService service = this.acquireService();
        // execute the submitted tasks
        foreach (Task task : tasks)
            task.executeWith(service);
        // cleanup yourself
        service.releaseResources();
    }

}

Dies gibt Ihnen die volle Kontrolle über die Beschaffung und Freigabe von Ressourcen. Der Anrufer übergibt nur Aufgaben an Ihren Dienst, und Sie sind selbst dafür verantwortlich, Ressourcen zu beschaffen und zu bereinigen.

Es gibt jedoch einen Haken. Der Anrufer kann dies trotzdem tun:

MyServiceTask t1 = // some task
manager.execute(t1);
MyServiceTask t2 = // some task
manager.execute(t2);

Aber Sie können dieses Problem ansprechen, wenn es auftritt. Wenn es Leistungsprobleme gibt und Sie feststellen, dass einige Anrufer dies tun, zeigen Sie ihnen einfach den richtigen Weg und beheben Sie das Problem:

MyServiceTask t1 = // some task
MyServiceTask t2 = // some task
manager.execute(t1, t2);

Sie können dies beliebig komplex gestalten, indem Sie Versprechungen für Aufgaben implementieren, die von anderen Aufgaben abhängig sind. Das Freigeben von Inhalten wird jedoch auch komplizierter. Dies ist nur ein Ausgangspunkt.

Async

Wie in den Kommentaren ausgeführt wurde, funktioniert das oben Genannte nicht wirklich mit asynchronen Anforderungen. Das ist richtig. Dies kann in Java 8 mit CompleteableFuture problemlos gelöst werden , insbesondere CompleteableFuture#supplyAsyncum die einzelnen Zukünfte zu erstellen und CompleteableFuture#allOfdie Freigabe der Ressourcen durchzuführen, sobald alle Aufgaben abgeschlossen sind. Alternativ kann man jederzeit Threads oder ExecutorServices verwenden, um eine eigene Implementierung von Futures / Promises durchzuführen.

Wenn Sie können, erlauben Sie dem Benutzer nicht, die Ressource zu erstellen. Lassen Sie den Benutzer ein Besucherobjekt an Ihre Methode übergeben, wodurch die Ressource erstellt, an die Methode des Besucherobjekts übergeben und anschließend freigegeben wird.

Meine Idee war ähnlich wie die von Polygnome.

Mit den Methoden "do_something ()" in Ihrer Klasse können Sie einfach Befehle zu einer privaten Befehlsliste hinzufügen. Dann haben Sie eine "commit ()" - Methode, die tatsächlich die Arbeit erledigt und "release ()" aufruft.

Wenn der Benutzer also niemals commit () aufruft, ist die Arbeit nie erledigt. In diesem Fall werden die Ressourcen freigegeben.

public class Foo
{
  private ArrayList<ICommand> _commands;

  public Foo doSomething(int arg) { _commands.Add(new DoSomethingCommand(arg)); return this; }
  public Foo doSomethingElse() { _commands.Add(new DoSomethingElseCommand()); return this; }

  public void commit() { 
     for(ICommand c : _commands) c.doWork();
     release();
     _commands.clear();
  }

}

Sie können es dann wie folgt verwenden: foo.doSomething.doSomethineElse (). Commit ();

Eine andere Alternative zu den genannten wäre die Verwendung von "intelligenten Referenzen", um Ihre gekapselten Ressourcen so zu verwalten, dass der Garbage Collector automatisch bereinigen kann, ohne Ressourcen manuell freizugeben. Ihr Nutzen hängt natürlich von Ihrer Implementierung ab. Lesen Sie mehr zu diesem Thema in diesem wunderbaren Blog-Beitrag: https://community.oracle.com/blogs/enicholas/2006/05/04/understanding-weak-references

Für jede andere klassenorientierte Sprache würde ich sagen, legen Sie sie in den Destruktor, aber da dies keine Option ist, können Sie die Finalisierungsmethode überschreiben. Auf diese Weise wird die Instanz freigegeben, wenn sie außerhalb des Gültigkeitsbereichs liegt und der Speicherplatz nicht mehr ausreicht.

@Override
public void finalize() {
    this.release();
}

Ich bin mit Java nicht allzu vertraut, denke aber, dass dies der Zweck ist, für den finalize () vorgesehen ist.

http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#finalize ()