ราคาแพงในที่สุดก็ลอง

ในกรณีของรหัสที่คุณต้องทำการล้างทรัพยากรก่อนออกจากฟังก์ชันมีความแตกต่างที่สำคัญระหว่าง 2 วิธีในการทำมัน

1. การทำความสะอาดทรัพยากรก่อนทุกคำสั่งส่งคืน

   void func()
   {
       login();
   
       bool ret = dosomething();
       if(ret == false)
       {
           logout();
           return;
       }
   
       ret = dosomethingelse();
       if(ret == false)
       {
           logout();
           return;
       }
   
       dootherstuff();
   
       logout();
   }

2. การทำความสะอาดทรัพยากรในบล็อกสุดท้าย

   void func()
   {
       login();
   
       try
       {
           bool ret = dosomething();
           if(ret == false)
               return;
   
           ret = dosomethingelse();
           if(ret == false)
               return;
   
           dootherstuff();
   
       }
       finally
       {
           logout();
       }
   }

ฉันทำการทดสอบขั้นพื้นฐานในโปรแกรมตัวอย่างและดูเหมือนจะไม่แตกต่างกันมากนัก ฉันชอบfinallyวิธีการทำแบบนี้มาก - แต่ฉันสงสัยว่ามันจะทำให้เกิดผลงานใด ๆ ในโครงการขนาดใหญ่หรือไม่

ตามที่ระบุไว้ในข้อยกเว้น Java ช้าแค่ไหน? จะเห็นได้ว่าความtry {} catch {}เชื่องช้าของนั้นอยู่ภายในการสร้างสัญชาตญาณของข้อยกเว้นนั้นเอง

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

ในตัวอย่างที่ให้ไว้ในคำถามนี้ไม่มีข้อยกเว้นใครจะไม่คาดหวังว่าจะเกิดการชะลอตัว - พวกเขาไม่ได้ถูกสร้างขึ้น สิ่งที่อยู่ที่นี่คือการtry {} finally {}จัดการการจัดสรรทรัพยากรในบล็อกในที่สุด

ดังนั้นเพื่อตอบคำถามไม่ไม่มีค่าใช้จ่ายรันไทม์ที่แท้จริงภายในtry {} finally {}โครงสร้างที่ไม่ได้ใช้ข้อยกเว้น (มันไม่เคยได้ยินมาก่อน) อะไรคืออาจจะมีราคาแพงเวลาการบำรุงรักษาเมื่อใครอ่านรหัสและเห็นรูปแบบรหัสนี้ไม่ปกติและ coder มีเพื่อให้ได้ใจของพวกเขาไปรอบ ๆ สิ่งที่อื่นที่เกิดขึ้นในวิธีการนี้หลังจากที่returnก่อนจะกลับไปสายก่อน

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

พิจารณาเวลาการบำรุงรักษาของการสอนโครงสร้างภาษาใหม่ให้กับบางคน การเห็นtry {} finally {}ไม่ใช่สิ่งที่คนมักเห็นในโค้ด Java และอาจทำให้ผู้คนสับสน มีเวลาการบำรุงรักษาในระดับหนึ่งสำหรับการเรียนรู้โครงสร้างขั้นสูงใน Java มากกว่าสิ่งที่ผู้คนคุ้นเคย

finally {}บล็อกมักจะทำงาน และนี่คือเหตุผลที่คุณควรใช้มัน พิจารณาเวลาการบำรุงรักษาของการดีบักวิธีที่ไม่ใช่ขั้นสุดท้ายเมื่อบางคนลืมที่จะรวมการออกจากระบบในเวลาที่เหมาะสมหรือเรียกมันในเวลาที่ไม่เหมาะสม มีข้อบกพร่องที่เป็นไปได้มากมายด้วยสิ่งนี้ซึ่งการใช้try {} finally {}ทำให้เป็นไปไม่ได้

เมื่อชั่งน้ำหนักค่าใช้จ่ายทั้งสองนี้มันมีราคาแพงในเวลาการบำรุงรักษาที่จะไม่ใช้try {} finally {}วิธีการ ในขณะที่ผู้คนสามารถ dicker เกี่ยวกับจำนวนมิลลิวินาทีเศษส่วนหรือคำแนะนำ jvm เพิ่มเติมtry {} finally {}บล็อกเปรียบเทียบกับรุ่นอื่น ๆ หนึ่งต้องพิจารณาชั่วโมงที่ใช้ในการแก้จุดบกพร่องน้อยกว่าวิธีที่เหมาะในการจัดการการจัดสรรทรัพยากร

เขียนโค้ดที่สามารถบำรุงรักษาได้ก่อนและควรใช้วิธีที่จะป้องกันข้อผิดพลาดในการเขียนในภายหลัง

/programming/299068/how-slow-are-java-exceptions

คำตอบที่ได้รับการยอมรับสำหรับคำถามนี้แสดงให้เห็นถึงการตัดการเรียกใช้ฟังก์ชั่นในบล็อก catch catch block ที่มีค่าใช้จ่ายน้อยกว่า 5% จากการเรียกใช้ฟังก์ชันเปล่า การขว้างและจับข้อยกเว้นที่เกิดขึ้นจริงทำให้รันไทม์ไปบอลลูนมากกว่า 66x การเรียกฟังก์ชันเปล่า ดังนั้นหากคุณคาดหวังว่าการออกแบบข้อยกเว้นจะโยนเป็นประจำดังนั้นฉันจะพยายามหลีกเลี่ยงมัน (ในรหัสที่มีความสำคัญต่อประสิทธิภาพอย่างเหมาะสม) อย่างไรก็ตามหากสถานการณ์พิเศษนั้นหายากมันก็ไม่ใช่เรื่องใหญ่

แทนที่จะปรับให้เหมาะสม - ลองคิดดูว่ารหัสของคุณกำลังทำอะไรอยู่

การเพิ่มบล็อกสุดท้ายคือการใช้งานที่แตกต่างกัน - หมายความว่าคุณจะออกจากระบบทุกข้อยกเว้น

โดยเฉพาะ - หากการเข้าสู่ระบบเกิดข้อยกเว้นพฤติกรรมในฟังก์ชันที่สองของคุณจะแตกต่างจากครั้งแรกของคุณ

หากการเข้าสู่ระบบและออกจากระบบไม่ได้เป็นส่วนหนึ่งของพฤติกรรมการทำงานจริง ๆ แล้วฉันขอแนะนำให้วิธีการทำสิ่งหนึ่งและสิ่งหนึ่งที่ดี:

    void func()
    {
            bool ret = dosomething();
            if(ret == false)
                return;

            ret = dosomethingelse();
            if(ret == false)
                return;

            dootherstuff();

    }

และควรอยู่ในฟังก์ชั่นที่ได้รับการห่อหุ้มแล้วในบริบทที่จัดการเข้าสู่ระบบ / ออกจากระบบเนื่องจากสิ่งเหล่านี้ดูเหมือนจะแตกต่างจากสิ่งที่รหัสหลักของคุณกำลังทำอยู่

โพสต์ของคุณถูกแท็กเป็น Java ซึ่งฉันไม่คุ้นเคยเป็นพิเศษ แต่ใน. net ฉันจะใช้บล็อกการใช้สำหรับสิ่งนี้:

เช่น:

    using(var loginContext = CreateLoginContext()) 
    {
            // Do all your stuff
    }

และบริบทการเข้าสู่ระบบมีวิธีการกำจัดซึ่งจะออกจากระบบและทำความสะอาดทรัพยากร

แก้ไข: ฉันไม่ได้ตอบคำถามจริงๆ!

ฉันไม่มีหลักฐานที่สามารถวัดได้ แต่ฉันไม่คาดหวังว่าสิ่งนี้จะมีราคาแพงกว่าหรือแน่นอนไม่มากพอที่จะคุ้มค่ากับการเพิ่มประสิทธิภาพก่อนวัยอันควร

ฉันจะออกจากคำตอบที่เหลือเพราะแม้ว่าจะไม่ตอบคำถามฉันคิดว่ามันมีประโยชน์สำหรับ OP

ข้อสันนิษฐาน: คุณกำลังพัฒนาในรหัส C #

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

คำตอบอีกต่อไปคือการเห็นด้วยตนเอง หากคุณดูรหัส CIL ที่สร้างขึ้น ( เช่นตัวสะท้อนสัญญาณสีแดงคุณสามารถดูคำแนะนำ CIL พื้นฐานที่สร้างขึ้นและดูผลกระทบที่เกิดขึ้นได้

ดังที่คนอื่น ๆ ระบุไว้แล้วรหัส Ttese จะมีผลลัพธ์ที่แตกต่างกันหากมีdosomethingelseหรือdootherstuffมีข้อยกเว้น

และใช่การเรียกใช้ฟังก์ชันใด ๆสามารถทำให้เกิดข้อยกเว้นอย่างน้อยStackOVerflowError! แม้ว่าจะเป็นไปได้ยากที่จะจัดการกับสิ่งเหล่านี้อย่างถูกต้อง (เนื่องจากฟังก์ชันการล้างข้อมูลใด ๆ ที่เรียกว่าอาจมีปัญหาเดียวกันในบางกรณี (เช่นการใช้การล็อกตัวอย่าง) มันเป็นสิ่งสำคัญที่จะต้องจัดการอย่างถูกต้อง ...