LINQ学习之旅——第二站"LTQ"之并发访问冲突及处理

　　在编写用户应用软件时，只要是涉及到数据库的操作，尤其是对于多用户并发访问数据库的情况，开发人员都要考虑如何来解决并发冲突的问题。当一个用户从数据库中读取数据并修改数据，最后把修改结果保存到数据库中，在这个过程中，另外一个用户也同样在查询和修改和上一个用户相同的数据，并早于上一个用户向数据库提交了更改，这时第一个用户在向数据库提交修改就发生了所谓的并发冲突。所以所开发的程序一定要提供对并发冲突检测和处理的机制。一般情况下，处理并发冲突有两种方式：乐观并发和悲观并发。下面详细介绍一下这两种处理并发冲突的方式。

　　1.乐观并发：

　　从字面意思上来看，就是说它对于并发冲突的发生持有乐观的态度，且认为大部分的程序运行时间里不会发生并发冲突。所以程序在访问和修改数据库时不会锁定要修改的数据，而是采用一种在修改时动态监测并发冲突的可能性的方法。乐观并发允许大量的用户访问数据库，也是目前应用最广泛的一种并发冲突处理方式。而LINQ TO SQL就提供了对乐观并发的支持，来帮助完成冲突检测和冲突处理任务。LINQ TO SQL提供了两种方法来检测并发冲突。这两种方式关键都在之前对象——关心映射(ORM)一节中所提到的内联属性Column中参数IsVersion和UpdateCheck的设置上。那么第一种就是用参数IsVersion来修饰实体类的列属性，如果实体类的某一列使用了IsVersion修饰并其值设置为true，这该列用于检测并发冲突。在用示例进一步说明之前，先把前几节都用到过的实体类Student做如下更改：

    [Table(Name ="dbo.student")]
class Student
    {
        [Column(Name ="sno",IsPrimaryKey=true, DbType ="char(8) NOT NULL")]
publicstring No { get; set; }

//Name列进行冲突检测
        [Column(Name ="sname", DbType ="varchar(10) NOT NULL", IsVersion =true)]
publicstring Name { get; set; }

        [Column(Name ="sdept", DbType ="varchar(10)", CanBeNull =true)]
publicstring Dept { get; set; }

        [Column(Name ="ssex", DbType ="char(2)", CanBeNull =true)]
publicstring Sex { get; set; }

        [Column(Name ="sage", DbType ="int", CanBeNull =true)]
publicint Age { get; set; }


//重新实现ToString()方法
publicoverridestring ToString()
        {
return"{No="+ No +", Name="+ Name +", Dept="+ Dept+", Sex="+ Sex+", Age="+ Age +"}";
        }
    }

i.IsVersion参数列参与乐观并发冲突检测：

string str_conn =@"Data Source=localhost;Initial Catalog=DB_Student;User ID=sa;Password=king";
            DataContext dc =new DataContext(str_conn);

            var students = dc.GetTable<Student>();
//将SQL语句显示在控制台
            dc.Log = Console.Out;

            var student = (from stu in students
where stu.No =="20030005"
                           select stu).Single();

//修改实体类属性
            student.Age +=1;

//提交修改到数据库
            dc.SubmitChanges();

            Console.Read();

ii.结果：

从运行结果中可以看到，在向数据库提交数据更新的时候，Update语句中不仅sno作为Where查找记录的条件，而且sname也作为查找条件参与更新。但要注意的是参数IsVersion在每个实体类中只能设置一个实体列。通常IsVersion参数和数据库中类型为Timestamp(时间戳)的字段数据结合使用。在LINQ TO SQL第一次查询数据时，会在DataContext对象中单独保存所有数据的原始值，当向数据库提交更新时，这些原始数据作为检测并发冲突的条件，将这些原始值添加到Update语句中的Where条件中，比如上述中的Name属性的原始值，如果数据库中该数据在这段时间里被别的用户修改了，那么显然该Update语句中的条件将不成立，这时LINQ TO SQL就感知到并发冲突的发生了，接着就可以相应做并发处理。IsVersion参数用于哪一列，哪一列就参与并发冲突检测。既然参数IsVersion只能在设置一个实体列，那么如果更新时要检测的条件很多，比如上述实体类中的列Sdept和列Age都要进行并发检测，那该如何解决呢？

　　LINQ TO SQL中还允许使用UpdateCheck参数来指定参与并发冲突检测的列，这就是第二种乐观并发冲突检测的方式。UpdateCheck是一个枚举类型，有Never、Always和WhenChanged这三个枚举值。其中Never指示该列不参加并发冲突检测；Always指示该列将一直参与并发冲突检测；WhenChanged指示该列只有值发生修改时才参与并发冲突检测。下面通过示例来进一步说明：

i.修改实体类Student：

    [Table(Name ="dbo.student")]
class Student
    {
        [Column(Name ="sno",IsPrimaryKey=true, DbType ="char(8) NOT NULL")]
publicstring No { get; set; }

//Name列一直参与并发冲突检测
        [Column(Name ="sname", DbType ="varchar(10) NOT NULL",UpdateCheck=UpdateCheck.Always)]
publicstring Name { get; set; }

//Dept列只有在值发生改变时才参与并发冲突检测
        [Column(Name ="sdept", DbType ="varchar(10)", CanBeNull =true,UpdateCheck=UpdateCheck.WhenChanged)]
publicstring Dept { get; set; }

//Sex列从不参与并发冲突检测
        [Column(Name ="ssex", DbType ="char(2)", CanBeNull =true,UpdateCheck=UpdateCheck.Never)]
publicstring Sex { get; set; }

//Age列只有在值发生改变时才参与并发冲突检测
        [Column(Name ="sage", DbType ="int", CanBeNull =true,UpdateCheck=UpdateCheck.WhenChanged)]
publicint Age { get; set; }

//重新实现ToString()方法
publicoverridestring ToString()
        {
return"{No="+ No +", Name="+ Name +", Dept="+ Dept+", Sex="+ Sex+", Age="+ Age +"}";
        }
    }

ii.UpdateCheck参数列参与乐观并发冲突检测：

string str_conn =@"Data Source=localhost;Initial Catalog=DB_Student;User ID=sa;Password=king";
            DataContext dc =new DataContext(str_conn);

            var students = dc.GetTable<Student>();

//将SQL语句显示在控制台
            dc.Log = Console.Out;

            var student1 = (from stu in students
where stu.No =="20030006"
                           select stu).Single();

//修改实体类属性
            student1.Dept ="软件工程";
            student1.Age +=1;

//提交修改到数据库
            dc.SubmitChanges();

            Console.Read();

iii.结果：

从运行结果中可以看到Name列参与了冲突检测，Age列和Dept列因为修改后属性值与原始值不同，所以也参与到并发冲突的检测中，而Sex列却没有参加任何检测。接下来说说，假如发生了并发冲突的情况，那么该如何进行处理。

　　冲突检测发生在DataContext对象调用SubmitChanges方法时，此方法可以接受一个ConflictMode类型的枚举值作为参数，用来指定在将更改的数据保存到数据库过程中发生并发冲突时的处理策略。它包含FailOnFirstConflict和ContinueOnConflict两个值，其中，FailOnFirstConflict指示在修改的数据保存到数据库过程中第一次发生并发冲突时，SubmitChanges方法就抛出异常，不再继续更新；而ContinueOnConflict指示发生并发冲突时继续更新其他的数据，最后抛出一个全部更新失败的异常。在并发冲突发生时，SumbitChanges抛出类型为ChangeConflictException的异常对象，通过在代码中捕获该异常对象，就可以对其进行并发冲突的逻辑处理。其实LINQ TO SQL中提供了Resolve和ResolveAll方法来帮助实现并发冲突处理功能，在使用这两个方法时，要指定一个RefreshMode枚举类型的参数来指示处理并发冲突的策略，RefreshMode枚举类型包含KeepChanges、KeepCurrentValues和OverWriteCurrentValues三个值。而这三个值具体的作用说明可以参考之前所讲过的DataContext对象成员方法Refresh，这里就不在详细说明了。在用Resolve和ResolveAll方法查询数据库，并获取数据库最新数据时，保存在DataContext对象中的实体类对象原始值将会自动更新，一旦更新完成，那么冲突条件就不再存在，除非发生新的冲突。下面通过示例来进一步说明(注：实体类Student代码不变)：

i.并发访问冲突处理：

staticvoid Main(string[] args)
        {
string str_conn =@"Data Source=localhost;Initial Catalog=DB_Student;User ID=sa;Password=king";
            DataContext dc =new DataContext(str_conn);

            var students = dc.GetTable<Student>();
//把SQL语句输出在控制台
            dc.Log = Console.Out;

            var student = (from stu in students
where stu.Name =="刘麻子"
                           select stu).Single();

//修改实体类对象属性
            student.Name ="张麻子";

//模拟并发访问
            SqlConnection conn =new SqlConnection(str_conn);
            SqlCommand cmd = conn.CreateCommand();
            cmd.CommandText ="update student set sname='刘晓光' where sname='刘麻子'";
            cmd.CommandType = System.Data.CommandType.Text;
            conn.Open();
            cmd.ExecuteNonQuery();
            conn.Close();

//提交更改数据到数据库
try
            {
                dc.SubmitChanges(ConflictMode.ContinueOnConflict);
            }
catch (ChangeConflictException)
            {
                
foreach (var c in dc.ChangeConflicts)
                {
foreach (var m in c.MemberConflicts)
                    { 
//记录并发冲突的数据信息
                        var exception =new
                        {
                            MemberName = m.Member.Name,
                            CurrentValue = m.CurrentValue,
                            DataBaseValue = m.DatabaseValue,
                            OriginValue = m.OriginalValue
                        };
                        Console.WriteLine("并发冲突数据信息:");
                        Console.WriteLine(exception.ToString()+"\n");

//并发冲突处理
                        m.Resolve(RefreshMode.KeepCurrentValues);
                    }
                   
                }
//或
//dc.ChangeConflicts.ResolveAll(RefreshMode.KeepCurrentValues);
            }
finally
            {
//再次提交
try
                {
                    dc.SubmitChanges(ConflictMode.ContinueOnConflict);
                }
catch (ChangeConflictException e)
                {
                    Console.WriteLine(e);
                }
            }

            Console.Read();
        }

ii.结果：

从结果中可以看到程序分两次执行更新语句向数据库提交。

　　2.悲观并发：

　　同样地，从字面意思来看悲观并发就是对并发冲突的发生持有悲观的态度，认为程序运行的大部分时间里都可能发生并发冲突。所以在修改数据库中的数据时，要将其锁定，只允许一个用户访问并修改，且直到该用户修改完成了，才对该数据解除锁定。悲观并发不会发生并发冲突，而一般悲观并发要在数据库用户访问数量比较少情况下才适合。那该如何用悲观并发来避免并发冲突的发生呢，其实很简单，就是把要操作的数据代码包含在一个事务里。下面通过示例进一步说明：

i.事务处理来避免并发冲突：

staticvoid Main(string[] args)
        {
string str_conn =@"Data Source=localhost;Initial Catalog=DB_Student;User ID=sa;Password=king";
            DataContext dc =new DataContext(str_conn);

//使用事务将数据库中的记录锁定
using (TransactionScope t1 =new TransactionScope())
            {
                var students = dc.GetTable<Student>();

                var student = (from stu in students
where stu.Name =="刘麻子"
                               select stu).Single();
//修改实体类对象
                student.Name ="张麻子";

//模拟并发访问
using (TransactionScope t2 =new TransactionScope(TransactionScopeOption.RequiresNew))
                {
                    SqlConnection conn =new SqlConnection(str_conn);
                    SqlCommand cmd = conn.CreateCommand();
                    cmd.CommandText ="update student set sname='刘晓光' where sname='刘麻子'";
                    cmd.CommandType = System.Data.CommandType.Text;
                    conn.Open();
                    cmd.ExecuteNonQuery();
                    conn.Close();
//事务2提交
                    t2.Complete();
                }

//提交数据修改到数据库
                dc.SubmitChanges();
//事务1提交
                t1.Complete();
            }

            Console.Read();
        }

ii.结果：

原因在于事务1将数据库中数据锁住，进行数据修改，但并未提交事务，所以导致事务2一直等待事务1结束，而事务1的结束必须要等事务2结束，所以事务2不可能会有机会来执行，所以事务2最终等待超时抛出异常。