Di perpustakaan di Java 7, saya memiliki kelas yang menyediakan layanan ke kelas lain. Setelah membuat turunan dari kelas layanan ini, satu metode dapat dipanggil beberapa kali (sebut saja doWork()metode). Jadi saya tidak tahu kapan pekerjaan kelas layanan selesai.

Masalahnya adalah kelas layanan menggunakan benda berat dan harus melepaskannya. Saya mengatur bagian ini dalam suatu metode (sebut saja release()), tetapi tidak dijamin bahwa pengembang lain akan menggunakan metode ini.

Apakah ada cara untuk memaksa pengembang lain untuk memanggil metode ini setelah menyelesaikan tugas kelas layanan? Tentu saja saya bisa mendokumentasikannya, tetapi saya ingin memaksa mereka.

Catatan: Saya tidak dapat memanggil release()metode dalam doWork()metode ini, karena doWork() membutuhkan objek tersebut ketika dipanggil selanjutnya.

Solusi pragmatis adalah membuat kelas AutoCloseable, dan menyediakan finalize()metode sebagai backstop (jika perlu ... lihat di bawah!). Kemudian Anda bergantung pada pengguna kelas Anda untuk menggunakan try-with-resource atau menelepon close()secara eksplisit.

Tentu saja saya bisa mendokumentasikannya, tetapi saya ingin memaksa mereka.

Sayangnya, tidak ada cara ¹ di Jawa untuk memaksa programmer untuk melakukan hal yang benar. Yang terbaik yang bisa Anda lakukan adalah mengambil penggunaan yang salah dalam penganalisa kode statis.

Pada topik finalizers. Fitur Java ini memiliki sangat sedikit kasus penggunaan yang baik . Jika Anda bergantung pada finalizer untuk merapikan, Anda mengalami masalah yang bisa memakan waktu sangat lama untuk merapikannya. Finalizer hanya akan dijalankan setelah GC memutuskan bahwa objek tidak lagi dapat dijangkau. Itu mungkin tidak terjadi sampai JVM melakukan pengumpulan penuh .

Jadi, jika masalah yang ingin Anda selesaikan adalah merebut kembali sumber daya yang perlu dirilis lebih awal , maka Anda telah ketinggalan perahu dengan menggunakan finalisasi.

Dan kalau-kalau Anda tidak mendapatkan apa yang saya katakan di atas ... hampir tidak pernah tepat untuk menggunakan finalizer dalam kode produksi, dan Anda tidak boleh mengandalkan mereka!

^{1 - Ada beberapa cara. Jika Anda siap untuk "menyembunyikan" objek layanan dari kode pengguna atau mengontrol siklus hidupnya dengan ketat (mis. Https://softwareengineering.stackexchange.com/a/345100/172 ) maka kode pengguna tidak perlu menelepon release(). Namun, API menjadi lebih rumit, dibatasi ... dan IMO "jelek". Juga, ini tidak memaksa programmer untuk melakukan hal yang benar . Ini menghilangkan kemampuan programmer untuk melakukan hal yang salah!}

Ini seperti use-case untuk AutoCloseableantarmuka dan try-with-resourcespernyataan yang diperkenalkan di Java 7. Jika Anda memiliki sesuatu seperti

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

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

maka konsumen Anda dapat menggunakannya sebagai

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

dan tidak perlu khawatir tentang memanggil eksplisit releaseterlepas dari apakah kode mereka melempar pengecualian.

Jawaban tambahan

Jika yang benar-benar Anda cari adalah untuk memastikan tidak ada yang bisa lupa untuk menggunakan fungsi Anda, Anda harus melakukan beberapa hal

1. Pastikan semua konstruktor MyServicebersifat pribadi.
2. Tentukan satu titik masuk untuk digunakan MyServiceyang memastikan itu dibersihkan setelah.

Anda akan melakukan sesuatu seperti

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

Anda kemudian akan menggunakannya sebagai

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

Saya tidak merekomendasikan jalur ini pada awalnya karena itu mengerikan tanpa Java-8 lambdas dan antarmuka fungsional (di mana MyServiceConsumermenjadi Consumer<MyService>) dan itu cukup mengesankan pada konsumen Anda. Tetapi jika yang Anda inginkan hanyalah yang release()harus dipanggil, itu akan berhasil.

ya kamu bisa

Anda benar-benar dapat memaksa mereka untuk melepaskan, dan membuatnya jadi 100% mustahil untuk dilupakan, dengan membuatnya tidak mungkin bagi mereka untuk membuat Serviceinstance baru .

Jika mereka melakukan sesuatu seperti ini sebelumnya:

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

Kemudian ubah sehingga mereka harus mengaksesnya seperti ini.

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

Peringatan:

• Pertimbangkan kodesemu ini, sudah lama sejak saya menulis Java.
• Mungkin ada varian yang lebih elegan di sekitar hari ini, mungkin termasuk AutoCloseableantarmuka yang disebutkan seseorang; tetapi contoh yang diberikan harus bekerja di luar kotak, dan kecuali untuk keanggunan (yang merupakan tujuan yang bagus dalam dirinya sendiri) tidak boleh ada alasan utama untuk mengubahnya. Perhatikan bahwa ini bermaksud untuk mengatakan bahwa Anda dapat menggunakan AutoCloseabledi dalam implementasi pribadi Anda; manfaat dari solusi saya atas penggunaan pengguna Anda AutoCloseableadalah bahwa hal itu dapat, sekali lagi, tidak dilupakan.
• Anda harus menyempurnakannya sesuai kebutuhan, misalnya untuk menyuntikkan argumen ke dalam new Servicepanggilan.
• Seperti disebutkan dalam komentar, pertanyaan apakah konstruk seperti ini (yaitu, mengambil proses membuat dan menghancurkan a Service) berada di tangan si penelepon atau tidak berada di luar cakupan jawaban ini. Tetapi jika Anda memutuskan bahwa Anda benar-benar membutuhkan ini, ini adalah bagaimana Anda dapat melakukannya.
• Seorang komentator memberikan informasi ini mengenai penanganan pengecualian: Google Books

Anda dapat mencoba memanfaatkan pola Command .

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

}

Ini memberi Anda kendali penuh atas akuisisi dan pelepasan sumber daya. Penelepon hanya mengirimkan tugas ke Layanan Anda, dan Anda sendiri yang bertanggung jawab untuk memperoleh dan membersihkan sumber daya.

Namun ada tangkapan. Penelepon masih dapat melakukan ini:

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

Tapi Anda bisa mengatasi masalah ini ketika sedang arisis. Ketika ada masalah kinerja dan Anda mengetahui bahwa beberapa penelepon melakukan ini, cukup tunjukkan cara yang tepat dan selesaikan masalah:

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

Anda dapat membuat kompleks sewenang-wenang ini dengan menerapkan janji-janji untuk tugas-tugas yang bergantung pada tugas-tugas lain, tetapi kemudian melepaskan barang juga menjadi lebih rumit. Ini hanya titik awal.

Async

Seperti yang telah ditunjukkan dalam komentar, hal di atas tidak benar-benar berfungsi dengan permintaan asinkron. Itu benar. Tetapi ini dapat dengan mudah diselesaikan di Java 8 dengan menggunakan CompleteableFuture , terutama CompleteableFuture#supplyAsyncuntuk menciptakan masa depan individu dan CompleteableFuture#allOfuntuk merilis sumber daya setelah semua tugas selesai. Atau, seseorang selalu dapat menggunakan Utas atau Layanan Pelaksana untuk menggulung implementasi Futures / Janji mereka sendiri.

Jika Anda bisa, jangan izinkan pengguna membuat sumber daya. Biarkan pengguna meneruskan objek pengunjung ke metode Anda, yang akan membuat sumber daya, meneruskannya ke metode objek pengunjung, dan lepaskan setelahnya.

Ide saya mirip dengan Polygnome.

Anda dapat memiliki metode "do_something ()" di kelas Anda hanya menambahkan perintah ke daftar perintah pribadi. Kemudian, miliki metode "commit ()" yang benar-benar berfungsi, dan panggil "release ()".

Jadi, jika pengguna tidak pernah memanggil commit (), pekerjaan itu tidak pernah dilakukan. Jika mereka melakukannya, sumber dayanya akan dibebaskan.

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

}

Anda kemudian dapat menggunakannya seperti foo.doSomething.doSomethineElse (). Commit ();

Alternatif lain dari yang disebutkan adalah penggunaan "referensi pintar" untuk mengelola sumber daya Anda yang telah dienkapsulasi dengan cara yang memungkinkan pengumpul sampah untuk secara otomatis membersihkan tanpa secara manual membebaskan sumber daya. Kegunaannya tentu saja tergantung pada implementasi Anda. Baca lebih lanjut tentang topik ini di posting blog yang luar biasa ini: https://community.oracle.com/blogs/enicholas/2006/05/04/understanding-weak-references

Untuk bahasa Berorientasi Kelas lainnya saya akan mengatakan memasukkannya ke dalam destructor, tetapi karena itu bukan pilihan saya pikir Anda dapat menimpa metode finalisasi. Dengan begitu ketika instance keluar dari ruang lingkup dan dikumpulkan sampah itu akan dirilis.

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

Saya tidak terlalu terbiasa dengan Java, tetapi saya pikir ini adalah tujuan finalisasi yang dimaksudkan.

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