มีประโยชน์ด้านประสิทธิภาพการใช้ไวยากรณ์อ้างอิงวิธีแทนไวยากรณ์แลมบ์ดาใน Java 8 หรือไม่

วิธีการอ้างอิงข้ามค่าใช้จ่ายของเสื้อคลุมแลมบ์ดา? พวกเขาอาจจะในอนาคตหรือไม่

อ้างอิงจากการสอนของ Java เกี่ยวกับวิธีการอ้างอิง :

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

ฉันชอบไวยากรณ์แลมบ์ดากับไวยากรณ์การอ้างอิงเมธอดด้วยเหตุผลหลายประการ:

แลมบ์ดานั้นชัดเจนขึ้น

แม้จะมีการอ้างสิทธิ์ของออราเคิล แต่ฉันพบว่าแลมบ์ดาไวยากรณ์นั้นง่ายต่อการอ่านมากกว่าการอ้างอิงวิธีการออบเจ็กต์สั้น ๆ เพราะไวยากรณ์การอ้างอิงเมธอดนั้นไม่ชัดเจน:

Bar::foo

คุณกำลังเรียกวิธีการหนึ่งอาร์กิวเมนต์คงที่ในชั้นเรียนของ x และผ่านมันได้หรือไม่

x -> Bar.foo(x)

หรือคุณกำลังเรียกวิธีการเป็นศูนย์อาร์กิวเมนต์บน x?

x -> x.foo()

ไวยากรณ์การอ้างอิงเมธอดสามารถยืนอยู่ได้ทั้งอันใดอันหนึ่ง มันซ่อนสิ่งที่รหัสของคุณกำลังทำอยู่

แลมบ์ดาปลอดภัยกว่า

หากคุณอ้างอิง Bar :: foo เป็นวิธีการเรียนและ Bar ภายหลังเพิ่มวิธีการตัวอย่างที่มีชื่อเดียวกัน (หรือในทางกลับกัน) รหัสของคุณจะไม่รวบรวมอีกต่อไป

คุณสามารถใช้ lambdas อย่างสม่ำเสมอ

คุณสามารถห่อฟังก์ชั่นใด ๆ ในแลมบ์ดา - เพื่อให้คุณสามารถใช้ไวยากรณ์เดียวกันได้ทุกที่ ไวยากรณ์การอ้างอิงเมธอดจะไม่ทำงานกับวิธีการที่ใช้หรือคืนค่าอาร์เรย์แบบดั้งเดิมโยนข้อยกเว้นที่ตรวจสอบหรือมีชื่อวิธีการเดียวกับที่ใช้เป็นอินสแตนซ์และวิธีการแบบสแตติก (เนื่องจากไวยากรณ์การอ้างอิงเมธอดนั้นไม่ชัดเจน . มันไม่ทำงานเมื่อคุณมีเมธอดมากเกินไปด้วยจำนวนอาร์กิวเมนต์ที่เท่ากัน แต่คุณไม่ควรทำเช่นนั้น (ดูรายการของ Josh Bloch ที่ 41) ดังนั้นเราจึงไม่สามารถระงับวิธีการดังกล่าวได้

ข้อสรุป

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

PS

ไม่ว่าที่นี่หรือที่นั่น แต่ในความฝันของฉันการอ้างอิงวิธีวัตถุมีลักษณะเช่นนี้มากขึ้นและใช้การเรียกใช้แบบไดนามิกกับวิธีการโดยตรงบนวัตถุโดยไม่มีตัวห่อหุ้มแลมบ์ดา:

_.foo()

ในหลาย ๆ สถานการณ์ฉันคิดว่าแลมบ์ดาและวิธีการอ้างอิงนั้นเทียบเท่ากัน แต่แลมบ์ดาจะห่อเป้าหมายการร้องขอตามประเภทอินเตอร์เฟสที่ประกาศไว้

ตัวอย่างเช่น

public class InvokeTest {

    private static void invoke(final Runnable r) {
        r.run();
    }

    private static void target() {
        new Exception().printStackTrace();
    }

    @Test
    public void lambda() throws Exception {
        invoke(() -> target());
    }

    @Test
    public void methodReference() throws Exception {
        invoke(InvokeTest::target);
    }
}

คุณจะเห็นคอนโซลเอาท์พุท stacktrace

ในlambda()การเรียกใช้เมธอดtarget()คือlambda$lambda$0(InvokeTest.java:20)ซึ่งมีข้อมูลบรรทัดที่สอบกลับได้ เห็นได้ชัดว่านั่นคือแลมบ์ดาที่คุณเขียนคอมไพเลอร์สร้างวิธีที่ไม่ระบุตัวตนสำหรับคุณ แล้วโทรของวิธีการแลมบ์ดาเป็นสิ่งที่ต้องการInvokeTest$$Lambda$2/1617791695.run(Unknown Source)นั่นคือinvokedynamicการโทรใน JVM ก็หมายความว่าสายจะเชื่อมโยงกับวิธีการสร้าง

ในmethodReference()โทรวิธีการที่target()จะโดยตรงInvokeTest$$Lambda$1/758529971.run(Unknown Source)ก็หมายความว่าการเรียกร้องมีการเชื่อมโยงโดยตรงกับInvokeTest::targetวิธีการ

ข้อสรุป

เหนือสิ่งอื่นใดเมื่อเปรียบเทียบกับการอ้างอิงเมธอดการใช้แลมบ์ดานิพจน์จะทำให้ การเรียกเมธอดอีกวิธีหนึ่งไปยังวิธีการสร้างจากแลมบ์ดาเท่านั้น

มันคือทั้งหมดที่เกี่ยวกับmetafactory

ขั้นแรกการอ้างอิงวิธีการส่วนใหญ่ไม่ต้องการ desugaring โดย lambda metafactory พวกเขาจะใช้เป็นวิธีการอ้างอิงเพียงอย่างเดียว ภายใต้หัวข้อ "บทความแลมบ์ดาฟ้องร้อง" ของบทความแปลแลมบ์ดานิพจน์ ("TLE"):

ทุกสิ่งเท่าเทียมกันวิธีส่วนตัวดีกว่าแบบ nonprivate วิธีแบบคงที่ดีกว่าวิธีแบบวิธีที่ดีที่สุดถ้าร่างกายแลมบ์ดาถูกเจาะเข้าไปในชั้นในสุดที่นิพจน์แลมบ์ดาปรากฏขึ้น อาร์กิวเมนต์ควรจะถูกเติมไว้ที่ด้านหน้าของรายการอาร์กิวเมนต์สำหรับค่าที่ดักจับและจะไม่อ้างถึงวิธี desugar เลย อย่างไรก็ตามมีกรณียกเว้นที่เราอาจต้องเบี่ยงเบนจากกลยุทธ์พื้นฐานนี้

นี่คือไฮไลต์เพิ่มเติมต่อไปใน "The Lambda Metafactory" ของ TLE:

metaFactory(MethodHandles.Lookup caller, // provided by VM
            String invokedName,          // provided by VM
            MethodType invokedType,      // provided by VM
            MethodHandle descriptor,     // lambda descriptor
            MethodHandle impl)           // lambda body

implอาร์กิวเมนต์ระบุวิธีการที่แลมบ์ดาทั้งร่างกายแลมบ์ดา desugared หรือวิธีการที่มีชื่อในการอ้างอิงวิธี

คงที่ ( Integer::sum) หรือวิธีการเช่นมากมาย ( Integer::intValue) อ้างอิงเป็น 'ง่าย' หรือมากที่สุด 'สะดวก' ในความรู้สึกที่ว่าพวกเขาสามารถจัดการได้อย่างเหมาะสมโดยเร็วเส้นทาง ' ตัวแปร metafactory โดยไม่ต้อง desugaring ข้อได้เปรียบนี้ชี้ให้เห็นอย่างเป็นประโยชน์ใน "ตัวแปร Metafactory" ของ TLE:

โดยการกำจัดข้อโต้แย้งที่พวกเขาไม่ต้องการ classfiles กลายเป็นเล็ก และตัวเลือกพา ธ ด่วนจะลดแถบสำหรับ VM เพื่อเพิ่มประสิทธิภาพการแปลงแลมบ์ดาทำให้สามารถใช้เป็น "มวย" และดำเนินการเพิ่มประสิทธิภาพ unbox ได้อย่างง่ายดาย

โดยปกติแล้วการอ้างอิงวิธีการจับภาพอินสแตนซ์ ( obj::myMethod) จำเป็นต้องจัดเตรียมอินสแตนซ์ที่ถูกผูกไว้เป็นอาร์กิวเมนต์สำหรับการจัดการเมธอดสำหรับการเรียกใช้ซึ่งอาจหมายถึงความต้องการในการแยกข้อมูลโดยใช้วิธีการ 'บริดจ์'

ข้อสรุป

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

มีสิ่งหนึ่งที่ค่อนข้างร้ายแรงเมื่อใช้แลมบ์ดานิพจน์ที่อาจส่งผลต่อประสิทธิภาพ

เมื่อคุณประกาศแลมบ์ดานิพจน์คุณกำลังสร้างการปิดขอบเขตท้องถิ่น

สิ่งนี้หมายความว่าอะไรและมีผลต่อประสิทธิภาพอย่างไร

ฉันดีใจที่คุณถาม นั่นหมายถึงว่าการแสดงออกแลมบ์ดาเล็ก ๆ น้อย ๆ นั้นเป็นคลาสภายในที่ไม่ระบุตัวตนเล็ก ๆ และนั่นหมายความว่ามันอ้างอิงกับตัวแปรทั้งหมดที่อยู่ในขอบเขตเดียวกันของการแสดงออกแลมบ์ดา

นี่หมายถึงthisการอ้างอิงของอินสแตนซ์ของวัตถุและเขตข้อมูลทั้งหมด ทั้งนี้ขึ้นอยู่กับช่วงเวลาของการภาวนาที่แท้จริงของแลมบ์ดาสิ่งนี้สามารถทำให้เกิดการรั่วไหลของทรัพยากรอย่างมีนัยสำคัญเนื่องจากตัวเก็บขยะไม่สามารถปล่อยการอ้างอิงเหล่านี้ได้ตราบใดที่วัตถุที่ถือครองแลมบ์ดายังมีชีวิตอยู่ ...