sql server在高并发状态下同时执行查询与更新操作时的死锁问题

蔚落 2021-12-17 04:47 692阅读 0赞

最近在项目上线使用过程中使用SqlServer的时候发现在高并发情况下，频繁更新和频繁查询引发死锁。通常我们知道如果两个事务同时对一个表进行插入或修改数据，会发生在请求对表的X锁时，已经被对方持有了。由于得不到锁，后面的Commit无法执行，这样双方开始死锁。但是select语句和update语句同时执行，怎么会发生死锁呢？看完下面的分析，你会明白的…

首先看到代码中使用的查询的方法Select

1.  `/// <summary>`
2.  `/// 根据学生ID查询教师信息。用于前台学生评分主页面显示`
3.  `/// </summary>`
4.  `/// <param name="enTeacherCourseStudent">教师课程学生关系实体：StudentID</param>`
5.  `public DataTable QueryTeacherByStudent(TeacherCourseStudentLinkEntity enTeacherCourseStudent)`
6.  `{`
7.  `//TODO:QueryTeacherByStudent string strSql = "SELECT ID, CollegeTeacherID,CollegeTeacherName,TeacherID,TeacherCode," +`
8.  `//"TeacherName,CourseID,CourseName,CourseTypeID,CourseTypeName," +`
9.  `//"StudentID,StudentName,IsEvluation FROM TA_TeacherCourseStudentLink WITH(NOLOCK) " +`
10. `//"WHERE StudentID = @StudentID";`
11. `//根据学生ID查询该学生对哪些教师评分的sql语句`
12. `string strSql = "SELECT ID, CollegeTeacherID,CollegeTeacherName,TeacherID,TeacherCode," +`
13. `"TeacherName,CourseID,CourseName,CourseTypeID,CourseTypeName," +`
14. `"StudentID,StudentName,IsEvluation FROM TA_TeacherCourseStudentLink WITH(NOLOCK) " +`
15. `"WHERE StudentID = @StudentID";`
16. `//参数`
17. `SqlParameter[] para = new SqlParameter[] {`
18. `new SqlParameter("@StudentID",enTeacherCourseStudent.StudentID) //学生ID`
19. `};`
20. `//执行带参数的sql查询语句或存储过程`
21. `DataTable dtStuTeacher = sqlHelper.ExecuteQuery(strSql, para, CommandType.Text);`
22. `//返回查询结果`
23. `return dtStuTeacher;`
24. `}`

更新方法

1.  `/// <summary>`
2.  `/// 学生对教师评分完毕，是否评估由N变为Y`
3.  `/// </summary>`
4.  `/// <param name="enTeacherCourseStudent">教师课程学生关系实体：StudentID、TeacherID、CourseID</param>`
5.  `/// <return>是否修改成功，true成功，false失败</return>`
6.  `public Boolean EditIsEvaluation(TeacherCourseStudentLinkEntity enTeacherCourseStudent, SqlConnection sqlCon, SqlTransaction sqlTran)`
7.  `{`
8.  `//更改是否评估字段为"Y"的sql语句`
9.  `string strSql = "UPDATE TA_TeacherCourseStudentLink WITH(UPDLOCK) SET IsEvluation='Y' WHERE TeacherID=@TeacherID AND StudentID=@StudentID AND CourseID=@CourseID";`
10. `//参数`
11. `SqlParameter[] paras = new SqlParameter[]{`
12. `new SqlParameter("@TeacherID",enTeacherCourseStudent.TeacherID), //教师ID`
13. `new SqlParameter("@StudentID",enTeacherCourseStudent.StudentID), //学生ID`
14. `new SqlParameter("@CourseID",enTeacherCourseStudent.CourseID) //课程ID`
15. `};`
16. `//李社河添加2014年12月29日`
17. `Boolean flagModify = false;`
18. `try`
19. `{`
20. `//执行带参数的增删改sql语句或存储过程`
21. `flagModify = sqlHelper.ExecNoSelect(strSql, paras, CommandType.Text, sqlCon, sqlTran);`
22. `}`
23. `catch (Exception e)`
24. `{`
25. `throw e;`
26. `}`
27.  
28.  
29. `//返回修改结果`
30. `return flagModify;`
31. `}`

现在分析，在数据库系统中，死锁是指多个用户（进程）分别锁定了一个资源，并又试图请求锁定对方已经锁定的资源，这就产生了一个锁定请求环，导致多个用户（进程）都处于等待对方释放所锁定资源的状态。还有一种比较典型的死锁情况是当在一个数据库中时，有若干个长时间运行的事务执行并行的操作，当查询分析器处理一种非常复杂的查询例如连接查询时，那么由于不能控制处理的顺序，有可能发生死锁现象。

那么，什么导致了死锁？

现象图![Center][]

通过查询sqlserver的事务日志视图，发生的错误日志视图知道是在高并发的情况下引发的update和select发生的死锁，接下来我们看例子;

1.  `CREATE PROC p1 @p1 int AS`
2.  `SELECT c2, c3 FROM t1 WHERE c2 BETWEEN @p1 AND @p1+1`
3.  `GO`
4.   
5.  `CREATE PROC p2 @p1 int AS`
6.  `UPDATE t1 SET c2 = c2+1 WHERE c1 = @p1`
7.  `UPDATE t1 SET c2 = c2-1 WHERE c1 = @p1`
8.  `GO`

p1没有insert，没有delete，没有update，只是一个select，p2才是update。那么，什么导致了死锁？

1.  `需要从事件日志中，看sql的死锁信息：`
2.  `Spid X is running this query (line 2 of proc [p1], inputbuffer “… EXEC p1 4 …”):`
3.  `SELECT c2, c3 FROM t1 WHERE c2 BETWEEN @p1 AND @p1+1`
4.  `Spid Y is running this query (line 2 of proc [p2], inputbuffer “EXEC p2 4”):`
5.  `UPDATE t1 SET c2 = c2+1 WHERE c1 = @p1`
6.   
7.  `The SELECT is waiting for a Shared KEY lock on index t1.cidx. The UPDATE holds a conflicting X lock.`
8.  `The UPDATE is waiting for an eXclusive KEY lock on index t1.idx1. The SELECT holds a conflicting S lock.`

首先，我们看看p1的执行计划。怎么看呢？可以执行set statistics profile on，这句就可以了。下面是p1的执行计划

1.  `SELECT c2, c3 FROM t1 WHERE c2 BETWEEN @p1 AND @p1+1`
2.  `|--Nested Loops(Inner Join, OUTER REFERENCES:([Uniq1002], [t1].[c1]))`
3.  `|--Index Seek(OBJECT:([t1].[idx1]), SEEK:([t1].[c2] >= [@p1] AND [t1].[c2] <= [@p1]+(1)) ORDERED FORWARD)`
4.  `|--Clustered Index Seek(OBJECT:([t1].[cidx]), SEEK:([t1].[c1]=[t1].[c1] AND [Uniq1002]=[Uniq1002]) LOOKUP ORDERED FORWARD)`

我们看到了一个nested loops，第一行，利用索引t1.c2来进行seek，seek出来的那个rowid，在第二行中，用来通过聚集索引来查找整行的数据。这是什么？就是bookmark lookup啊！为什么？因为我们需要的c2、c3不能完全的被索引t1.c1带出来，所以需要书签查找。

好，我们接着看p2的执行计划。

1.  `UPDATE t1 SET c2 = c2+1 WHERE c1 = @p1`
2.  `|--Clustered Index Update(OBJECT:([t1].[cidx]), OBJECT:([t1].[idx1]), SET:([t1].[c2] = [Expr1004]))`
3.  `|--Compute Scalar(DEFINE:([Expr1013]=[Expr1013]))`
4.  `|--Compute Scalar(DEFINE:([Expr1004]=[t1].[c2]+(1), [Expr1013]=CASE WHEN CASE WHEN ...`
5.  `|--Top(ROWCOUNT est 0)`
6.  `|--Clustered Index Seek(OBJECT:([t1].[cidx]), SEEK:([t1].[c1]=[@p1]) ORDERED FORWARD)`

通过聚集索引的seek找到了一行，然后开始更新。这里注意的是，update的时候，它会申请一个针对clustered index的X锁的。

实际上到这里，我们就明白了为什么update会对select产生死锁。update的时候，会申请一个针对clustered index的X锁，这样就阻塞住了（注意，不是死锁！）select里面最后的那个clustered index seek。死锁的另一半在哪里呢？注意我们的select语句，c2存在于索引idx1中，c1是一个聚集索引cidx。问题就在这里！我们在p2中更新了c2这个值，所以sqlserver会自动更新包含c2列的非聚集索引：idx1。而idx1在哪里？就在我们刚才的select语句中。而对这个索引列的更改，意味着索引集合的某个行或者某些行，需要重新排列，而重新排列，需要一个X锁。

问题就这样被发现了，就是说，某个query使用非聚集索引来select数据，那么它会在非聚集索引上持有一个S锁。当有一些select的列不在该索引上，它需要根据rowid找到对应的聚集索引的那行，然后找到其他数据。而此时，第二个的查询中，update正在聚集索引上忙乎：定位、加锁、修改等。但因为正在修改的某个列，是另外一个非聚集索引的某个列，所以此时，它需要同时更改那个非聚集索引的信息，这就需要在那个非聚集索引上，加第二个X锁。select开始等待update的X锁，update开始等待select的S锁，死锁，就这样发生鸟。

添加了针对select和update同一个表的非聚集索引解决问题。那么，为什么我们增加了一个非聚集索引，死锁就消失鸟？我们看一下，按照上文中自动增加的索引之后的执行计划：

1.  `SELECT c2, c3 FROM t1 WHERE c2 BETWEEN @p1 AND @p1+1`
2.  `|--Index Seek(OBJECT:([deadlocktest].[dbo].[t1].[_dta_index_t1_7_2073058421__K2_K1_3]), SEEK:([deadlocktest].[dbo].[t1].[c2] >= [@p1] AND [deadlocktest].[dbo].[t1].[c2] <= [@p1]+(1)) ORDERED FORWARD)`

哦，对于clustered index的需求没有了，因为增加的覆盖索引已经足够把所有的信息都select出来。就这么简单。  
实际上，在sqlserver 2005中，如果用profiler来抓eventid：1222，那么会出现一个死锁的图，很直观的说。

下面的方法，有助于将死锁减至最少（详细情况，请看SQLServer联机帮助，搜索：将死锁减至最少即可）。

·  按同一顺序访问对象。

·  避免事务中的用户交互。

·  保持事务简短并处于一个批处理中。

·  使用较低的隔离级别。

·  使用基于行版本控制的隔离级别。

-    将 READ\_COMMITTED\_SNAPSHOT 数据库选项设置为 ON，使得已提交读事务使用行版本控制。

-    使用快照隔离。

·   使用绑定连接。

下面我们在测试的同时开启trace profiler跟踪死锁视图(locks:deadlock graph).(当然也可以开启跟踪标记,或者应用扩展事件(xevents)等捕捉死锁)

创建测试对象code

1.  `create table testklup`
2.  `( clskey int not null,`
3.  `nlskey int not null,`
4.  `cont1 int not null,`
5.  `cont2 char(3000)`
6.  `)`
7.   
8.  `create unique clustered index inx_cls on testklup(clskey)`
9.   
10. `create unique nonclustered index inx_nlcs on testklup(nlskey) include(cont1)`
11.  
12. `insert into testklup select 1,1,100,'aaa'`
13. `insert into testklup select 2,2,200,'bbb'`
14. `insert into testklup select 3,3,300,'ccc'`

开启会话1 模拟高频update操作

\----模拟高频update操作

1.  `declare @i int`
2.  `set @i=100`
3.  `while 1=1`
4.  `begin`
5.  `update testklup set cont1=@i`
6.  `where clskey=1`
7.  `set @i=@i+1`
8.  `end`

开启会话2 模拟高频select操作

\----模拟高频select操作

1.  `declare @cont2 char(3000)`
2.  `while 1=1`
3.  `begin`
4.  `select @cont2=cont2 from testklup where nlskey=1`
5.  `end`

此时开启会话2执行一小段时间时我们就可以看到类似错误信息:  
![Center 1][]  
而在我们开启的跟踪中捕捉到了死锁.

死锁分析:可以看出由于读进程(108)请求写进程(79)持有的X锁被阻塞的同时,写进程(79)又申请读进程(108)锁持有的S锁.读执行计划图，写执行计划图。

![Center 2][]

![Center 3][]

(由于在默认隔离级别下(读提交)读申请S锁只是瞬间过程,读完立即释放,不会等待事务完成),所以在并发,执行频率不高的情形下不易出现.但我们模拟的高频情况使得S锁获得频率非常高,此时就出现了仅仅两个会话,一个读,一个写就造成了死锁现象.

死锁原因:读操作中的键查找造成的额外锁(聚集索引)需求

解决方案:在了解了死锁产生的原因后,解决起来就比较简单了.

我们可以从以下几个方面入手.

a 消除额外的键查找锁需的锁

b 读操作时取消获取锁

a.1我们可以创建覆盖索引使select语句中的查询列包含在指定索引中

CREATE NONCLUSTERED INDEX [inx_nlskey_incont2] ON [dbo].[testklup] ([nlskey] ASC) INCLUDE ( [cont2])

a.2 根据查询需求,分步执行,通过聚集索引获取查询列,避免键查找.'

declare @cont2 char(3000) declare @clskey intwhile 1=1 begin  select @clskey=clskey from testklup where nlskey=1     select @cont2=cont2 from testklup where clskey=@clskey end

b 通过改变隔离级别,使用乐观并发模式,读操作时源行无需锁

1.  `declare @cont2 char(3000)`
2.  `while 1=1`
3.  `begin`
4.   
5.  `select @cont2=cont2 from testklup with(nolock) where nlskey=1`
6.   
7.  `end`

结束语.我们在解决问题时,最好弄清问题的本质原因,通过问题点寻找出适合自己的环境的解决方案再实施.

\-------------------------------------------------------------------------------------------------------------------------------------------------------------------------

## [SQL Server 中WITH (NOLOCK)浅析][SQL Server _WITH _NOLOCK]  ##

**概念介绍**

开发人员喜欢在SQL脚本中使用WITH(NOLOCK), WITH(NOLOCK)其实是表提示（table\_hint）中的一种。它等同于 READUNCOMMITTED 。 具体的功能作用如下所示（摘自MSDN）：

1： 指定允许脏读。不发布共享锁来阻止其他事务修改当前事务读取的数据，其他事务设置的排他锁不会阻碍当前事务读取锁定数据。允许脏读可能产生较多的并发操作，但其代价是读取以后会被其他事务回滚的数据修改。这可能会使您的事务出错，向用户显示从未提交过的数据，或者导致用户两次看到记录（或根本看不到记录）。有关脏读、不可重复读和幻读的详细信息，请参阅[并发影响][Link 1]。

2： READUNCOMMITTED 和 NOLOCK 提示仅适用于数据锁。所有查询（包括那些带有 READUNCOMMITTED 和 NOLOCK 提示的查询）都会在编译和执行过程中获取 Sch-S（架构稳定性）锁。因此，当并发事务持有表的 Sch-M（架构修改）锁时，将阻塞查询。例如，数据定义语言 (DDL) 操作在修改表的架构信息之前获取 Sch-M 锁。所有并发查询（包括那些使用 READUNCOMMITTED 或 NOLOCK 提示运行的查询）都会在尝试获取 Sch-S 锁时被阻塞。相反，持有 Sch-S 锁的查询将阻塞尝试获取 Sch-M 锁的并发事务。有关锁行为的详细信息，请参阅[锁兼容性（数据库引擎）][Link 2]。

3:  不能为通过插入、更新或删除操作修改过的表指定 READUNCOMMITTED 和 NOLOCK。SQL Server 查询优化器忽略 FROM 子句中应用于 UPDATE 或 DELETE 语句的目标表的 READUNCOMMITTED 和 NOLOCK 提示。

**功能与缺陷**

使用WIHT(NOLOCK)有利也有弊，所以在决定使用之前，你一定需要了解清楚WITH(NOLOCK)的功能和缺陷，看其是否适合你的业务需求,不要觉得它能提升性能，稀里糊涂的就使用它。

1：使用WITH(NOLOCK)时查询不受其它排他锁阻塞

打开会话窗口1，执行下面脚本，不提交也不回滚事务，模拟事务真在执行过程当中

BEGIN TRAN

UPDATE TEST SET NAME='Timmy' WHERE OBJECT_ID =1;

--ROLLBACK

打开会话窗口2，执行下面脚本，你会发现执行结果一直查询不出来（其实才两条记录）。当前会话被阻塞了

SELECT * FROM TEST;

打开会话窗口3，执行下面脚本，查看阻塞情况，你会发现在会话2被会话1给阻塞了，会话2的等待类型为LCK\_M\_S：“当某任务正在等待获取共享锁时出现”

SELECT wt.blocking_session_id AS BlockingSessesionId

,sp.program_name AS ProgramName

,COALESCE(sp.LOGINAME, sp.nt_username) AS HostName

,ec1.client_net_address AS ClientIpAddress

,db.name AS DatabaseName

,wt.wait_type AS WaitType

,ec1.connect_time AS BlockingStartTime

,wt.WAIT_DURATION_MS/1000 AS WaitDuration

,ec1.session_id AS BlockedSessionId

,h1.TEXT AS BlockedSQLText

,h2.TEXT AS BlockingSQLText

FROM sys.dm_tran_locks AS tl

INNER JOIN sys.databases db

ON db.database_id = tl.resource_database_id

INNER JOIN sys.dm_os_waiting_tasks AS wt

ON tl.lock_owner_address = wt.resource_address

INNER JOIN sys.dm_exec_connections ec1

ON ec1.session_id = tl.request_session_id

INNER JOIN sys.dm_exec_connections ec2

ON ec2.session_id = wt.blocking_session_id

LEFT OUTER JOIN master.dbo.sysprocesses sp

ON SP.spid = wt.blocking_session_id

CROSS APPLY sys.dm_exec_sql_text(ec1.most_recent_sql_handle) AS h1

CROSS APPLY sys.dm_exec_sql_text(ec2.most_recent_sql_handle) AS h2

[![clipboard][]][clipboard 1]

此时查看会话1（会话1的会话ID为53，执行脚本1前，可以用SELECT  @@spid查看会话ID）的锁信息情况，你会发现表TEST(ObjId=1893581784)持有的锁信息如下所示

[![clipboard\[1\]][clipboard_1]][clipboard_1_clipboard_1]

打开会话窗口4，执行下面脚本.你会发现查询结果很快就出来，会话4并不会被会话1阻塞。

SELECT \* FROM TEST WITH(NOLOCK)

从上面模拟的这个小例子可以看出，正是由于加上WITH(NOLOCK)提示后，会话1中事务设置的排他锁不会阻碍当前事务读取锁定数据，所以会话4不会被阻塞，从而提升并发时查询性能。

2：WITH(NOLOCK) 不发布共享锁来阻止其他事务修改当前事务读取的数据，这个就不举例子了。

本质上WITH(NOLOCK)是通过减少锁和不受排它锁影响来减少阻塞，从而提高并发时的性能。所谓凡事有利也有弊，WITH(NOLOCK)在提升性能的同时，也会产生脏读现象。

如下所示，表TEST有两条记录，我准备更新OBJECT\_ID=1的记录，此时事务既没有提交也没有回滚

[![clipboard\[2\]][clipboard_2]][clipboard_2_clipboard_2]

BEGIN TRAN

UPDATE TEST SET NAME='Timmy' WHERE OBJECT_ID =1;

--ROLLBACK

此时另外一个会话使用WITH(NOLOCK)查到的记录为未提交的记录值

[![clipboard\[3\]][clipboard_3]][clipboard_3_clipboard_3]

假如由于某种原因，该事务回滚了，那么我们读取到的OBJECT\_ID=1的记录就是一条脏数据。

脏读又称无效数据的读出，是指在数据库访问中，[事务][Link 3]T1将某一值修改，然后事务T2读取该值，此后T1因为某种原因撤销对该值的修改，这就导致了T2所读取到的数据是无效的。

**WITH(NOLOCK)使用场景**

什么时候可以使用WITH(NOLOCK)? 什么时候不能使用WITH(NOLOCK),这个要视你系统业务情况，综合考虑性能情况与业务要求来决定是否使用WITH(NOLOCK), 例如涉及到金融或会计成本之类的系统，出现脏读那是要产生严重问题的。关键业务系统也要慎重考虑。大体来说一般有下面一些场景可以使用WITH(NOLOCK)

1: 基础数据表，这些表的数据很少变更。

2：历史数据表，这些表的数据很少变更。

3：业务允许脏读情况出现涉及的表。

4：数据量超大的表，出于性能考虑，而允许脏读。

另外一点就是不要滥用WITH(NOLOCK),我发现有个奇怪现象，很多开发知道WITH(NOLOCK),但是有不了解脏读，习惯性的使用WITH(NOLOCK)。

**WITH(NOLOCK)与 NOLOCK区别**

为了搞清楚WITH(NOLOCK)与NOLOCK的区别，我查了大量的资料，我们先看看下面三个SQL语句有啥区别

SELECT \* FROM TEST NOLOCK

SELECT \* FROM TEST (NOLOCK);

SELECT \* FROM TEST WITH(NOLOCK);

上面的问题概括起来也就是说NOLOCK、(NOLOCK)、 WITH(NOLOCK)的区别：

1： NOLOCK这样的写法，其实NOLOCK其实只是别名的作用，而没有任何实质作用。所以不要粗心将(NOLOCK)写成NOLOCK

2：（NOLOCK）与WITH(NOLOCK)其实功能上是一样的。(NOLOCK)只是WITH(NOLOCK)的别名,但是在SQL Server 2008及以后版本中，(NOLOCK)不推荐使用了，"不借助 WITH 关键字指定表提示”的写法已经过时了。 具体参见MSDN [http://msdn.microsoft.com/zh-cn/library/ms143729][http_msdn.microsoft.com_zh-cn_library_ms143729]%28SQL.100%29.aspx

2.1  至于网上说WITH(NOLOCK)在SQL SERVER 2000不生效，我验证后发现完全是个谬论。

2.2  在使用链接服务器的SQL当中，(NOLOCK)不会生效，WITH(NOLOCK)才会生效。如下所示

[![clipboard\[4\]][clipboard_4]][clipboard_4_clipboard_4]

消息 4122，级别 16，状态 1，第 1 行

Remote table-valued function calls are not allowed.

3.语法上有些许出入，如下所示

这种语法会报错

SELECT  * FROM   sys.indexes  WITH(NOLOCK) AS i

-Msg 156, Level 15, State 1, Line 1

-Incorrect syntax near the keyword 'AS'.

这种语法正常

SELECT  * FROM   sys.indexes  (NOLOCK) AS i

可以全部改写为下面语法

SELECT  * FROM   sys.indexes   i WITH(NOLOCK)

SELECT  * FROM   sys.indexes   i (NOLOCK)

**WITH(NOLOCK)会不会产生锁**

很多人误以为使用了WITH(NOLOCK)后，数据库库不会产生任何锁。实质上，使用了WITH(NOLOCK)后，数据库依然对该表对象生成Sch-S（架构稳定性）锁以及DB类型的共享锁， 如下所示，可以在一个会话中查询一个大表，然后在另外一个会话中查看锁信息(也可以使用SQL Profile查看会话锁信息)

不使用WTIH(NOLOCK)

[![clipboard\[5\]][clipboard_5]][clipboard_5_clipboard_5]

使用WITH(NOLOCK)

[![clipboard\[6\]][clipboard_6]][clipboard_6_clipboard_6]

从上可以看出使用WITH(NOLOCK)后，数据库并不是不生成相关锁。  对比可以发现使用WITH(NOLOCK)后，数据库只会生成DB类型的共享锁、以及TAB类型的架构稳定性锁.

另外，使用WITH(NOLOCK)并不是说就不会被其它会话阻塞，依然可能会产生Schema Change Blocking

会话1：执行下面SQL语句，暂时不提交，模拟事务正在执行

BEGIN TRAN

ALTER TABLE TEST ADD Grade VARCHAR(10) ;

会话2：执行下面语句，你会发现会话被阻塞，截图如下所示。

SELECT * FROM TEST WITH(NOLOCK)

[![image][]][image 1]

[Center]: /images/20211213/d1a5d03f272c4270a24c6870a3f0cfb4.png
[Center 1]: /images/20211213/b2a733abbdbc4a708f746f844ae1cfb0.png
[Center 2]: /images/20211213/103fb0e8bc8c4723a3923b67d215152e.png
[Center 3]: /images/20211213/a74fb7257f664fe99a862bf6ed8a02c3.png
[SQL Server _WITH _NOLOCK]: https://www.cnblogs.com/kerrycode/p/3946268.html
[Link 1]: http://msdn.microsoft.com/zh-cn/library/ms190805%28v=sql.105%29.aspx
[Link 2]: http://msdn.microsoft.com/zh-cn/library/ms186396%28v=sql.105%29.aspx
[clipboard]: /images/20211213/2cf5af11f64d44bfb9956ea5e1cd83ac.png
[clipboard 1]: https://images0.cnblogs.com/blog/73542/201408/301204003457660.png
[clipboard_1]: https://images0.cnblogs.com/blog/73542/201408/301157597984445.png
[clipboard_1_clipboard_1]: /images/20211213/3e094e73c627413fae00a191aa23e670.png
[clipboard_2]: https://images0.cnblogs.com/blog/73542/201408/301158015956927.png
[clipboard_2_clipboard_2]: /images/20211213/a1fbabfa1fb94ac6b226cbb23a653a19.png
[clipboard_3]: https://images0.cnblogs.com/blog/73542/201408/301158030165927.png
[clipboard_3_clipboard_3]: /images/20211213/e456f1d0b64a47569db37acad676c4b0.png
[Link 3]: http://baike.baidu.com/view/121511.htm
[http_msdn.microsoft.com_zh-cn_library_ms143729]: http://msdn.microsoft.com/zh-cn/library/ms143729
[clipboard_4]: https://images0.cnblogs.com/blog/73542/201408/301158046103640.png
[clipboard_4_clipboard_4]: /images/20211213/c3bfd3a913334a0a86c11bfaf0a977d0.png
[clipboard_5]: https://images0.cnblogs.com/blog/73542/201408/301158061412139.png
[clipboard_5_clipboard_5]: /images/20211213/1453108c57c94baca6f8940db3112c42.png
[clipboard_6]: https://images0.cnblogs.com/blog/73542/201408/301158077047095.png
[clipboard_6_clipboard_6]: /images/20211213/d1d2dfc88ce449d0a0254612a6cd71ce.png
[image]: /images/20211213/5a674f84927943e98879b47f5a120fe1.png
[image 1]: https://images0.cnblogs.com/blog/73542/201408/301158081574024.png