SqlServer加锁

为什么要引入锁?？
多个用户同时对数据库的并发操作时会带来以下数据不一致的问题。

?

select加共享锁，insert、update、delete加排他锁。

?

悲观锁(Pessimistic Lock),顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。?通过?jdbc?实现时?sql?语句只要在整个语句之后加?for update?即可。例如：?select …for update

乐观锁(Optimistic Lock),顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write_condition机制的其实都是提供的乐观锁。

两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下，即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果经常产生冲突，上层应用会不断的进行retry，这样反倒是降低了性能，所以这种情况下用悲观锁就比较合适

?

共享锁的使用

?

排它锁的使用

在第一个连接中执行以下语句
begin tran
update table1
set A='aa'
where B='b2'
waitfor delay '00:00:30' --等待30秒
commit tran
在第二个连接中执行以下语句
begin tran
select * from table1
where B='b2'
commit tran

若同时执行上述两个语句，则select查询必须等待update执行完毕才能执行即要等待30秒

互斥锁（Mutex）

互斥锁是一个互斥的同步对象，意味着同一时间有且仅有一个线程可以获取它。

互斥锁可适用于一个共享资源每次只能被一个线程访问的情况

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
using System.Threading;
  
namespace MyTTCon
{
    class shareRes
    {
        public static int count = 0;
        public static Mutex mutex = new Mutex();
    }
  
    class IncThread
    {
        int number;
        public Thread thrd;
        public IncThread(string name,int n)
        {
            thrd = new Thread(this.run);
            number = n;
            thrd.Name = name;
            thrd.Start();
        }
        void run()
        {
            Console.WriteLine(thrd.Name + "正在等待 the mutex");
            //申请
            shareRes.mutex.WaitOne();
            Console.WriteLine(thrd.Name + "申请到 the mutex");
            do
            {
                Thread.Sleep(1000);
                shareRes.count++;
                Console.WriteLine("In " + thrd.Name + "ShareRes.count is " + shareRes.count);
                number--;
            } while (number > 0);
            Console.WriteLine(thrd.Name + "释放 the nmutex");
            //  释放
            shareRes.mutex.ReleaseMutex();
        }
    }
    class DecThread
    {
        int number;
        public Thread thrd;
        public DecThread(string name,int n)
        {
            thrd = new Thread(this.run);
            number = n;
            thrd.Name = name;
            thrd.Start();
        }
        void run()
        {
            Console.WriteLine(thrd.Name + "正在等待 the mutex");
            //申请
            shareRes.mutex.WaitOne();
            Console.WriteLine(thrd.Name + "申请到 the mutex");
            do
            {
                Thread.Sleep(1000);
                shareRes.count--;
                Console.WriteLine("In " + thrd.Name + "ShareRes.count is " + shareRes.count);
                number--;
            } while (number > 0);
            Console.WriteLine(thrd.Name + "释放 the nmutex");
            //  释放
            shareRes.mutex.ReleaseMutex();
        }
    }
  
    class Program
    {
        static void Main(string[] args)
        {
            IncThread mthrd1 = new IncThread("IncThread thread ",5);
            DecThread mthrd2 = new DecThread("DecThread thread ",5);
            mthrd1.thrd.Join();
            mthrd2.thrd.Join();
        }
    }
}

?小结：

　　悲观锁：查询加锁 【select ...... for update】

　　乐观锁：修改加锁 【版本号控制】

　　排它锁：事务A可以查询、修改，直到事务A释放为止才可以执行下一个事务

　　共享锁：事务A可以查询、修改，同时事务B也可以查询但不能修改

　　互斥锁：同一资源同一时间只能被一个线程访问

参考：http://bbs.csdn.net/topics/360017582

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!