sql serve2008是否自带互斥锁

近期突然想到,一道珠海笔试题,让你写atm机的逻辑,当时想多了,以为重点是让你写清楚其中的事务互斥关系,当时也忘记数据库是否会自动互斥,从而不会出现脏数据。所以就敲了个代码实践了下。

例子还是老例子.....卖票..不会卖出脏数据为好。

线程函数:

static DWORD WINAPI Ticket1(LPVOID lp)

{
while(1){
  try{
    CppSQLDB db;
    //获取不是0则卖出
    string s = "select * from Ticket";
    db.ExectueQuery(s);

    if(db.Eof())
      return false;
    int ticket;
    db.GetIntValue("ticket",ticket);
    if(ticket>0){
      s = "update Ticket set ticket = ticket - 1";
      if(db.ExecuteDML(s))
      cout << "ticket 1 sale "<< tickets-- <<endl;
    }else{
      break;
    }
  }catch(_com_error& e){
      cout << "error 1 "<< e.Description() << endl;
     }
  }
  return 1;
}

当在多线程/进程的情况下,很容易想到,如果再某一时间,同时获取数据库得到票数为1,那么就可能卖出脏票,然而实际上通过sql中的触发器可以实现不会卖脏票,反之可以得出,数据库对一些更新的事务,会智能处理(应该是加锁),不会出现在某个时刻,同时执行了两次 ticket = ticket -1 而导致 ticket 只减少了一张,而卖出脏票。

CREATE trigger ticketTri on Ticket
for update
as
begin
  IF EXISTS(select * from Deleted where ticket < 1)
begin
  print ‘least‘;
  rollback;
end
end

时间: 2024-11-05 12:35:36

sql serve2008是否自带互斥锁的相关文章

SQL Server中的事务与锁

了解事务和锁 事务:保持逻辑数据一致性与可恢复性,必不可少的利器. 锁:多用户访问同一数据库资源时,对访问的先后次序权限管理的一种机制,没有他事务或许将会一塌糊涂,不能保证数据的安全正确读写. 死锁:是数据库性能的重量级杀手之一,而死锁却是不同事务之间抢占数据资源造成的. 不懂的听上去,挺神奇的,懂的感觉我在扯淡,下面带你好好领略下他们的风采,嗅査下他们的狂骚.. 先说事务--概念,分类 用华仔无间道中的一句来给你诠释下:去不了终点,回到原点. 举例说明: 在一个事务中,你写啦2条sql语句,一

C11线程管理:互斥锁

1.概述 锁类型 c11提供了跨平台的线程同步手段,用来保护多线程同时访问的共享数据. std::mutex,最基本的 Mutex 类,独占的互斥量,不能递归使用. std::time_mutex,带超时的独占互斥量,不能递归使用. std::recursive_mutex,递归互斥量,不带超时功能. std::recursive_timed_mutex,带超时的递归互斥量. lock类型 std::lock_guard,与 Mutex RAII 相关,方便线程对互斥量上锁. std::uniq

死锁现象与解决方案,开启线程的2种方式,守护线程,线程VS进程,线程互斥锁,信号量

死锁现象与解决方案 from threading import Thread,Lock,active_count import time mutexA=Lock() # 锁1 mutexB=Lock() # 锁2 class Mythread(Thread): def run(self): self.f1() self.f2() def f1(self): mutexA.acquire() print('%s 拿到A锁' %self.name) mutexB.acquire() print('%

基于(Redis | Memcache)实现分布式互斥锁

设计一个缓存系统,不得不要考虑的问题就是:缓存穿透.缓存击穿与失效时的雪崩效应. 缓存击穿 缓存穿透是指查询一个一定不存在的数据,由于缓存是不命中时被动写的,并且出于容错考虑,如果从存储层查不到数据则不写入缓存,这将导致这个不存在的数据每次请求都要到存储层去查询,失去了缓存的意义.在流量大时,可能DB就挂掉了,要是有人利用不存在的key频繁攻击我们的应用,这就是漏洞. 解决方案 有很多种方法可以有效地解决缓存穿透问题,最常见的则是采用布隆过滤器,将所有可能存在的数据哈希到一个足够大的bitmap

synchronized互斥锁实例解析

目录 synchronized互斥锁实例解析 1.互斥锁基础使用:防止多个线程访问对象的synchronized方法. 1.1.不加互斥锁时 1.2.加互斥锁后 2.脏读 2.1.不加锁 2.2.加锁后 java的内置锁:每个java对象都可以用做一个实现同步的锁,这些锁成为内置锁.线程进入同步代码块或方法的时候会自动获得该锁,在退出同步代码块或方法时会释放该锁.获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法. java内置锁是一个互斥锁. 对象锁是用于对象实例方法,或者一个对象实例

Python36 1.joinablequeue 2.线程理论 3.多线程对比多进程 4.线程的使用方式 4.1.产生 线程的两种方式 4.2.守护线程 4.3.线程安全问题 4.3.1.互斥锁 4.3.2.死锁 4.3.3.可重入锁 4.3.4.信号量

复习1.守护进程2.互斥锁(解决数据错乱的方法)3.IPC(进程间通讯)4.生产者与消费者模型 详解:1.守护进程 一个进程可以设为另一个进程的守护进程 特点:被守护的进程结束时,守护进程也会随之结束 本质:父进程交给子进程一个任务,然而父进程 先于子进程结束了,子进程的任务也就没有必要 继续执行了 格式:开始前加 p.daemon=True 2.互斥锁(解决数据错乱的方法)方法一:互斥锁 互斥 互相排斥 锁的本质:一个标志 标志的两个状态: 1.锁定 2.未锁定 什么时候用? 当多个进程要操作

10.22进程互斥锁,队列,堆栈,线程

进程互斥锁 让并发变成串行,牺牲了执行效率,保证了数据的安全. 在程序并发执行时,如果需要修改数据就使用互斥锁. 队列 相当于内存中的空间. 可以存放多个数据,必须排队,遵循先进先出的顺序. from multiprocessing import Queue #调用队列类,实例化队列对象q q = Queue(5) #若传参,队列中就可以存放5个数据 q = Queue() #若不传参,则队列中可以存放无限个数据 q.get() #获取数据 q.put() #添加数据,满了就报错 q.empty

进程,互斥锁,生产者消费者,线程

进程,互斥锁,生产者消费者,线程 一.僵尸进程与孤儿进程 代码演示 ''' 僵尸进程(有坏处): - 在子进程结束后,主进程没有正常结束,子进程的PID不会被回收. 缺点: - 操作系统中PID号是有限的,比如子进程PID号无法正常回收,则会占用PID号. - 资源浪费 - 若PID号满了,则无法创建新的进程. 孤儿进程(没有坏处): - 在子进程没有结束时,主进程没有"正常结束",子进程PID不会被回收. - 操作系统优化机制(孤儿院): 当主进程意外终止,操作系统会检测是否有正在运

【Java并发编程】之七:使用synchronized获取互斥锁的几点说明

 在并发编程中,多线程同时并发访问的资源叫做临界资源,当多个线程同时访问对象并要求操作相同资源时,分割了原子操作就有可能出现数据的不一致或数据不完整的情况,为避免这种情况的发生,我们会采取同步机制,以确保在某一时刻,方法内只允许有一个线程. 采用synchronized修饰符实现的同步机制叫做互斥锁机制,它所获得的锁叫做互斥锁.每个对象都有一个monitor(锁标记),当线程拥有这个锁标记时才能访问这个资源,没有锁标记便进入锁池.任何一个对象系统都会为其创建一个互斥锁,这个锁是为了分配给线程的,