如何使用 dotTrace 来诊断 netcore 应用的性能问题

最近在为 Newbe.Claptrap 作性能升级,所以将过程当中使用到的 dotTrace 软件的基础用法介绍给各位开发者。php

Newbe.Claptrap 是一个用于轻松应对并发问题的分布式开发框架。若是您是首次阅读本系列文章。建议能够先从本文末尾的入门文章开始了解。git

开篇摘要

dotTrace 是 Jetbrains 公司为 .net 应用提供的一款 profile 软件。有助于对于软件中的耗时函数和内存问题进行诊断分析。github

本篇,咱们将使用 Jetbrains 公司的 dotTrace 软件对一些已知的性能问题进行分析。从而使读者可以掌握使用该软件的基本技能。面试

过程当中咱们将搭配一些经典的面试问题进行演示,逐步解释该软件的使用。docker

这次示例使用的是 Rider 做为主要演示的 IDE。开发者也可使用 VS + Resharper 作出相同的效果。数据库

如何获取 dotTrace

dotTrace 是付费软件。目前只要购买 dotUltimate 及以上的许可证即可以直接使用该软件。编程

固然,该软件也包含试用版本,能够免费开启 7 天的试用时间。Jetbrains 的 IDE 购买满一年以上便可获取一个当前最新的永久使用版本。数组

或者也能够直接购买 Jetbrains 全家桶许可证,一次性所有带走。服务器

经典场景再现

接下来,咱们经过一些经典的面试问题,来体验一下如何使用 dotTrace。并发

什么时候要使用 StringBuilder

这是多么经典的面试问题。可以看到这篇文章的朋友,我相信各位都知道 StringBuilder 可以减小 string 直接拼接的碎片,减小内存压力这个道理。

咱们这是真的吗?会不会只是面试官想要刁难我,欺负我信息不对称呢?

没有关系,接下来,让咱们使用 dotTrace 来具体的结合代码来分析一波。看看使用 StringBuilder 究竟有没有减低内存分配的压力。

首先,咱们建立一个单元测试项目,并添加如下这样一个测试类:

using System.Linq;
using System.Text;
using NUnit.Framework;

namespace Newbe.DotTrace.Tests
{
    public class X01StringBuilderTest
    {
        [Test]
        public void UsingString()
        {
            var source = Enumerable.Range(0, 10)
                .Select(x => x.ToString())
                .ToArray();
            var re = string.Empty;
            for (int i = 0; i < 10_000; i++)
            {
                re += source[i % 10];
            }
        }

        [Test]
        public void UsingStringBuilder()
        {
            var source = Enumerable.Range(0, 10)
                .Select(x => x.ToString())
                .ToArray();
            var sb = new StringBuilder();
            for (var i = 0; i < 10_000; i++)
            {
                sb.Append(source[i % 10]);
            }

            var _ = sb.ToString();
        }
    }
}

而后,以下图所示,咱们将 Rider 中的 profile 模式设置为 Timeline 。

TimeLine 是多种模式中的一种,相较而言,该模式能够更全面的了解各个线程的工做状况,包括有内存分配、IO 处理、锁、反射等等多维度数据。这将会做为本示例主要使用的一种模式。

接着,以下图所示,经过单元测试左侧的小图标启动对应测试的 profile。

启动 profile 以后,等待一段时间以后,便会出现最新生成的 timeline 报告。查看报告的位置以下所示:

右键选择对应的报告,选择”Open in External Viewer”,即可以使用 dotTrace 打开生成好的报告。

那么首先,让我打开第一个报告,查看 UsingString 方法生成的报告。

以下图所示,选择 .Net Memory Allocations 以查看该测试运行过程当中分配的内存数额。

根据上图咱们能够得出如下结论:

  1. 在这测试中,有 102M 的内存被分配给 String 。注意,在 dotTrace 中显示的分配是指整个运行过程当中所有分配的内存。即便后续被回收,该数值也不会减小。

  2. 内存的分配只要在 CLR Worker 线程进行。而且很是的密集。

Tip:Timeline 所显示的运行时间比正常运行测试的时间更长,由于在 profile 过程当中须要对数据进行记录会有额外的消耗。

所以,咱们就得出了第一个结论:使用 string 进行直接拼接,确实会消耗更多的内存分配。

接着,咱们继续按照上面的步骤,查看一下 UsingStringBuilder 方法的报告,以下所示:

根据上图,咱们能够得出第二个结论:使用 StringBuilder 能够明显的减小相较于 string 直接拼接所消耗的内存。

固然,咱们获得的最终的结论实际上是:看来面试官不是糊弄人。

class 和 struct 对内存有什么影响

class 和 struct 的区别有不少,面试题常客了。其中,二者在内存方面就存在区别。

那么咱们经过一个测试来看看区别。

using System;
using System.Collections.Generic;
using NUnit.Framework;

namespace Newbe.DotTrace.Tests
{
    public class X02ClassAndStruct
    {
        [Test]
        public void UsingClass()
        {
            Console.WriteLine($"memory in bytes before execution: {GC.GetGCMemoryInfo().TotalAvailableMemoryBytes}");
            const int count = 1_000_000;
            var list = new List<Student>(count);
            for (var i = 0; i < count; i++)
            {
                list.Add(new Student
                {
                    Level = int.MinValue
                });
            }

            list.Clear();

            var gcMemoryInfo = GC.GetGCMemoryInfo();
            Console.WriteLine($"heap size: {gcMemoryInfo.HeapSizeBytes}");
            Console.WriteLine($"memory in bytes end of execution: {gcMemoryInfo.TotalAvailableMemoryBytes}");
        }

        [Test]
        public void UsingStruct()
        {
            Console.WriteLine($"memory in bytes before execution: {GC.GetGCMemoryInfo().TotalAvailableMemoryBytes}");
            const int count = 1_000_000;
            var list = new List<Yueluo>(count);
            for (var i = 0; i < count; i++)
            {
                list.Add(new Yueluo
                {
                    Level = int.MinValue
                });
            }

            list.Clear();

            var gcMemoryInfo = GC.GetGCMemoryInfo();
            Console.WriteLine($"heap size: {gcMemoryInfo.HeapSizeBytes}");
            Console.WriteLine($"memory in bytes end of execution: {gcMemoryInfo.TotalAvailableMemoryBytes}");
        }

        public class Student
        {
            public int Level { get; set; }
        }

        public struct Yueluo
        {
            public int Level { get; set; }
        }
    }
}

代码要点:

  1. 两个测试,分别建立 1,000,000 个 class 和 struct 加入到 List 中。

  2. 运行测试以后,在测试的末尾输出当前堆空间的大小。

按照上一节提供的基础步骤,咱们对比两个方法生成的报告。

UsingClass

UsingStruct

对比两个报告,能够得出如下这些结论:

  1. Timeline 报告中的内存分配,只包含分配在堆上的内存状况。

  2. struct 不须要分配在堆上,可是,数组是引用对象,须要分配在堆上。

  3. List 自增的过程本质是扩张数组的特性在报告中也获得了体现。

  4. 另外,没有展现在报告上,而展现在测试打印文本中能够看到,UsingStruct 运行以后的堆大小也证明了 struct 不会被分配在堆上。

装箱和拆箱

经典面试题 X3,来,上代码,上报告!

using NUnit.Framework;

namespace Newbe.DotTrace.Tests
{
    public class X03Boxing
    {
        [Test]
        public void Boxing()
        {
            for (int i = 0; i < 1_000_000; i++)
            {
                UseObject(i);
            }
        }

        [Test]
        public void NoBoxing()
        {
            for (int i = 0; i < 1_000_000; i++)
            {
                UseInt(i);
            }
        }

        public static void UseInt(int age)
        {
            // nothing
        }

        public static void UseObject(object obj)
        {
            // nothing
        }
    }
}

Boxing, 发生装箱拆箱

NoBoxing,未发生装箱拆箱

对比两个报告,能够得出如下这些结论:

  1. 没有买卖就没有杀害,没有装拆就没有分配消耗。

Thread.Sleep 和 Task.Delay 有什么区别

经典面试题 X4,来,上代码,上报告!

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using NUnit.Framework;

namespace Newbe.DotTrace.Tests
{
    public class X04SleepTest
    {
        [Test]
        public Task TaskDelay()
        {
            return Task.Delay(TimeSpan.FromSeconds(3));
        }

        [Test]
        public Task ThreadSleep()
        {
            return Task.Run(() => { Thread.Sleep(TimeSpan.FromSeconds(3)); });
        }
    }
}

ThreadSleep

TaskDelay

对比两个报告,能够得出如下这些结论:

  1. 在 dotTrace 中 Thread.Sleep 会被单独标记,由于这是一种性能不不佳的作法,容易形成线程饥饿。

  2. Thread.Sleep 比起 Task.Delay 会多出一个线程处于 Sleep 状态

阻塞大量的 Task 真的会致使应用一动不动吗

有了上一步的结论,笔者产生了一个大胆的想法。咱们都知道线程的有限的,那若是启动很是多的 Thread.Sleep 或者 Task.Delay 会如何呢?

来,代码:

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using NUnit.Framework;

namespace Newbe.DotTrace.Tests
{
    public class X04SleepTest
    {

        [Test]
        public Task RunThreadSleep()
        {
            return Task.WhenAny(GetTasks(50));

            IEnumerable<Task> GetTasks(int count)
            {
                for (int i = 0; i < count; i++)
                {
                    var i1 = i;
                    yield return Task.Run(() =>
                    {
                        Console.WriteLine($"Task {i1}");
                        Thread.Sleep(int.MaxValue);
                    });
                }

                yield return Task.Run(() => { Console.WriteLine("yueluo is the only one dalao"); });
            }
        }

        [Test]
        public Task RunTaskDelay()
        {
            return Task.WhenAny(GetTasks(50));

            IEnumerable<Task> GetTasks(int count)
            {
                for (int i = 0; i < count; i++)
                {
                    var i1 = i;
                    yield return Task.Run(() =>
                    {
                        Console.WriteLine($"Task {i1}");
                        return Task.Delay(TimeSpan.FromSeconds(int.MaxValue));
                    });
                }

                yield return Task.Run(() => { Console.WriteLine("yueluo is the only one dalao"); });
            }
        }
    }
}

这里就不贴报告了,读者能够试一下这个测试,也能够将报告的内容写在本文的评论中参与讨论~

反射调用和表达式树编译调用

有时,咱们须要动态调用一个方法。最广为人知的方式就是使用反射。

可是,这也是广为人知的耗时相对较高的方式。

这里,笔者提供一种使用表达式树建立委托来取代反射提升效率的思路。

那么,究竟有没有减小时间消耗呢?好报告,本身会说话。

using System;
using System.Diagnostics;
using System.Linq.Expressions;
using NUnit.Framework;

namespace Newbe.DotTrace.Tests
{
    public class X05ReflectionTest
    {
        [Test]
        public void RunReflection()
        {
            var methodInfo = GetType().GetMethod(nameof(MoYue));
            Debug.Assert(methodInfo != null, nameof(methodInfo) + " != null");
            for (int i = 0; i < 1_000_000; i++)
            {
                methodInfo.Invoke(null, null);
            }

            Console.WriteLine(_count);
        }

        [Test]
        public void RunExpression()
        {
            var methodInfo = GetType().GetMethod(nameof(MoYue));
            Debug.Assert(methodInfo != null, nameof(methodInfo) + " != null");
            var methodCallExpression = Expression.Call(methodInfo);
            var lambdaExpression = Expression.Lambda<Action>(methodCallExpression);
            var func = lambdaExpression.Compile();
            for (int i = 0; i < 1_000_000; i++)
            {
                func.Invoke();
            }

            Console.WriteLine(_count);
        }

        private static int _count = 0;

        public static void MoYue()
        {
            _count++;
        }
    }
}

RunReflection,直接使用反射调用。

RunExpression,使用表达式树编译一个委托。

本篇小结

使用 dotTrace 能够查看方法的内存和时间消耗。本篇所演示的内容只是其中很小的部分。开发者们能够尝试上手,大有裨益。

本篇内容中的示例代码,都可以在如下连接仓库中找到:

  • https://github.com/newbe36524/Newbe.Demo

  • https://gitee.com/yks/Newbe.Demo

最后可是最重要!

若是读者对该内容感兴趣,欢迎转发、评论、收藏文章以及项目。

最近做者正在构建以反应式Actor模式事件溯源为理论基础的一套服务端开发框架。但愿为开发者提供可以便于开发出 “分布式”、“可水平扩展”、“可测试性高” 的应用系统 ——Newbe.Claptrap

本篇文章是该框架的一篇技术选文,属于技术构成的一部分。

联系方式:

  • Github Issue

  • Gitee Issue

  • 公开邮箱 newbe-claptrap@googlegroups.com (发送到该邮箱的内容将被公开)

  • Gitter

  • QQ 群 610394020

您还能够查阅本系列的其余选文:

理论入门篇

  1. Newbe.Claptrap - 一套以 “事件溯源” 和 “Actor 模式” 做为基本理论的服务端开发框架

术语介绍篇

  1. Actor 模式

  2. 事件溯源(Event Sourcing)

  3. Claptrap

  4. Minion

  5. 事件 (Event)

  6. 状态 (State)

  7. 状态快照 (State Snapshot)

  8. Claptrap 设计图 (Claptrap Design)

  9. Claptrap 工厂 (Claptrap Factory)

  10. Claptrap Identity

  11. Claptrap Box

  12. Claptrap 生命周期(Claptrap Lifetime Scope)

  13. 序列化(Serialization)

实现入门篇

  1. Newbe.Claptrap 框架入门,第一步 —— 建立项目,实现简易购物车

  2. Newbe.Claptrap 框架入门,第二步 —— 简单业务,清空购物车

  3. Newbe.Claptrap 框架入门,第三步 —— 定义 Claptrap,管理商品库存

  4. Newbe.Claptrap 框架入门,第四步 —— 利用 Minion,商品下单

样例实践篇

  1. 构建一个简易的火车票售票系统,Newbe.Claptrap 框架用例,第一步 —— 业务分析

  2. 在线体验火车票售票系统

其余番外篇

  1. 谈反应式编程在服务端中的应用,数据库操做优化,从 20 秒到 0.5 秒

  2. 谈反应式编程在服务端中的应用,数据库操做优化,提速 Upsert

  3. 十万同时在线用户,须要多少内存?——Newbe.Claptrap 框架水平扩展实验

  4. docker-mcr 助您全速下载 dotnet 镜像

  5. 十多位全球技术专家,为你献上近十个小时的.Net 微服务介绍

  6. 年轻的樵夫哟,你掉的是这个免费 8 核 4G 公网服务器,仍是这个随时可用的 Docker 实验平台?

  7. 如何使用 dotTrace 来诊断 netcore 应用的性能问题

GitHub 项目地址:https://github.com/newbe36524/Newbe.Claptrap

Gitee 项目地址:https://gitee.com/yks/Newbe.Claptrap

您当前查看的是先行发布于 www.newbe.pro 上的博客文章,实际开发文档随版本而迭代。若要查看最新的开发文档,须要移步 claptrap.newbe.pro。

相关文章
相关标签/搜索