[C#] 언제 Lazy <T>를 사용해야합니까?

Lazy<T>내 코드의 성능을 향상시키고 약간 더 배우기 위해 속성 사용을 고려하고 있습니다. 나는 그것을 언제 사용 해야하는지에 대한 답을 찾기 위해 여기에 왔지만 어디를 가든지 다음과 같은 문구가있는 것 같습니다.

지연 초기화를 사용하여 특히 프로그램 수명 기간 동안 이러한 생성 또는 실행이 발생하지 않을 때 큰 또는 리소스 집약적 인 개체 생성 또는 리소스 집약적 작업 실행을 연기하십시오.

에서 MSDN 게으른 <T> 클래스

선을 그릴 위치가 확실하지 않기 때문에 약간 혼란스러워합니다. 예를 들어 선형 보간법을 상당히 빠른 계산으로 생각하지만 필요하지 않으면 지연 초기화를 수행하지 않아도 가치가 있습니까?

결국 나는 내 자신의 테스트를 시도하기로 결정했고 여기에서 결과를 공유 할 것이라고 생각했습니다. 불행히도 나는 이런 종류의 테스트를 수행하는 전문가가 아니므로 개선을 제안하는 의견을 기쁘게 생각합니다.

기술

필자의 경우 Lazy Properties가 많은 보간을 수행하는 코드의 일부를 개선하는 데 도움이되는지 (특히 대부분 사용되지 않음) 관심이 있었으므로 3 가지 접근법을 비교하는 테스트를 만들었습니다.

각 접근 방식마다 20 개의 테스트 속성 (t 속성이라고 함)으로 별도의 테스트 클래스를 만들었습니다.

• GetInterp 클래스 : t 속성을 얻을 때마다 선형 보간을 실행합니다.
• InitInterp 클래스 : 생성자에서 각각에 대한 선형 보간을 실행하여 t- 속성을 초기화합니다. get은 단지 double을 반환합니다.
• InitLazy 클래스 : 속성을 처음 가져올 때 선형 보간이 한 번 실행되도록 t 속성을 지연 속성으로 설정합니다. 후속 Get은 이미 계산 된 Double을 반환해야합니다.

테스트 결과는 ms 단위로 측정되며 평균 50 개의 인스턴스화 또는 20 개의 속성 가져 오기입니다. 그런 다음 각 테스트를 5 회 실행했습니다.

테스트 1 결과 : 인스턴스화 (평균 50 개 인스턴스화)

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것을 InitInterp제안하는 것보다 인스턴스화 하는 것이 더 빠릅니다. 그러나 InitInterp20 개의 선형 보간을 수행해야 하기 때문에 (t 속성을 설정해야 함) 여기에서 약간 혼란 스럽지만 인스턴스화 (테스트 1) GetInterp하는 데 0.09ms 만 걸리는 반면 한 번의 선형 보간을 수행하는 데 0.28ms가 소요됩니다 첫 번째 (테스트 2), 두 번째 (테스트 3)에는 0.1ms입니다.

처음 속성을 얻는 InitLazy것보다 거의 2 배 더 오래 걸리며 인스턴스화하는 동안 속성을 채웠기 때문에 가장 빠릅니다. (적어도 그것이해야 할 일이지만 왜 단일 선형 보간보다 인스턴스화 결과가 훨씬 빠릅니까? 정확히 언제 보간을 수행합니까?)GetInterpInitInterp

불행히도 테스트에서 자동 코드 최적화가 진행되는 것처럼 보입니다. GetInterp두 번째와 마찬가지로 처음으로 속성을 얻는 데는 시간이 걸리지 만 2 배 이상 빠릅니다. 이 최적화는 다른 클래스에도 영향을 미치는 것으로 보입니다. 모두 테스트 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; }
    }
}

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

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