Lazy Loading คืออะไร?

Lazy Loading คืออะไร?

[แก้ไขหลังจากอ่านไม่กี่คำตอบ] ทำไมคนถึงใช้คำนี้บ่อยจัง?

สมมติว่าคุณใช้ชุดระเบียน ASP / ADO และโหลดด้วย data หรือ ADO.NET Datasource สำหรับ gridview

ฉันเดาว่าฉันน่าจะถามว่าทำไมคนถึงใช้คำว่า Lazy Loading ประเภท "อื่น ๆ " คืออะไร?

เรียกว่าขี้เกียจโหลดเพราะเหมือนคนขี้เกียจคุณกำลังละทิ้งการทำสิ่งที่คุณไม่ต้องการ สิ่งที่ตรงกันข้ามคือ Eager Loading ที่คุณโหลดบางสิ่งได้ทันทีก่อนที่คุณจะต้องการมัน

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

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

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

ตามปกติวิกิพีเดียมีรายละเอียดเพิ่มเติม

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

ด้านล่างนี้เป็นวิดีโอ youtube ที่สาธิตวิธีใช้การโหลดแบบขี้เกียจวิธีที่เราสามารถใช้การโหลดแบบขี้เกียจและข้อดีและข้อเสียของสิ่งเดียวกัน

http://www.youtube.com/watch?v=2SrfdAkwmFo

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

http://en.wikipedia.org/wiki/Lazy%20loading

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

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

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

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

นี่คือตัวอย่างจากโค้ด Python จริงที่ฉันเขียน:

class Item(Model):
    ...
    @property
    def total(self):
        if not hasattr(self, "_total"):
            self._total = self.quantity \
                  + sum(bi.quantity for bi in self.borroweditem_set.all())
        return self._total

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

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

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

ตัวอย่างจากชีวิต: แทนที่จะเรียนรู้วลีภาษาฝรั่งเศสจริงๆคุณจะเรียนรู้วลีทีละประโยคตามที่จำเป็น เมื่อไหร่ที่จะเข้าใจ? หากคุณจะอยู่ในฝรั่งเศสเพียงช่วงเวลาสั้น ๆ (กล่าวคือคุณไม่จำเป็นต้องใช้วลีมากมาย) หรือหากคุณต้องการออกเดินทางในไม่ช้า หากคุณอยู่ที่นั่นเป็นเวลาสองปีและ / หรือมีเวลาในการศึกษาเป็นเวลานานอาจมีประสิทธิภาพมากกว่าที่จะเรียนรู้วลีทั้งหมดล่วงหน้า (การโหลดอย่างกระตือรือร้น)

[ได้รับแรงบันดาลใจจากAtom ที่สอนในรูปแบบแก๊งค์โดย Venus ใน WKRP ]

Lazy load เป็นคำที่ใช้บ่อยในฐานข้อมูลเพื่ออ้างถึงแนวคิดในการโหลดบางส่วนของข้อมูลที่ต้องการเมื่อจำเป็นเท่านั้น

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

'การโหลด' ประเภทอื่น ๆ คือ:

1. Eager Loading - โหลดตารางที่เชื่อมต่อทั้งหมดพร้อมกัน

เป็นรูปแบบการออกแบบ

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

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

ตัวอย่างการใช้งาน Lazy load:

Ghost Lazy initialization ผู้ถือค่า

ข้อดีบางประการของการโหลดแบบขี้เกียจ:

1. ลดเวลาเริ่มต้นของแอปพลิเคชัน
2. แอปพลิเคชันใช้หน่วยความจำน้อยลงเนื่องจากการโหลดตามความต้องการ
3. หลีกเลี่ยงคำขอที่ไม่จำเป็นไปยังเซิร์ฟเวอร์

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

นี่กำลังกลายเป็นรูปแบบการออกแบบภาพ / การโต้ตอบทั่วไปมากขึ้นเช่นกันผ่าน ajax หรือ jQuery

และตามที่กล่าวไว้ข้างต้นตรงกันข้ามจะกระตือรือร้นในการโหลดที่คุณไม่คำนึงถึงไคลเอนต์ดังนั้นจึงอาจมีผลงาน

Lazy<T>ตอนนี้เป็นส่วนหนึ่งของ c # 4.0 - มีเพจดีๆบนMSDNซึ่งอธิบายแนวคิดนี้

อ้างอิงจาก geeksforgeeks Lazy loading เป็นรูปแบบการออกแบบซอฟต์แวร์ที่การเริ่มต้นของออบเจ็กต์จะเกิดขึ้นเมื่อจำเป็นจริง ๆ เท่านั้นไม่ใช่ก่อนหน้านี้เพื่อรักษาความเรียบง่ายของการใช้งานและปรับปรุงประสิทธิภาพ

https://www.geeksforgeeks.org/lazy-loading-design-pattern/