专栏首页GreenLeaves.Net 环境下比较各种数据库插入操作的性能

.Net 环境下比较各种数据库插入操作的性能

1、简介

再说Windows的异步I/O操作前,先聊聊一些题外话,能帮助我们更好的理解异步I/O操作,常规的Web程序,当用户发起一次请求,当请求通过管道到达客户端的这个过程,会唤起一个线程池线程(后台线程),处理我们的业务代码,即所有的用户请求是通过异步的方式发起的,这个过程,.Net Framework会自动进行,即使我们没有显示的通过代码来实现这个过程.所以这个过程明显是存在性能瓶颈的,假设现在有一个4核服务器,意味这该服务器同时只能处理4个用户请求(超理想情况下,一般不可能),但是这个时候来了10000个用户请求(并发执行)的情况下,那么意味者大量线程会堆积起来,等待着前面的线程执行完毕,同时进行频繁的上下文切换,这个时候你会发现CPU会爆表.

上面只是一个例子,再说一个数据库的例子,现在需要向数据库插入20000条记录,分为三个版本去实现,第一个版本是单个线程同步插入,第二个版本多线程同步插入(Parallel),第三个版本多线程异步插入,来比较下性能和CPU利用零及使用情况.

(1)、单线程同步版本

这个场景是只有一个用户请求进来,进行20000次的数据库插入操作,这个版本不会产生线程堆积,因为所有的插入操作都只由主线程完成.

        private static readonly string ConnectionStrings;
        static Program()
        {
            //配置数据库连接
             ConnectionStrings = ConfigurationManager.ConnectionStrings["connStr"].ConnectionString;
        }

        static void Main(string[] args)
        {

            var stop = Stopwatch.StartNew();
            InstertSync();
            stop.Stop();
            Console.WriteLine($"同步执行20000次插入操作,耗时:{stop.ElapsedMilliseconds/1000}秒");
            Console.ReadKey();
        }


        private static void InstertSync()
        {
            var totalCount = 0;
            var failCount = 0;

            //这里以同步方式执行数据库操作,注这里只有一个线程执行所有的数据库插入操作
            for (int i = 0; i <= 20000; i++)
            {
                var conn = new SqlConnection(ConnectionStrings);
                conn.Open();
                try
                {

                    //模拟数据库耗时操作
                    var sql = "insert into [dbo].[User]([Amount]) values (@Amount)";
                    var command = new SqlCommand(sql, conn);
                    command.Parameters.Add(
                        new SqlParameter("@Amount", i)
                    );
                    //这里线程会等待这一段时间,等待数据库返回结果,并继续执行下面的代码
                    var result = command.ExecuteNonQuery();
                    if (result == 1)
                    {
                        totalCount+=1;
                    }
                    else
                    {
                        failCount+=1;
                    }

                    Console.WriteLine($"成功插入{totalCount}条记录,插入失败{failCount}条记录");
                }
                catch (Exception ex)
                {

                    throw ex;
                }
                finally
                {
                    conn.Close();
                    conn.Dispose();
                }
            }
        }

再看看数据库的批请求数数据

大概稳定在300次左右每秒

(2)、多线程同步

这个场景是大多数没有使用Async Await模型的Web应用程序(Parallel代表同时有多个用户请求进来),同时数据库也使用的是同步Api,这个时候以同步的方式发起数据库请求,每个线程会等待不确定的时间,等待数据库返回结果,同时另一个线程开启,也会等待数据库返回结果,这样用户请求一多,就会产生大量的线程堆积,造成大量的内存浪费,而且当数据库开始响应线程时,线程会被唤醒,全部开始执行,这时候CPU又会开始繁忙的执行.

        private static readonly string ConnectionStrings;
        static Program()
        {
            //配置数据库连接
             ConnectionStrings = ConfigurationManager.ConnectionStrings["connStr"].ConnectionString;
        }

        static void Main(string[] args)
        {
            InsertAsync();
            Console.ReadKey();
        }

        private static void InsertAsync()
        {
            var stop = Stopwatch.StartNew();
            var totalCount = 0;
            var failCount = 0;
            var res = Parallel.For(0, 20000, i =>
            {
                var conn = new SqlConnection(ConnectionStrings);
                conn.Open();
                try
                {
                    //模拟数据库耗时操作
                    var sql = "insert into [dbo].[User]([Amount]) values (@Amount)";
                    var command = new SqlCommand(sql, conn);
                    command.Parameters.Add(
                        new SqlParameter("@Amount", i)
                    );
                    var result = command.ExecuteNonQuery();
                    if (result == 1)
                    {
                        Interlocked.Add(ref totalCount, 1);
                    }
                    else
                    {
                        Interlocked.Add(ref failCount, 1);
                    }

                    Console.WriteLine($"成功插入{totalCount}条记录,插入失败{failCount}条记录");
                }
                catch (Exception ex)
                {

                    throw ex;
                }
                finally
                {
                    conn.Close();
                    conn.Dispose();
                }
            });
            if (res.IsCompleted)
            {
                stop.Stop();
                Console.WriteLine($"同步执行20000次插入操作,耗时:{stop.ElapsedMilliseconds / 1000}秒");
            }
        }

去除Interlocked稍稍快一些.明显可以发现在多线程环境下,使用同步的数据库操作api,效率显著下降.CPU的利用率也很低,同时跑了很多操作线程,但数据库使用同步Api,只能响应一个线程,其余的都需要排队.

再看看数据库批请求数

只能稳定在130次左右,说明多线程环境下,使用同步数据库操作,阻碍了请求的提交速度.个人理解.

(3)、多线程异步

这个场景用户使用基于Async Await模型的Web程序,且使用数据库的异步Api

        private static readonly string ConnectionStrings;
        static Program()
        {
            //配置数据库连接
             ConnectionStrings = ConfigurationManager.ConnectionStrings["connStr"].ConnectionString;
        }

        static void Main(string[] args)
        {
            InsertAsync();
            Console.ReadKey();
        }

        private static void InsertAsync()
        {
            var stop = Stopwatch.StartNew();
            var totalCount = 0;
            var failCount = 0;
            var res = Parallel.For(0, 20000,async i =>
            {
                var conn = new SqlConnection(ConnectionStrings);
                conn.Open();
                try
                {

                    //模拟数据库耗时操作
                    var sql = "insert into [dbo].[User]([Amount]) values (@Amount)";
                    var command = new SqlCommand(sql, conn);
                    command.Parameters.Add(
                        new SqlParameter("@Amount", i)
                    );

                    var result =await command.ExecuteNonQueryAsync();
                    if (result == 1)
                    {
                        Interlocked.Add(ref totalCount, 1);
                    }
                    else
                    {
                        Interlocked.Add(ref failCount, 1);
                    }

                    Console.WriteLine($"成功插入");
                }
                catch (Exception ex)
                {

                    throw ex;
                }
                finally
                {
                    conn.Close();
                    conn.Dispose();
                }
            });
            if (res.IsCompleted)
            {
                stop.Stop();
                Console.WriteLine($"同步执行20000次插入操作,耗时:{stop.ElapsedMilliseconds / 1000}秒");
            }
        }

可以发现这个模式插入效率非常之高.但是它的插入是无序的,因为Parallel执行线程的顺序是无序的.CPU的利用率也是极高的.

再看看数据库批请求数

直线飙升>1000次的请求提交,说明使用异步Api数据库每秒接收的请求数,远大于同步方式,也是使用异步Api如此之快的原因.

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • C# 多线程六之Task(任务)三之任务工厂

    前面两篇关于Task的随笔,C# 多线程五之Task(任务)一 和 C# 多线程六之Task(任务)二,介绍了关于Task的一些基本的用法,以及一些使用的要点,...

    郑小超.
  • Jquery $.extend的重载方法详述

    1 $.extend(result,item1,item2,item3,........)  -这个重载方法主要是用来合并,将所有的参数都合并到result中,...

    郑小超.
  • CLR关于语言文化的类型一CultureInfo类和字符串与线程的关联

    郑小超.
  • SAP ADBC和JDBC的对比

    https://blogs.sap.com/2017/05/08/adbc-and-jdbc/

    Jerry Wang
  • .NET Core教程--给API加一个服务端缓存啦

    在.NET Core Web API这里的话, 两种思路:Middleware 或者ActionFilter.

    李国宝
  • ECMAScript简介以及es6新增语法

    人生不如戏
  • 聊聊artemis的connectionTtlCheckInterval

    本文主要研究一下artemis的connectionTtlCheckInterval

    codecraft
  • 聊聊artemis的connectionTtlCheckInterval

    本文主要研究一下artemis的connectionTtlCheckInterval

    codecraft
  • PWN:Tcache Attack原理

    同一大小的 chunk free 之后前 7 个会放到一个 tcache 链表里面,不同大小的放在不同的链表中

    yichen
  • Apache按天分隔日志

    windows下修改你的虚拟主机配置中增加如下内容: ErrorLog “|bin/rotatelogs.exe logs/5201314-%Y_%m_%d.e...

    苦咖啡

扫码关注云+社区

领取腾讯云代金券