เมื่อใดที่ฉันควรใช้ Lazy <T>

ฉันพบบทความนี้เกี่ยวกับLazy: ความเกียจคร้านใน C # 4.0 - Lazy

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

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

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

คุณควรพยายามหลีกเลี่ยงการใช้ Singletons แต่ถ้าคุณจำเป็นต้องLazy<T>ทำให้การใช้ singletons ที่ปลอดภัยต่อเธรดเป็นเรื่องขี้เกียจง่าย:

public sealed class Singleton
{
    // Because Singleton's constructor is private, we must explicitly
    // give the Lazy<Singleton> a delegate for creating the Singleton.
    static readonly Lazy<Singleton> instanceHolder =
        new Lazy<Singleton>(() => new Singleton());

    Singleton()
    {
        // Explicit private constructor to prevent default public constructor.
        ...
    }

    public static Singleton Instance => instanceHolder.Value;
}

ตัวอย่างจริงของโลกที่มีการโหลดแบบขี้เกียจมีประโยชน์กับ ORM (Object Relation Mappers) เช่น Entity Framework และ NHibernate

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

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

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

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

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

จากMSDN Lazy <T> คลาส

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

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

ลักษณะ

สำหรับกรณีของฉันฉันสนใจเป็นพิเศษเพื่อดูว่า Lazy Properties สามารถช่วยปรับปรุงส่วนของรหัสของฉันที่ทำการแก้ไขจำนวนมาก (ส่วนใหญ่ไม่ได้ใช้งาน) และดังนั้นฉันจึงได้สร้างการทดสอบที่เปรียบเทียบ 3 แนวทาง

ฉันสร้างคลาสการทดสอบแยกต่างหากพร้อมด้วยคุณสมบัติการทดสอบ 20 รายการ (ให้เรียกว่าคุณสมบัติที) สำหรับแต่ละวิธี

• คลาส GetInterp: ทำการแก้ไขเชิงเส้นทุกครั้งที่มีคุณสมบัติ t
• คลาส InitInterp:เริ่มต้นคุณสมบัติ t โดยเรียกใช้การแก้ไขเชิงเส้นสำหรับแต่ละรายการในตัวสร้าง รับเพียงแค่ส่งกลับสองครั้ง
• InitLazy Class:ตั้งค่าคุณสมบัติ t- เป็นคุณสมบัติ Lazy เพื่อให้การแก้ไขเชิงเส้นทำงานครั้งเดียวเมื่อคุณสมบัติได้รับครั้งแรก การได้รับครั้งต่อมาควรจะคืนค่า double ที่คำนวณแล้ว

ผลการทดสอบวัดเป็นมิลลิวินาทีและมีค่าเฉลี่ย 50 อินสแตนซ์หรือ 20 คุณสมบัติที่ได้รับ การทดสอบแต่ละครั้งจะทำงาน 5 ครั้ง

ทดสอบผลลัพธ์ 1:อินสแตนซ์ (เฉลี่ย 50 instantiations)

Class      1        2        3        4        5        Avg       %
------------------------------------------------------------------------
GetInterp  0.005668 0.005722 0.006704 0.006652 0.005572 0.0060636 6.72
InitInterp 0.08481  0.084908 0.099328 0.098626 0.083774 0.0902892 100.00
InitLazy   0.058436 0.05891  0.068046 0.068108 0.060648 0.0628296 69.59

ทดสอบผลลัพธ์ 2: รับครั้งแรก (โดยเฉลี่ย 20 คุณสมบัติได้รับ)

Class      1        2        3        4        5        Avg       %
------------------------------------------------------------------------
GetInterp  0.263    0.268725 0.31373  0.263745 0.279675 0.277775 54.38
InitInterp 0.16316  0.161845 0.18675  0.163535 0.173625 0.169783 33.24
InitLazy   0.46932  0.55299  0.54726  0.47878  0.505635 0.510797 100.00

ทดสอบ 3 ผลลัพธ์: รับครั้งที่สอง (โดยเฉลี่ย 20 คุณสมบัติได้รับ)

Class      1        2        3        4        5        Avg       %
------------------------------------------------------------------------
GetInterp  0.08184  0.129325 0.112035 0.097575 0.098695 0.103894 85.30
InitInterp 0.102755 0.128865 0.111335 0.10137  0.106045 0.110074 90.37
InitLazy   0.19603  0.105715 0.107975 0.10034  0.098935 0.121799 100.00

ข้อสังเกต

GetInterpเร็วที่สุดในการยกตัวอย่างตามที่คาดไว้เพราะมันไม่ได้ทำอะไรเลย InitLazyเร็วกว่า instantiate กว่าInitInterpแนะนำว่าค่าใช้จ่ายในการตั้งค่าคุณสมบัติขี้เกียจนั้นเร็วกว่าการคำนวณการแก้ไขเชิงเส้น อย่างไรก็ตามฉันสับสนเล็กน้อยที่นี่เพราะInitInterpควรทำการประมาณ 20 เชิงเส้น (เพื่อตั้งค่าเป็นคุณสมบัติ t) แต่ใช้เวลาเพียง 0.09 ms ในการสร้างอินสแตนซ์ (ทดสอบ 1) เมื่อเทียบกับGetInterpที่ใช้เวลา 0.28 มิลลิวินาทีในการแก้ไขเชิงเส้นเดียว ครั้งแรก (ทดสอบ 2) และ 0.1 ms เพื่อทำครั้งที่สอง (ทดสอบ 3)

ใช้InitLazyเวลานานกว่า 2 เท่าGetInterpในการรับคุณสมบัติเป็นครั้งแรกในขณะInitInterpที่เร็วที่สุดเนื่องจากมีคุณสมบัติในระหว่างการสร้างอินสแตนซ์ (อย่างน้อยนั่นคือสิ่งที่ควรทำ แต่ทำไมผลของอินสแตนซ์นั้นเร็วกว่าการสอดแทรกเชิงเส้นเดี่ยวมาก?

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

สรุปผลการวิจัย

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

เพียงชี้ไปที่ตัวอย่างที่โพสต์โดยแม็ตธิว

public sealed class Singleton
{
    // Because Singleton's constructor is private, we must explicitly
    // give the Lazy<Singleton> a delegate for creating the Singleton.
    private static readonly Lazy<Singleton> instanceHolder =
        new Lazy<Singleton>(() => new Singleton());

    private Singleton()
    {
        ...
    }

    public static Singleton Instance
    {
        get { return instanceHolder.Value; }
    }
}

ก่อนที่ Lazy จะเกิดเราจะทำแบบนี้:

private static object lockingObject = new object();
public static LazySample InstanceCreation()
{
    if(lazilyInitObject == null)
    {
         lock (lockingObject)
         {
              if(lazilyInitObject == null)
              {
                   lazilyInitObject = new LazySample ();
              }
         }
    }
    return lazilyInitObject ;
}

จาก MSDN:

ใช้อินสแตนซ์ของ Lazy เพื่อเลื่อนการสร้างวัตถุที่มีขนาดใหญ่หรือใช้ทรัพยากรมากหรือการดำเนินการของงานที่ใช้ทรัพยากรมากโดยเฉพาะอย่างยิ่งเมื่อการสร้างหรือการดำเนินการดังกล่าวอาจไม่เกิดขึ้นในช่วงอายุการใช้งานของโปรแกรม

นอกจากคำตอบของ James Michael Hare แล้ว Lazy ยังให้การกำหนดค่าเริ่มต้นที่ปลอดภัยสำหรับเธรดของคุณ ลองดูที่การแจงนับLazyThreadSafetyModeรายการ MSDN ที่อธิบายถึงโหมดความปลอดภัยของเธรดประเภทต่างๆสำหรับคลาสนี้

คุณควรดูตัวอย่างนี้เพื่อทำความเข้าใจกับสถาปัตยกรรม Lazy Loading

private readonly Lazy<List<int>> list = new Lazy<List<int>>(() =>
{
    List<int> configList = new List<int>(Thread.CurrentThread.ManagedThreadId);
    return configList;
});
public void Execute()
{
    list.Value.Add(0);
    if (list.IsValueCreated)
    {
        list.Value.Add(1);
        list.Value.Add(2);

        foreach (var item in list.Value)
        {
            Console.WriteLine(item);
        }
    }
    else
    {
        Console.WriteLine("Value not created");
    }
}

-> เอาต์พุต -> 0 1 2

แต่ถ้ารหัสนี้ไม่ได้เขียน "list.Value.Add (0);"

เอาท์พุท -> ค่าไม่ได้สร้าง