ในห้องสมุดใน Java 7 ฉันมีคลาสที่ให้บริการกับคลาสอื่น หลังจากสร้างอินสแตนซ์ของคลาสบริการนี้วิธีการหนึ่งในนั้นอาจถูกเรียกหลายครั้ง (ลองเรียกมันว่าdoWork()เมธอด) ดังนั้นฉันไม่ทราบว่าเมื่องานของคลาสบริการเสร็จสมบูรณ์

ปัญหาคือระดับบริการใช้วัตถุหนักและควรปล่อยพวกเขา ฉันตั้งค่าส่วนนี้ในวิธีการ (เรียกว่าrelease()) แต่ไม่รับประกันว่านักพัฒนารายอื่นจะใช้วิธีนี้

มีวิธีบังคับให้ผู้พัฒนารายอื่นเรียกใช้วิธีนี้หลังจากทำงานของคลาสบริการหรือไม่ แน่นอนฉันสามารถบันทึกได้ แต่ฉันต้องการบังคับพวกเขา

หมายเหตุ: ฉันไม่สามารถเรียกrelease()เมธอดในdoWork()เมธอดได้เนื่องจากdoWork() ต้องการอ็อบเจ็กต์เหล่านั้นเมื่อมันถูกเรียกในครั้งถัดไป

วิธีแก้ปัญหาในทางปฏิบัติคือการทำให้ชั้นเรียนAutoCloseableและจัดให้มีfinalize()วิธีการหนุนหลัง (ถ้าเหมาะสม ... ดูด้านล่าง!) จากนั้นคุณต้องพึ่งพาผู้ใช้ในชั้นเรียนของคุณเพื่อใช้ลองกับทรัพยากรหรือโทรclose()อย่างชัดเจน

แน่นอนฉันสามารถบันทึกได้ แต่ฉันต้องการบังคับพวกเขา

แต่น่าเสียดายที่ไม่มีวิธีที่¹ใน Java เพื่อบังคับให้โปรแกรมเมอร์ทำสิ่งที่ถูกต้อง สิ่งที่ดีที่สุดที่คุณสามารถทำได้คือรับการใช้งานที่ไม่ถูกต้องในเครื่องวิเคราะห์รหัสแบบคงที่

ในหัวข้อของ finalizers คุณลักษณะ Java นี้มีกรณีการใช้งานที่ดีน้อยมาก หากคุณพึ่งพา finalizers เป็นระเบียบคุณพบปัญหาที่อาจใช้เวลานานมากสำหรับการเป็นระเบียบเรียบร้อยเกิดขึ้น Finalizer จะทำงานหลังจาก GC ตัดสินใจว่าวัตถุนั้นไม่สามารถเข้าถึงได้อีกต่อไป สิ่งนี้อาจไม่เกิดขึ้นจนกว่า JVM จะทำการรวบรวมเต็มรูปแบบ

ดังนั้นหากปัญหาที่คุณคาดว่าจะแก้คือการเรียกคืนทรัพยากรที่จำเป็นต้องได้รับการปล่อยตัวก่อนกำหนดจากนั้นคุณจะพลาดเรือลำนั้นโดยใช้การสรุป

และในกรณีที่คุณไม่ได้รับสิ่งที่ฉันพูดข้างต้น ... มันเกือบจะไม่เหมาะสมที่จะใช้ finalizers ในรหัสการผลิตและคุณไม่ควรพึ่งพาพวกเขา!

^{1 - มีหลายวิธี หากคุณกำลังเตรียมที่จะ "ซ่อน" บริการวัตถุจากรหัสผู้ใช้หรือแน่นควบคุมวงจรชีวิตของพวกเขา (เช่นhttps://softwareengineering.stackexchange.com/a/345100/172 ) แล้วรหัสผู้ใช้ไม่จำเป็นต้องมีrelease()การเรียกร้อง อย่างไรก็ตาม API มีความซับซ้อน จำกัด ... และ IMO "น่าเกลียด" มากขึ้น นอกจากนี้ไม่ได้ถูกบังคับให้โปรแกรมเมอร์ที่จะทำสิ่งที่ถูกต้อง เป็นการลบความสามารถของโปรแกรมเมอร์ในการทำสิ่งที่ผิด!}

ดูเหมือนว่าจะเป็นกรณีใช้งานสำหรับAutoCloseableอินเทอร์เฟซและtry-with-resourcesคำสั่งที่นำมาใช้ใน Java 7 หากคุณมีสิ่งที่ชอบ

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

ฉันไม่แนะนำเส้นทางนี้ตั้งแต่แรกเพราะมันน่าเกลียดหากไม่มี lambdas Java-8 และส่วนต่อประสานการใช้งาน ( MyServiceConsumerกลายเป็นที่ไหนConsumer<MyService>) และมันค่อนข้างน่าประทับใจสำหรับผู้บริโภคของคุณ แต่ถ้าสิ่งที่คุณต้องการคือrelease()ต้องได้รับการเรียกมันจะได้ผล

ใช่คุณสามารถ

คุณสามารถบังคับให้พวกเขาปล่อยและทำให้เป็นไปไม่ได้ 100% ที่จะลืมโดยทำให้เป็นไปไม่ได้ที่พวกเขาจะสร้างServiceอินสแตนซ์ใหม่

หากพวกเขาทำอะไรแบบนี้มาก่อน:

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

คุณสามารถสร้างความซับซ้อนได้ตามใจชอบโดยการปฏิบัติตามคำมั่นสัญญาสำหรับงานที่ต้องพึ่งพางานอื่น แต่การปล่อยสิ่งต่าง ๆ ก็มีความซับซ้อนมากขึ้น นี่เป็นเพียงจุดเริ่มต้น

async

ดังที่มีการระบุไว้ในความคิดเห็นข้างต้นไม่ได้ทำงานกับคำขอแบบอะซิงโครนัส ถูกต้อง. แต่สิ่งนี้สามารถแก้ไขได้อย่างง่ายดายใน Java 8 ด้วยการใช้CompleteableFutureโดยเฉพาะอย่างยิ่งCompleteableFuture#supplyAsyncเพื่อสร้างฟิวเจอร์สรายบุคคลและCompleteableFuture#allOfเพื่อปล่อยทรัพยากรให้สมบูรณ์เมื่องานทั้งหมดเสร็จสิ้น อีกวิธีหนึ่งสามารถใช้เธรดหรือ ExecutorServices เพื่อหมุนการใช้งานฟิวเจอร์ส / สัญญาของตัวเอง

หากคุณสามารถทำได้อย่าอนุญาตให้ผู้ใช้สร้างทรัพยากร ให้ผู้ใช้ส่งต่อวัตถุผู้เยี่ยมชมไปยังวิธีการของคุณซึ่งจะสร้างทรัพยากรส่งต่อไปยังวิธีการของวัตถุผู้เข้าชมแล้วปล่อยหลังจากนั้น

ความคิดของฉันคล้ายกับของ Polygnome

คุณสามารถมีวิธีการ "do_something ()" ในชั้นเรียนของคุณเพียงแค่เพิ่มคำสั่งลงในรายการคำสั่งส่วนตัว จากนั้นมีเมธอด "commit ()" ที่ใช้งานได้จริงและเรียกว่า "release ()"

ดังนั้นหากผู้ใช้ไม่เคยเรียกคอมมิท () ผลงานก็จะไม่ถูกดำเนินการ หากพวกเขาทำทรัพยากรที่เป็นอิสระ

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

สำหรับภาษา Class Oriented อื่น ๆ ฉันจะบอกว่าวางไว้ใน destructor แต่เนื่องจากนั่นไม่ใช่ตัวเลือกฉันคิดว่าคุณสามารถแทนที่วิธีสุดท้ายได้ ด้วยวิธีนี้เมื่ออินสแตนซ์ออกจากขอบเขตและเก็บรวบรวมขยะจะถูกปล่อยออกมา

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

ฉันไม่คุ้นเคยกับ Java มากนัก แต่ฉันคิดว่านี่เป็นจุดประสงค์ที่จะทำการสรุป ()

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