Java 7'deki bir kütüphanede diğer sınıflara hizmet veren bir sınıfa sahibim. Bu hizmet sınıfının bir örneğini oluşturduktan sonra, bunun bir yöntemi birkaç kez çağrılabilir (hadi yöntem olarak adlandıralım doWork()). Bu yüzden hizmet sınıfının çalışması ne zaman biter bilmiyorum.

Sorun, servis sınıfının ağır nesneler kullanması ve onları serbest bırakmasıdır. Bu kısmı bir yöntemde belirledim (diyelim release()), ancak diğer geliştiricilerin bu yöntemi kullanacağı garanti edilmez.

Servis sınıfının görevini tamamladıktan sonra diğer geliştiricileri bu yöntemi çağırmaya zorlamanın bir yolu var mı? Tabii ki bunu belgeleyebilirim ama onları zorlamak istiyorum.

Not: release()Yöntemdeki yöntemi doWork()çağıramıyorum, çünkü doWork() daha sonra çağrıldığında bu nesnelere ihtiyaç duyuyor.

Pragmatik çözüm, sınıfı yapmak ve geri döndürmez olarak bir yöntem AutoCloseablesunmaktır finalize()(eğer uygunsa ... aşağıya bakınız!). Ardından, kaynak kullanarak denemek veya close()açıkça arama yapmak için sınıfınızın kullanıcılarına güvenin.

Tabii ki bunu belgeleyebilirim ama onları zorlamak istiyorum.

Ne yazık ki, programcıyı doğru olanı yapmaya zorlamak için Java'da ¹ yolu yoktur . Yapmayı umabileceğiniz en iyi şey, statik kod çözümleyicide yanlış kullanımı tespit etmektir.

Kesinleştiriciler konusunda. Bu Java özelliği çok az iyi kullanım durumlarına sahiptir. Toplayıcılık için kesinleştiricilere güvenirseniz, toparlanmanın gerçekleşmesinin çok uzun zaman alabileceği sorunuyla karşı karşıya kalırsınız. Sonlandırıcı yalnızca GC nesneye artık erişilemez olduğuna karar verdikten sonra çalıştırılacaktır . JVM tam bir koleksiyon yapana kadar bu olmayabilir .

Bu nedenle, çözmek istediğiniz sorun erken çıkarılması gereken kaynakları geri almak ise , sonlandırma kullanarak tekneyi kaçırdınız.

Ve yukarıda söylediklerime sahip değilseniz, sonlandırıcıları üretim kodunda kullanmak hiçbir zaman uygun değildir ve asla bunlara güvenmemeniz gerekir!

^{1 - Yollar var. Hizmet nesnelerini kullanıcı kodundan "gizlemeye" hazırsanız veya kullanım ömrünü sıkıca kontrol ederseniz (örneğin, https://softwareengineering.stackexchange.com/a/345100/172 ) o zaman kullanıcı kodunu çağırmanız gerekmezrelease() . Ancak, API daha karmaşık, kısıtlı ... ve "çirkin" IMO olur. Ayrıca, bu programcıyı doğru olanı yapmaya zorlamaz . Programcının yanlış şeyi yapma yeteneğini ortadan kaldırıyor!}

Bu, AutoCloseablearabirim için kullanım durumu ve Java 7'de sunulan try-with-resourcesifadeye benziyor.

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

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

o zaman tüketicileriniz onu kullanabilir

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

ve releasekodlarının bir istisna atıp atmadığına bakılmaksızın açık bir çağrı yapmak için endişelenmenize gerek yoktur .

Ek cevap

Eğer gerçekten aradığınız şey, kimsenin işlevinizi kullanmayı unutamayacağından emin olmaksa, birkaç şey yapmanız gerekir.

1. Tüm yapıcıların MyServiceözel olduğundan emin olun .
2. Kullandıktan MyServicesonra temizlenmesini sağlamak için kullanılacak tek bir giriş noktası tanımlayın .

Gibi bir şey yapardın

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

O zaman olarak kullanırdın

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

Java-8 lambdas ve fonksiyonel arayüzler (burada olmadan çirkin olduğu için başlangıçta bu yolu tavsiye etmedi MyServiceConsumerolur Consumer<MyService>) ve oldukça da tüketiciler üzerinde heybetli. Ama sadece istediğin, aranması release()gereken şeyse işe yarayacak.

Evet yapabilirsin

Onları serbest bırakmaları için kesinlikle zorlayabilir ve yeni Serviceörnekleri yaratmalarını imkansız kılarak, unutmak imkansız olan% 100'dür .

Daha önce böyle bir şey yaptılarsa:

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

O zaman değiştirin, böylece bu şekilde erişebilsinler.

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

Uyarılar:

• Bu sahte kodu göz önünde bulundurun, Java yazdığımdan bu yana yıllar geçti.
• Bugünlerde, belki de AutoCloseablebahsi geçen birinin ara yüzü dahil olmak üzere, daha zarif çeşitler olabilir ; ancak verilen örnek kutunun dışına çıkmalı ve şıklık dışında (ki bu kendi içinde iyi bir amaçtır) değiştirmek için önemli bir sebep olmamalıdır. Bunun AutoCloseable, özel uygulamanızın içinde kullanabileceğinizi söylemek niyetinde olduğunu unutmayın ; Çözümümün kullanıcılarınızın kullanımına göre yararı AutoCloseable, yine unutulamamasıdır.
• Örneğin new Serviceçağrıya argümanları eklemek için gerektiği gibi kesmeniz gerekir .
• Yorumlarda da belirtildiği gibi, böyle bir yapının (a yaratma ve yok etme sürecini alma Service) arayanın elinde olup olmadığı sorusu bu cevabın kapsamı dışındadır. Ancak buna kesinlikle ihtiyacınız olduğuna karar verirseniz, bunu nasıl yapabilirsiniz.
• Bir yorum yapan, istisnaların ele alınmasıyla ilgili şu bilgileri verdi: Google Kitaplar

Komut düzenini kullanmayı deneyebilirsiniz .

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

}

Bu size kaynak edinimi ve salıverilmesinde tam kontrol sağlar. Arayan kişi yalnızca Servisinize görevler verir ve siz de kaynakları almaktan ve temizlemekten siz sorumlusunuz.

Yalnız dikkat edilmesi gereken bir şey var. Arayan hala bunu yapabilir:

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

Fakat bu problemi ortaya çıktığında çözebilirsiniz. Performans sorunları olduğunda ve bazı arayanların bunu yaptığını öğrendiğinizde, onlara doğru yolu gösterin ve sorunu çözün:

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

Bunu, diğer görevlere bağlı görevler için vaatler uygulayarak keyfi olarak karmaşık hale getirebilirsiniz, ancak daha sonra işleri serbest bırakmak da daha karmaşık hale gelir. Bu sadece bir başlangıç ​​noktasıdır.

zaman uyumsuz

Yorumlarda da belirtildiği gibi, yukarıdakiler asenkron isteklerle gerçekten çalışmaz. Bu doğru. Ancak bu, Java 8'de CompleteableFuture kullanımıyla , özellikle CompleteableFuture#supplyAsyncbireysel geleceklerini oluşturmak ve tüm görevler tamamlandıktan CompleteableFuture#allOfsonra kaynakların serbest bırakılmasını sağlamak için kolayca çözülebilir . Alternatif olarak, kendi Futures / Promises uygulamalarını uygulamak için her zaman Threads veya ExecutorServices'i kullanabilirsiniz.

Yapabilirseniz, kullanıcının kaynağı oluşturmasına izin vermeyin. Kullanıcının, kaynağı oluşturacak olan yöntemine ziyaretçi nesnesini geçmesine, onu ziyaretçi nesnesinin yöntemine geçirmesine ve daha sonra serbest bırakmasına izin ver.

Benim fikrim Polygnome'unki ile benzerdi.

Sınıfınızdaki "do_something ()" yöntemlerine özel bir komut listesine komut eklemeniz yeterlidir. Ardından, işi gerçekten yapan ve "release ()" adında bir "commit ()" yöntemi kullanın.

Böylece, kullanıcı asla bir çağrı yapmazsa (), iş hiç bitmez. Onlar yaparsa, kaynaklar serbest bırakılır.

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

}

Daha sonra foo.doSomething.doSomethineElse (). Commit ();

Bahsedilenlerin bir diğer alternatifi, kapsüllenen kaynaklarınızı, çöp toplayıcısının kaynakları elle serbest bırakmadan otomatik olarak temizlemesini sağlayacak şekilde yönetmek için "akıllı referansların" kullanılmasıdır. Yararları elbette uygulamanıza bağlıdır. Bu harika blog yazısında bu konuyla ilgili daha fazla bilgi edinin : https://community.oracle.com/blogs/enicholas/2006/05/04/understanding-weak-references

Diğer herhangi bir Sınıf Odaklı dil için onu yıkıcıya koyarım derdim, ama bu bir seçenek olmadığından sonlandırma yöntemini geçersiz kılabileceğinizi düşünüyorum. Bu durumda, örnek kapsam dışına çıktığında ve çöp toplandığında, serbest bırakılacaktır.

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

Java'ya pek aşina değilim, ancak finalize () hedefinin amacı bu olduğunu düşünüyorum.

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