高并发的几种处理方法

并发（英文Concurrency），其实是一个很泛的概念，字面意思就是“同时做多件事”，不过方式有所不同。在.NET的世界里面，处理高并发大致有以下几种方法：

1.异步编程

异步编程就是使用future模式（又称promise）或者回调机制来实现（Non-blocking on waiting）。如果使用回调或事件来实现（容易callback hell），不仅编写这样的代码不直观，很快就容易把代码搞得一团糟。

不过在.NET 4.5 及以上框架中引入的async/await关键字（在.NET 4.0中通过添加Microsoft.Bcl.Async包也可以使用），让编写异步代码变得容易和优雅。通过使用async/await关键字，可以像写同步代码那样编写异步代码，所有的回调和事件处理都交给编译器和运行时帮你处理了，简单好用。

使用异步编程有两个好处：不阻塞主线程（比如UI线程），提高服务端应用的吞吐量。所以微软推荐ASP.NET中默认使用异步来处理请求。

例如：我用异步做微信模板消息推送。

/// <summary>
/// 使用异步Action测试异步模板消息接口
/// </summary>
/// <param name="checkcode"></param>
/// <returns></returns>
public async Task<string> TemplateMessageAsync(string openId, string first, string keyword1, string keyword2, string keyword3, string keyword4, string remark, string url)
{
    if (openId == null)
    {
        return ReturnString(7771, "OPENID不能为空");
    }
    else
    {
        var testData = new //TestTemplateData()
        {
            first = new TemplateDataItem(first),
            keyword1 = new TemplateDataItem(keyword1),
            keyword2 = new TemplateDataItem(keyword2),
            keyword3 = new TemplateDataItem(keyword3),
            keyword4 = new TemplateDataItem(keyword4),
            remark = new TemplateDataItem(remark)
        };

        var result = await TemplateApi.SendTemplateMessageAsync(_wechat.APPID, openId, "m6td4jp_heMA5rhopbUaHApOlp2DD5x18BMXWKj3M5U", url, testData);
        return ReturnString(0, "成功");
    }
}

 

2.高并发处理

-》硬件

集群：多台服务器分流 ，静态资源集群和动态资源集群，需要考虑session同步问题

CDN:使用CDN存放静态资源

反向代理：用别的服务器代理处理

-》软件

动静分离：静态资源和动态资源分离，把静态资源放到单独的服务器

页面缓存：经常访问的页面可以做成静态页面放到缓存里

缩短请求路径：缩短请求服务的路径，便于解析

批量读取：多个请求合并到一起请求，减少数据库访问次数

延迟修改：把多次修改请求先放到缓存中，然后同步到库

 

3.Sql语句优化：

1.Where语句中不要出现Null、or、!=、<>、in、not in否则会避开索引进行全表扫描

2.尽量避免在索引过的字符数据中，使用非打头字母搜索，否则会避开索引进行全表扫如：SELECT * FROM T1 WHERE NAME LIKE ‘%L%’ 
SELECT * FROM T1 WHERE SUBSTING(NAME,2,1)=’L’ 

3.必要时强制查询优化器使用某个索引，如在 where 子句中使用参数，也会导致全表扫描如：select id from t where num=@num
可以改为强制查询使用索引：
select id from t with(index(索引名)) where num=@num

4.应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：

SELECT * FROM T1 WHERE F1/2=100 

应改为: 

SELECT * FROM T1 WHERE F1=100*2

SELECT * FROM RECORD WHERE SUBSTRING(CARD_NO,1,4)=’5378’

应改为: 

 

SELECT * FROM RECORD WHERE CARD_NO LIKE ‘5378%’
SELECT member_number, first_name, last_name FROM members 
WHERE DATEDIFF(yy,datofbirth,GETDATE()) > 21 

 

应改为: 

SELECT member_number, first_name, last_name FROM members 
WHERE dateofbirth < DATEADD(yy,-21,GETDATE()) 

即：任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边。

5.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：

select id from t where substring(name,1,3)='abc'--name以abc开头的id
select id from t where datediff(day,createdate,'2005-11-30')=0--‘2005-11-30’生成的id

应改为:

select id from t where name like 'abc%'
select id from t where createdate>='2005-11-30' and createdate<'2005-12-1'

6.不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。

7.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。

很多时候用 exists是一个好的选择：

elect num from a where num in(select num from b)

用下面的语句替换：

select num from a where exists(select 1 from b where num=a.num)
SELECT SUM(T1.C1)FROM T1 WHERE( 
(SELECT COUNT(*)FROM T2 WHERE T2.C2=T1.C2>0) 
SELECT SUM(T1.C1) FROM T1WHERE EXISTS( 
SELECT * FROM T2 WHERE T2.C2=T1.C2) 

两者产生相同的结果，但是后者的效率显然要高于前者。因为后者不会产生大量锁定的表扫描或是索引扫描。

如果你想校验表里是否存在某条纪录，不要用count(*)那样效率很低，而且浪费服务器资源。可以用EXISTS代替。如： 

IF (SELECT COUNT(*) FROM table_name WHERE column_name = 'xxx') 

可以写成： 

IF EXISTS (SELECT * FROM table_name WHERE column_name = 'xxx')

经常需要写一个T_SQL语句比较一个父结果集和子结果集，从而找到是否存在在父结果集中有而在子结果集中没有的记录，如： 

SELECT a.hdr_key FROM hdr_tbl a---- tbl a 表示tbl用别名a代替 
WHERE NOT EXISTS (SELECT * FROM dtl_tbl b WHERE a.hdr_key = b.hdr_key) 
SELECT a.hdr_key FROM hdr_tbl a 
LEFT JOIN dtl_tbl b ON a.hdr_key = b.hdr_key WHERE b.hdr_key IS NULL 
SELECT hdr_key FROM hdr_tbl 
WHERE hdr_key NOT IN (SELECT hdr_key FROM dtl_tbl) 

三种写法都可以得到同样正确的结果，但是效率依次降低。

1.尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限（只有主键索引）。

2.避免频繁创建和删除临时表，以减少系统表资源的消耗。

3.在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert。

4.如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。

5.临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件，最好使用导出表。

6.在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送 DONE_IN_PROC 消息。

7.尽量避免大事务操作，提高系统并发能力。

8.尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。 

9.避免使用不兼容的数据类型。例如float和int、char和varchar、binary和varbinary是不兼容的。数据类型的不兼容可能使优化器无法执行一些本来可以进行的优化操作。例如: 
SELECT name FROM employee WHERE salary > 60000 
在这条语句中,如salary字段是money型的,则优化器很难对其进行优化,因为60000是个整型数。我们应当在编程时将整型转化成为钱币型,而不要等到运行时转化。

10.充分利用连接条件，在某种情况下，两个表之间可能不只一个的连接条件，这时在 WHERE 子句中将连接条件完整的写上，有可能大大提高查询速度。 
例： 

SELECT SUM(A.AMOUNT) FROM ACCOUNT A,CARD B WHERE A.CARD_NO = B.CARD_NO 
SELECT SUM(A.AMOUNT) FROM ACCOUNT A,CARD B WHERE A.CARD_NO = B.CARD_NO AND A.ACCOUNT_NO=B.ACCOUNT_NO 

第二句将比第一句执行快得多。

1.使用视图加速查询 
把表的一个子集进行排序并创建视图，有时能加速查询。它有助于避免多重排序 操作，而且在其他方面还能简化优化器的工作

2.能用DISTINCT的就不用GROUP BY 

3.能用UNION ALL就不要用UNION 

4.尽量不要用SELECT INTO语句。 
SELECT INOT 语句会导致表锁定，阻止其他用户访问该表。

5.尽量避免使用游标，因为游标的效率较差