在Java 7的库中，我有一个为其他类提供服务的类。创建此服务类的实例后，可以多次调用该服务类的一个方法（将其称为doWork()方法）。因此，我不知道服务类的工作何时完成。

问题在于服务类使用重对象，并且应该释放它们。我在方法中设置了这一部分（我们称它为release()），但不能保证其他开发人员将使用此方法。

有没有一种方法可以迫使其他开发人员在完成服务类任务后调用此方法？我当然可以记录下来，但是我想强迫他们。

注意：我无法在release()方法中调用该方法doWork()，因为doWork() 在下一次调用该方法时需要这些对象。

务实的解决方案是制作类AutoCloseable，并提供一个finalize()作为支持的方法（如果合适，请参见下文！）。然后，您依靠班级的用户使用try-with-resource或close()显式调用。

我当然可以记录下来，但是我想强迫他们。

不幸的是，Java中没有方法¹可以迫使程序员做正确的事。您可能希望做的最好的事情就是在静态代码分析器中发现不正确的用法。

关于终结器的话题。此Java功能很少有很好的用例。如果您依靠终结器进行整理，则会遇到以下问题：整理可能需要很长时间。只有在GC决定该对象不再可访问之后，终结器才会运行。在JVM完成完整收集之前，可能不会发生这种情况。

因此，如果您要解决的问题是回收需要尽早释放的资源，那么您将无法使用finalization 来解决问题。

并且以防万一您没有我在上面说的话... 在生产代码中几乎不适合使用终结器，并且您永远不应依赖它们！

^{1-有办法。如果您准备从用户代码中“隐藏”服务对象或严格控制其生命周期（例如https://softwareengineering.stackexchange.com/a/345100/172），则用户代码不需要调用release()。但是，API变得更加复杂，受限制……而且“丑陋”的IMO。同样，这并不是在强迫程序员做正确的事。它正在消除程序员做错事的能力！}

这似乎是AutoCloseable接口的用例和Java 7中引入的try-with-resources语句。

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

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

然后您的消费者可以将其用作

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

不必担心调用显式方法release，无论其代码是否引发异常。

附加答案

如果您真正要寻找的是确保没有人会忘记使用您的功能，那么您必须做几件事

1. 确保的所有构造函数MyService都是私有的。
2. 定义要使用的单个入口点，以MyService确保在此之后对其进行清理。

你会做类似的事情

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)
        }
    }
}

然后，您将其用作

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

我最初不建议使用此路径，因为它没有Java-8 lambda和功能性接口（MyServiceConsumer变为Consumer<MyService>），因此很丑陋，并且确实强加于您的使用者。但是，如果您只想要被release()调用，它将起作用。

是的你可以

您可以绝对迫使他们释放它们，并通过使它们无法创建新Service实例来使它成为100％不可能忘记的事情。

如果他们之前做过这样的事情：

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

然后更改它，以便他们必须像这样访问它。

// 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();
      } 
    } 
  }

注意事项：

• 考虑一下这个伪代码，自从我编写Java以来​​已经存在了很长时间。
• 这些天可能会有更优雅的变体，也许包括AutoCloseable有人提到的那个界面。但是给定的示例应该是开箱即用的，并且除了优雅（这本身是一个不错的目标）之外，没有任何理由更改它。注意，这是要说明您可以AutoCloseable在私有实现中使用；与让您的用户使用相比，我的解决方案的好处AutoCloseable是，它不会再次被遗忘。
• 您必须根据需要对其进行充实，例如，将参数注入到new Service调用中。
• 如评论中所述，类似这样的构造（即，进行创建和销毁a的过程Service）是否属于调用方的问题不在此答案的范围之内。但是，如果您确定绝对需要此功能，这就是您可以做到的方式。
• 一位评论者提供了有关异常处理的以下信息：Google图书

您可以尝试使用命令模式。

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();
    }

}

这使您可以完全控制资源的获取和释放。呼叫者仅将任务提交给您的服务，您自己负责获取和清理资源。

但是有一个陷阱。呼叫者仍然可以这样做：

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

但是您可以解决这个问题。如果存在性能问题，而您发现有一些调用者这样做，则只需向他们显示正确的方法并解决问题：

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

您可以通过为依赖于其他任务的任务实现承诺来使此过程变得任意复杂，但是发布内容也变得更加复杂。这仅仅是一个起点。

异步

正如评论中指出的那样，以上内容实际上不适用于异步请求。没错。但这可以通过使用CompleteableFuture在Java 8中轻松解决，尤其是CompleteableFuture#supplyAsync在创建完所有任务之后创建单个的期货并CompleteableFuture#allOf执行资源的释放。或者，可以始终使用Threads或ExecutorServices滚动其自己的Future / Promises实现。

如果可以，则不允许用户创建资源。让用户将访问者对象传递给您的方法，该方法将创建资源，将其传递给访问者对象的方法，然后释放。

我的想法类似于Polygnome的想法。

您可以在类中使用“ do_something（）”方法，只需将命令添加到专用命令列表中即可。然后，使用一个“ commit（）”方法实际完成工作，并调用“ release（）”。

因此，如果用户从不调用commit（），则该工作永远不会完成。如果这样做，则释放资源。

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();
  }

}

然后，您可以像foo.doSomething.doSomethineElse（）。commit（）;一样使用它。

提到的方法的另一种选择是使用“智能引用”来管理封装的资源，使垃圾收集器能够自动清理而无需手动释放资源。它们的有用性当然取决于您的实现。在此精彩的博客文章中了解有关此主题的更多信息：https : //community.oracle.com/blogs/enicholas/2006/05/04/understanding-weak-references

对于任何其他面向类的语言，我都会说将其放在析构函数中，但是由于这不是一种选择，因此我认为您可以覆盖finalize方法。这样，当实例超出范围并被垃圾回收时，它将被释放。

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

我不太熟悉Java，但是我认为这是finalize（）的目的。

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