搜索到
43
篇与
后端
的结果
-
Mysql批量更新的四种方式 逐条update的弊端最近做一个需求，更新2w条数据，一个一个update去更新的，结果花了30分钟，这样性能上很差，也容易阻塞，所以就找了一些MySQL批量更新的方式，在此记录一下方法一；replace into{message type="warning" content="这种更新会将其它字段更新为默认值，因为它是先将重复记录删掉再更新，如果更新的字段不全会将缺失的字段置为缺省值,谨慎使用"/}replace into `user` (id,age) values (1,'2'),(2,'3'),(3,'4'),(4,'98'); -- > 时间: 0.038s 方法二：insert into [table] values… on duplicate key update (Mysql独有的语法)。这种方式应该也是删掉记录，再更新，但是保存的原来的其它字段数据，所以其它字段不会改变insert into `user`(id,age) values (1,'5'),(2,'7'),(3,'2'),(4,'198') on duplicate key update age=values(age) -- > > 时间: 0.017s 方法三：创建临时表创建临时表，将更新数据插入临时表，再执行更新，需要有 建表权限DROP TABLE if EXISTS tmp; -- > 时间: 0.016s create temporary table tmp(id int(4) primary key,age varchar(50)); -- > 时间: 0.01s insert into tmp values (1,'13'), (2,'16'),(3,'18'),(4,'18'); -- > 时间: 0.009s update `user`, tmp set `user`.age=tmp.age where `user`.id=tmp.id; -- > 时间: 0.022s 方法四：使用MySQL自带批量更新语句update `user` set age = CASE id WHEN 1 THEN '22' WHEN 2 THEN '22' WHEN 3 THEN '22' WHEN 4 THEN '22' END WHERE id IN(1,2,3,4); -- > 时间: 0.015s update (表名) set (更新字段) = case (被更新字段) when (被更新字段值) then (更新字段值)... end where (被更新字段) in((被更新字段值)...) {card-describe title="举例说明"}set age = CASE id WHEN 1 THEN ‘22’简单来说就是以id为查询条件，当id=1时更新age=22，后面的where语句只是为了提高sql的执行效率，先过滤需要修改的记录然后再更新。{/card-describe} -
PHP实现拖拽排序功能接口 思路先分析一个场景，假如有一个页面有十条数据，所谓的拖拽就是在这十条数据来来回回的拖，但是每次拖动都会影响到其他数据例如把最后一条拖到最前面，那么后面九条就自动往后移，反之也是，嗯~~~ 先想象一下，排序号是固定的，就好像有十把椅子，每个椅子都是固定在那里的，移动的是上面的人，这样就不会影响到其他页面的数据了而且每个人换的也是之前其他人的桌椅号码，这样也不用去想到底要加多少才能排在哪里。代码实现//$ids 这十条数据的id集合，逗号隔开的字符串 //$oldIndex 原始位置，从0开始算 //$newIndex 要拖动到的位置 function dragSort($ids,$oldIndex,$newIndex) { //保证查找出来的数据跟前台提交的顺序一致，这里要用到mysql的 order by field() //id 主键 sort 排序值 $sql = "select id,sort from 表名字 where id in ($ids) order by field(id, " . $ids . ") "; $list = "这里省略，就是数据库返回的二维数组数据记录"; //id集合 $idArr = []; //排序集合 $sortArr = []; foreach ($list as $item) { $idArr[] = $item['id']; $sortArr[] = $item['sort']; } /* 或者 $idArr=array_column($list, 'id'); $sortArr=array_column($list, 'sort'); */ //记录要拖动记录的id $oldValue = $idArr[$oldIndex]; //删除这个要拖动的id unset($idArr[$oldIndex]); //插入新的位置，并自动移位 array_splice($idArr, $newIndex, 0, $oldValue); //重新设置排序 $set = []; for ($i = 0; $i < count($idArr); $i++) { $set[$i]['id'] = $idArr[$i]; $set[$i]['sort'] = $sortArr[$i]; } //保存到数据库省略① } {callout color="#f0ad4e"}@数据库批量更新四种方式{/callout}
-
如何保证缓存与数据库双写时的数据一致性 如何保证缓存与数据库双写时的数据一致性？在做系统优化时，想到了将数据进行分级存储的思路。因为在系统中会存在一些数据，有些数据的实时性要求不高，比如一些配置信息。基本上配置了很久才会变一次。而有一些数据实时性要求非常高，比如订单和流水的数据。所以这里根据数据要求实时性不同将数据分为三级。第1级：订单数据和支付流水数据；这两块数据对实时性和精确性要求很高，所以不添加任何缓存，读写操作将直接操作数据库。第2级：用户相关数据；这些数据和用户相关，具有读多写少的特征，所以我们使用redis进行缓存。第3级：支付配置信息；这些数据和用户无关，具有数据量小，频繁读，几乎不修改的特征，所以我们使用本地内存进行缓存。但是只要使用到缓存，无论是本地内存做缓存还是使用 redis 做缓存，那么就会存在数据同步的问题，因为配置信息缓存在内存中，而内存时无法感知到数据在数据库的修改。这样就会造成数据库中的数据与缓存中数据不一致的问题。接下来就讨论一下关于保证缓存和数据库双写时的数据一致性。解决方案那么我们这里列出来所有策略，并且讨论他们优劣性。先更新数据库，后更新缓存先更新数据库，后删除缓存先更新缓存，后更新数据库先删除缓存，后更新数据库先更新数据库，后更新缓存这种场景一般是没有人使用的，主要原因是在更新缓存那一步，为什么呢？因为有的业务需求缓存中存在的值并不是直接从数据库中查出来的，有的是需要经过一系列计算来的缓存值，那么这时候后你要更新缓存的话其实代价是很高的。如果此时有大量的对数据库进行写数据的请求，但是读请求并不多，那么此时如果每次写请求都更新一下缓存，那么性能损耗是非常大的。举个例子比如在数据库中有一个值为 1 的值，此时我们有 10 个请求对其每次加一的操作，但是这期间并没有读操作进来，如果用了先更新数据库的办法，那么此时就会有十个请求对缓存进行更新，会有大量的冷数据产生，如果我们不更新缓存而是删除缓存，那么在有读请求来的时候那么就会只更新缓存一次。先更新缓存，后更新数据库这一种情况应该不需要我们考虑了吧，和第一种情况是一样的。先删除缓存，后更新数据库该方案也会出问题，具体出现的原因如下。此时来了两个请求，请求 A（更新操作） 和请求 B（查询操作）请求 A 会先删除 Redis 中的数据，然后去数据库进行更新操作此时请求 B 看到 Redis 中的数据时空的，会去数据库中查询该值，补录到 Redis 中但是此时请求 A 并没有更新成功，或者事务还未提交那么这时候就会产生数据库和 Redis 数据不一致的问题。如何解决呢？其实最简单的解决办法就是延时双删的策略。但是上述的保证事务提交完以后再进行删除缓存还有一个问题，就是如果你使用的是 Mysql 的读写分离的架构的话，那么其实主从同步之间也会有时间差。此时来了两个请求，请求 A（更新操作） 和请求 B（查询操作）请求 A 更新操作，删除了 Redis请求主库进行更新操作，主库与从库进行同步数据的操作请 B 查询操作，发现 Redis 中没有数据去从库中拿去数据此时同步数据还未完成，拿到的数据是旧数据此时的解决办法就是如果是对 Redis 进行填充数据的查询数据库操作，那么就强制将其指向主库进行查询。先更新数据库，后删除缓存问题：这一种情况也会出现问题，比如更新数据库成功了，但是在删除缓存的阶段出错了没有删除成功，那么此时再读取缓存的时候每次都是错误的数据了。此时解决方案就是利用消息队列进行删除的补偿。具体的业务逻辑用语言描述如下：请求 A 先对数据库进行更新操作在对 Redis 进行删除操作的时候发现报错，删除失败此时将Redis 的 key 作为消息体发送到消息队列中系统接收到消息队列发送的消息后再次对 Redis 进行删除操作但是这个方案会有一个缺点就是会对业务代码造成大量的侵入，深深的耦合在一起，所以这时会有一个优化的方案，我们知道对 Mysql 数据库更新操作后再 binlog 日志中我们都能够找到相应的操作，那么我们可以订阅 Mysql 数据库的 binlog 日志对缓存进行操作。总结每种方案各有利弊，比如在第二种先删除缓存，后更新数据库这个方案我们最后讨论了要更新 Redis 的时候强制走主库查询就能解决问题，那么这样的操作会对业务代码进行大量的侵入，但是不需要增加的系统，不需要增加整体的服务的复杂度。最后一种方案我们最后讨论了利用订阅 binlog 日志进行搭建独立系统操作 Redis，这样的缺点其实就是增加了系统复杂度。其实每一次的选择都需要我们对于我们的业务进行评估来选择，没有一种技术是对于所有业务都通用的。没有最好的，只有最适合我们的。
-
用PHP与Redis实现单据锁，防止并发重复写入数据 一、何为单据锁：在整个供应链系统中，会有很多种单据（采购单、入库单、到货单、运单等等），在涉及写单据数据的接口时（增删改操作），即使前端做了相关限制，还是有可能因为网络或异常操作产生并发重复调用的情况，导致对相同单据做相同的处理；为了防止这种情况对系统造成异常影响，我们通过Redis实现了一个简单的单据锁，每个请求需先获取锁才能执行业务逻辑，执行结束后才会释放锁；保证了同一单据的并发重复操作请求只有一个请求可以获取到锁（依赖Redis的单线程），是一种悲观锁的设计；注：Redis锁在我们的系统中一般只用于解决并发重复请求的情况，对于非并发的的重复请求一般会去数据库或日志校验数据的状态，两种机制结合起来才能保证整个链路的可靠。二、加锁机制：主要依赖Redis setnx指令实现：但使用setnx有一个问题，即setnx指令不支持设置过期时间，需要使用expire指令另行为key设置超时时间。这样整个加锁操作就不是一个原子性操作，有可能存在setnx加锁成功，但因程序异常退出导致未成功设置超时时间，在不及时解锁的情况下，有可能会导致死锁（即使业务场景中不会出现死锁，无用的key一直常驻内存也不是很好的设计）；这种情况可以使用Redis事务解决，把setnx与expire两条指令作为一个原子性操作执行，但这样做相对而言会比较麻烦，好在Redis 2.6.12之后版本，Redis set指令支持了nx、ex模式，并支持原子化地设置过期时间：三、加锁实现（完整测试代码会贴在最后）：/** * 加单据锁 * @param int $intOrderId 单据ID * @param int $intExpireTime 锁过期时间（秒） * @return bool|int 加锁成功返回唯一锁ID，加锁失败返回false */ public static function addLock($intOrderId, $intExpireTime = self::REDIS_LOCK_DEFAULT_EXPIRE_TIME) { //参数校验 if (empty($intOrderId) || $intExpireTime <= 0) { return false; } //获取Redis连接 $objRedisConn = self::getRedisConn(); //生成唯一锁ID，解锁需持有此ID $intUniqueLockId = self::generateUniqueLockId(); //根据模板，结合单据ID，生成唯一Redis key（一般来说，单据ID在业务中系统中唯一的） $strKey = sprintf(self::REDIS_LOCK_KEY_TEMPLATE, $intOrderId); //加锁（通过Redis setnx指令实现，从Redis 2.6.12开始，通过set指令可选参数也可以实现setnx，同时可原子化地设置超时时间） $bolRes = $objRedisConn->set($strKey, $intUniqueLockId, ['nx', 'ex'=>$intExpireTime]); //加锁成功返回锁ID，加锁失败返回false return $bolRes ? $intUniqueLockId : $bolRes; }四、解锁机制：解锁即比对加锁时的唯一lock id，如果比对成功，则删除key；需要注意的是，解锁整个过程中同样需要保证原子性，这里依赖redis的watch与事务实现；WATCH命令可以监控一个或多个键，一旦其中有一个键被修改（或删除），之后的事务就不会执行。监控一直持续到EXEC命令（事务中的命令是在EXEC之后才执行的，所以在MULTI命令后可以修改WATCH监控的键值）五、解锁实现（完整测试代码会贴在最后）：/** * 解单据锁 * @param int $intOrderId 单据ID * @param int $intLockId 锁唯一ID * @return bool */ public static function releaseLock($intOrderId, $intLockId) { //参数校验 if (empty($intOrderId) || empty($intLockId)) { return false; } //获取Redis连接 $objRedisConn = self::getRedisConn(); //生成Redis key $strKey = sprintf(self::REDIS_LOCK_KEY_TEMPLATE, $intOrderId); //监听Redis key防止在【比对lock id】与【解锁事务执行过程中】被修改或删除，提交事务后会自动取消监控，其他情况需手动解除监控 $objRedisConn->watch($strKey); if ($intLockId == $objRedisConn->get($strKey)) { $objRedisConn->multi()->del($strKey)->exec(); return true; } $objRedisConn->unwatch(); return false; }六、附整体测试代码（此代码仅为简易版本）<?php /** * Class Lock_Service 单据锁服务 */ class Lock_Service { /** * 单据锁redis key模板 */ const REDIS_LOCK_KEY_TEMPLATE = 'order_lock_%s'; /** * 单据锁默认超时时间（秒） */ const REDIS_LOCK_DEFAULT_EXPIRE_TIME = 86400; /** * 加单据锁 * @param int $intOrderId 单据ID * @param int $intExpireTime 锁过期时间（秒） * @return bool|int 加锁成功返回唯一锁ID，加锁失败返回false */ public static function addLock($intOrderId, $intExpireTime = self::REDIS_LOCK_DEFAULT_EXPIRE_TIME) { //参数校验 if (empty($intOrderId) || $intExpireTime <= 0) { return false; } //获取Redis连接 $objRedisConn = self::getRedisConn(); //生成唯一锁ID，解锁需持有此ID $intUniqueLockId = self::generateUniqueLockId(); //根据模板，结合单据ID，生成唯一Redis key（一般来说，单据ID在业务中系统中唯一的） $strKey = sprintf(self::REDIS_LOCK_KEY_TEMPLATE, $intOrderId); //加锁（通过Redis setnx指令实现，从Redis 2.6.12开始，通过set指令可选参数也可以实现setnx，同时可原子化地设置超时时间） $bolRes = $objRedisConn->set($strKey, $intUniqueLockId, ['nx', 'ex'=>$intExpireTime]); //加锁成功返回锁ID，加锁失败返回false return $bolRes ? $intUniqueLockId : $bolRes; } /** * 解单据锁 * @param int $intOrderId 单据ID * @param int $intLockId 锁唯一ID * @return bool */ public static function releaseLock($intOrderId, $intLockId) { //参数校验 if (empty($intOrderId) || empty($intLockId)) { return false; } //获取Redis连接 $objRedisConn = self::getRedisConn(); //生成Redis key $strKey = sprintf(self::REDIS_LOCK_KEY_TEMPLATE, $intOrderId); //监听Redis key防止在【比对lock id】与【解锁事务执行过程中】被修改或删除，提交事务后会自动取消监控，其他情况需手动解除监控 $objRedisConn->watch($strKey); if ($intLockId == $objRedisConn->get($strKey)) { $objRedisConn->multi()->del($strKey)->exec(); return true; } $objRedisConn->unwatch(); return false; } /** * Redis配置：IP */ const REDIS_CONFIG_HOST = '127.0.0.1'; /** * Redis配置：端口 */ const REDIS_CONFIG_PORT = 6379; /** * 获取Redis连接（简易版本，可用单例实现） * @param string $strIp IP * @param int $intPort 端口 * @return object Redis连接 */ public static function getRedisConn($strIp = self::REDIS_CONFIG_HOST, $intPort = self::REDIS_CONFIG_PORT) { $objRedis = new Redis(); $objRedis->connect($strIp, $intPort); return $objRedis; } /** * 用于生成唯一的锁ID的redis key */ const REDIS_LOCK_UNIQUE_ID_KEY = 'lock_unique_id'; /** * 生成锁唯一ID（通过Redis incr指令实现简易版本，可结合日期、时间戳、取余、字符串填充、随机数等函数，生成指定位数唯一ID） * @return mixed */ public static function generateUniqueLockId() { return self::getRedisConn()->incr(self::REDIS_LOCK_UNIQUE_ID_KEY); } } //test $res1 = Lock_Service::addLock('666666'); var_dump($res1);//返回lock id，加锁成功 $res2 = Lock_Service::addLock('666666'); var_dump($res2);//false，加锁失败 $res3 = Lock_Service::releaseLock('666666', $res1); var_dump($res3);//true，解锁成功 $res4 = Lock_Service::releaseLock('666666', $res1); var_dump($res4);//false，解锁失败
-
[精选] 这篇MySQL锁写的很有深度，请深入 首先对mysql锁进行划分：按照锁的粒度划分：行锁、表锁、页锁按照锁的使用方式划分：共享锁、排它锁（悲观锁的一种实现）还有两种思想上的锁：悲观锁、乐观锁。InnoDB中有几种行级锁类型：Record Lock、Gap Lock、Next-key LockRecord Lock：在索引记录上加锁Gap Lock：间隙锁Next-key Lock：Record Lock+Gap Lock1.行锁 行级锁是Mysql中锁定粒度最细的一种锁，表示只针对当前操作的行进行加锁。行级锁能大大减少数据库操作的冲突。其加锁粒度最小，但加锁的开销也最大。有可能会出现死锁的情况。 行级锁按照使用方式分为共享锁和排他锁。共享锁用法（S锁 读锁）： 若事务T对数据对象A加上S锁，则事务T可以读A但不能修改A，其他事务只能再对A加S锁，而不能加X锁，直到T释放A上的S锁。这保证了其他事务可以读A，但在T释放A上的S锁之前不能对A做任何修改。select ... lock in share mode; 共享锁就是允许多个线程同时获取一个锁，一个锁可以同时被多个线程拥有。排它锁用法（X 锁 写锁）： 若事务T对数据对象A加上X锁，事务T可以读A也可以修改A，其他事务不能再对A加任何锁，直到T释放A上的锁。这保证了其他事务在T释放A上的锁之前不能再读取和修改A。select ... for update 排它锁，也称作独占锁，一个锁在某一时刻只能被一个线程占有，其它线程必须等待锁被释放之后才可能获取到锁。2.表锁 表级锁是mysql锁中粒度最大的一种锁，表示当前的操作对整张表加锁，资源开销比行锁少，不会出现死锁的情况，但是发生锁冲突的概率很大。被大部分的mysql引擎支持，MyISAM和InnoDB都支持表级锁，但是InnoDB默认的是行级锁。共享锁用法：LOCK TABLE table_name [ AS alias_name ] READ 排它锁用法：LOCK TABLE table_name [AS alias_name][ LOW_PRIORITY ] WRITE 解锁用法：unlock tables; 3.页锁 页级锁是MySQL中锁定粒度介于行级锁和表级锁中间的一种锁。表级锁速度快，但冲突多，行级冲突少，但速度慢。所以取了折衷的页级，一次锁定相邻的一组记录。BDB支持页级锁4.乐观锁和悲观锁 在数据库的锁机制中介绍过，数据库管理系统（DBMS）中的并发控制的任务是确保在多个事务同时存取数据库中同一数据时不破坏事务的隔离性和统一性以及数据库的统一性。 乐观并发控制(乐观锁)和悲观并发控制（悲观锁）是并发控制主要采用的技术手段。 无论是悲观锁还是乐观锁，都是人们定义出来的概念，可以认为是一种思想。其实不仅仅是关系型数据库系统中有乐观锁和悲观锁的概念，像memcache、hibernate、tair等都有类似的概念。 针对于不同的业务场景，应该选用不同的并发控制方式。所以，不要把乐观并发控制和悲观并发控制狭义的理解为DBMS中的概念，更不要把他们和数据中提供的锁机制（行锁、表锁、排他锁、共享锁）混为一谈。其实，在DBMS中，悲观锁正是利用数据库本身提供的锁机制来实现的。4.1悲观锁 在关系数据库管理系统里，悲观并发控制（又名“悲观锁”，Pessimistic Concurrency Control，缩写“PCC”）是一种并发控制的方法。它可以阻止一个事务以影响其他用户的方式来修改数据。如果一个事务执行的操作对某行数据应用了锁，那只有当这个事务把锁释放，其他事务才能够执行与该锁冲突的操作。悲观并发控制主要用于数据争用激烈的环境，以及发生并发冲突时使用锁保护数据的成本要低于回滚事务的成本的环境中。 悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度(悲观)，因此，在整个数据处理过程中，将数据处于锁定状态。 悲观锁的实现，往往依靠数据库提供的锁机制 （也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）悲观锁的具体流程：在对任意记录进行修改前，先尝试为该记录加上排他锁（exclusive locking）如果加锁失败，说明该记录正在被修改，那么当前查询可能要等待或者抛出异常。 具体响应方式由开发者根据实际需要决定。如果成功加锁，那么就可以对记录做修改，事务完成后就会解锁了。其间如果有其他对该记录做修改或加排他锁的操作，都会等待我们解锁或直接抛出异常。在mysql/InnoDB中使用悲观锁： 首先我们得关闭mysql中的autocommit属性，因为mysql默认使用自动提交模式，也就是说当我们进行一个sql操作的时候，mysql会将这个操作当做一个事务并且自动提交这个操作。1.开始事务 begin;/begin work;/start transaction; (三者选一就可以) 2.查询出商品信息 select ... for update; 4.提交事务 commit;/commit work; 通过下面的例子来说明：1.当你手动加上排它锁，但是并没有关闭mysql中的autocommit。SESSION1: mysql> select * from user for update; +----+------+--------+ | id | name | psword | +----+------+--------+ | 1 | a | 1 | | 2 | b | 2 | | 3 | c | 3 | +----+------+--------+ 3 rows in set 这里他会一直提示Unknown mysql> update user set name=aa where id=1; 1054 - Unknown column 'aa' in 'field list' mysql> insert into user values(4,d,4); 1054 - Unknown column 'd' in 'field list' 2.正常流程窗口1： mysql> set autocommit=0; Query OK, 0 rows affected 我这里锁的是表 mysql> select * from user for update; +----+-------+ | id | price | +----+-------+ | 1 | 500 | | 2 | 800 | +----+-------+ 2 rows in set 窗口2： mysql> update user set price=price-100 where id=1; 执行上面操作的时候，会显示等待状态，一直到窗口1执行commit提交事务才会出现下面的显示结果 Database changed Rows matched: 1 Changed: 1 Warnings: 0 窗口1： mysql> commit; Query OK, 0 rows affected mysql> select * from user; +----+-------+ | id | price | +----+-------+ | 1 | 400 | | 2 | 800 | +----+-------+ 2 rows in set 上面的例子展示了排它锁的原理：一个锁在某一时刻只能被一个线程占有，其它线程必须等待锁被释放之后才可能获取到锁或者进行数据的操作。悲观锁的优点和不足： 悲观锁实际上是采取了“先取锁在访问”的策略，为数据的处理安全提供了保证，但是在效率方面，由于额外的加锁机制产生了额外的开销，并且增加了死锁的机会。并且降低了并发性；当一个事物所以一行数据的时候，其他事物必须等待该事务提交之后，才能操作这行数据。4.2乐观锁在关系数据库管理系统里，乐观并发控制（又名“乐观锁”，Optimistic Concurrency Control，缩写“OCC”）是一种并发控制的方法。它假设多用户并发的事务在处理时不会彼此互相影响，各事务能够在不产生锁的情况下处理各自影响的那部分数据。在提交数据更新之前，每个事务会先检查在该事务读取数据后，有没有其他事务又修改了该数据。如果其他事务有更新的话，正在提交的事务会进行回滚。 乐观锁（ Optimistic Locking ） 相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。 相对于悲观锁，在对数据库进行处理的时候，乐观锁并不会使用数据库提供的锁机制。一般的实现乐观锁的方式就是记录数据版本。数据版本,为数据增加的一个版本标识。当读取数据时，将版本标识的值一同读出，数据每更新一次，同时对版本标识进行更新。当我们提交更新的时候，判断数据库表对应记录的当前版本信息与第一次取出来的版本标识进行比对，如果数据库表当前版本号与第一次取出来的版本标识值相等，则予以更新，否则认为是过期数据。乐观锁的优点和不足： 乐观并发控制相信事务之间的数据竞争(data race)的概率是比较小的，因此尽可能直接做下去，直到提交的时候才去锁定，所以不会产生任何锁和死锁。但如果直接简单这么做，还是有可能会遇到不可预期的结果，例如两个事务都读取了数据库的某一行，经过修改以后写回数据库，这时就遇到了问题。5.1InnoDB锁的特性在不通过索引条件查询的时候，InnoDB使用的确实是表锁！由于 MySQL 的行锁是针对索引加的锁,不是针对记录加的锁,所以虽然是访问不同行 的记录,但是如果是使用相同的索引键,是会出现锁冲突的。当表有多个索引的时候,不同的事务可以使用不同的索引锁定不同的行,另外,不论 是使用主键索引、唯一索引或普通索引,InnoDB 都会使用行锁来对数据加锁。即便在条件中使用了索引字段,但是否使用索引来检索数据是由 MySQL 通过判断不同 执行计划的代价来决定的,如果 MySQL 认为全表扫 效率更高,比如对一些很小的表,它 就不会使用索引,这种情况下 InnoDB 将使用表锁,而不是行锁。因此,在分析锁冲突时, 别忘了检查 SQL 的执行计划（explain查看）,以确认是否真正使用了索引。有关执行计划的解释可以看着这篇文章：https://www.jianshu.com/p/b5c01bd4a3061.通过非索引项检索数据，加表锁！price属性并没有加索引，因此这时候添加的锁为表级锁！ 窗口1： mysql> select * from product where price=88 for update; +----+------+-------+-----+ | id | name | price | num | +----+------+-------+-----+ | 2 | 蒙牛 | 88 | 1 | +----+------+-------+-----+ 窗口2： mysql> update product set price=price-100 where id=6; 这里会等待，直到窗口1 commit后显示下面结果！ Query OK, 1 row affected Rows matched: 1 Changed: 1 Warnings: 0 2.使用相同索引值但是不同行引发的冲突这里的num属性 加上了普通索引，price属性并没有索引 窗口1： mysql> set autocommit=0; Query OK, 0 rows affected mysql> select * from product where num=1 and price=68 for update; +----+------+-------+-----+ | id | name | price | num | +----+------+-------+-----+ | 1 | 伊利 | 68 | 1 | +----+------+-------+-----+ 窗口2： mysql> update product set price=price+100 where num=1 and price=88; 这里会发生等待，直到窗口1 commit 显示下面结果 Query OK, 1 row affected Rows matched: 1 Changed: 1 Warnings: 0 mysql> select * from product; +----+----------+-------+-----+ | id | name | price | num | +----+----------+-------+-----+ | 1 | 伊利 | 68 | 1 | | 2 | 蒙牛 | 188 | 1 | +----+----------+-------+-----+ 3.当使用索引检索数据时不同事务可以操作不同行数据锁一行数据，DML操作其他行并没有影响 窗口1： mysql> select * from user where id=1 for update; +----+-------+ | id | price | +----+-------+ | 1 | 400 | +----+-------+ 窗口2： mysql> update user set price=price+100 where id=2; 无需等待窗口1 commit Database changed Rows matched: 1 Changed: 1 Warnings: 0 6.Record Lock、Gap Lock、Next-key Lock锁6.1.Record Lock 单条索引上加锁，record lock 永远锁的是索引，而非数据本身，如果innodb表中没有索引，那么会自动创建一个隐藏的聚集索引，锁住的就是这个聚集索引。所以说当一条sql没有走任何索引时，那么将会在每一条聚集索引后面加X锁，这个类似于表锁，但原理上和表锁应该是完全不同的。6.2.Gap Lock 间隙锁，是在索引的间隙之间加上锁，这是为什么Repeatable Read隔离级别下能防止幻读的主要原因。有关幻读的详细解释：https://blog.csdn.net/qq_38238296/article/details/883630176.2.1 什么叫间隙锁 直接通过例子来说明：mysql> select * from product_copy; +----+--------+-------+-----+ | id | name | price | num | +----+--------+-------+-----+ | 1 | 伊利 | 68 | 1 | | 2 | 蒙牛 | 88 | 1 | | 6 | tom | 2788 | 3 | | 10 | 优衣库 | 488 | 4 | +----+--------+-------+-----+ 其中id为主键 num为普通索引 窗口A： mysql> select * from product_copy where num=3 for update; +----+------+-------+-----+ | id | name | price | num | +----+------+-------+-----+ | 6 | tom | 2788 | 3 | +----+------+-------+-----+ 1 row in set 窗口B： mysql> insert into product_copy values(5,'kris',1888,2); 这里会等待 直到窗口A commit才会显示下面结果 Query OK, 1 row affected 但是下面是不需要等待的 mysql> update product_copy set price=price+100 where num=1; Query OK, 2 rows affected Rows matched: 2 Changed: 2 Warnings: 0 mysql> insert into product_copy values(5,'kris',1888,5); Query OK, 1 row affected 通过上面的例子可以看出Gap 锁的作用是在1,3的间隙之间加上了锁。而且并不是锁住了表，我更新num=1，5的数据是可以的.可以看出锁住的范围是（1,3]U[3,4)。6.2.2 为什么说gap锁是RR隔离级别下防止幻读的主要原因。首先得理解什么是幻读：https://blog.csdn.net/qq_38238296/article/details/88363017解决幻读的方式很简单，就是需要当事务进行当前读的时候，保证其他事务不可以在满足当前读条件的范围内进行数据操作。根据索引的有序性，我们可以从上面的例子推断出满足where条件的数据，只能插入在num=（1,3]U[3,4)两个区间里面，只要我们将这两个区间锁住，那么就不会发生幻读。6.2.3. 主键索引/唯一索引+当前读会加上Gap锁吗？直接通过例子来说明窗口A： mysql> select * from product_copy where id=6 for update; +----+------+-------+-----+ | id | name | price | num | +----+------+-------+-----+ | 6 | tom | 2788 | 3 | +----+------+-------+-----+ 窗口B：并不会发生等待 mysql> insert into product_copy values(5,'kris',1888,3); Query OK, 1 row affected 例子说明的其实就是行锁的原因，我只将id=6的行数据锁住了，用Gap锁的原理来解释的话：因为主键索引和唯一索引的值只有一个，所以满足检索条件的只有一行，故并不会出现幻读，所以并不会加上Gap锁。6.2.4通过范围查询是否会加上Gap锁 前面的例子都是通过等值查询，下面测试一下范围查询。窗口A： mysql> select * from product_copy where num>3 for update; +----+--------+-------+-----+ | id | name | price | num | +----+--------+-------+-----+ | 10 | 优衣库 | 488 | 4 | +----+--------+-------+-----+ 窗口B：会等待 mysql> insert into product_copy values(11,'kris',1888,5); Query OK, 1 row affected 不会等待 mysql> insert into product_copy values(3,'kris',1888,2); Query OK, 1 row affected 其实原因都是一样，只要满足检索条件的都会加上Gap锁6.2.5 检索条件并不存在的当前读会加上Gap吗？1.等值查询窗口A： mysql> select * from product_copy where num=5 for update; Empty set 窗口B：6 和 4都会等待 mysql> insert into product_copy values(11,'kris',1888,6); Query OK, 1 row affected mysql> insert into product_copy values(11,'kris',1888,4); Query OK, 1 row affected 原因一样会锁住（4,5]U[5,n）的区间2.范围查询这里就会有点不一样窗口A： mysql> select * from product_copy where num>6 for update; Empty set 窗口B：8 和 4 都会锁住 mysql> insert into product_copy values(11,'kris',1888,4); Query OK, 1 row affected mysql> insert into product_copy values(11,'kris',1888,8); Query OK, 1 row affected 上面的2例子看出当你查询并不存在的数据的时候，mysql会将有可能出现区间全部锁住。6.3.Next-Key Lock这个锁机制其实就是前面两个锁相结合的机制，既锁住记录本身还锁住索引之间的间隙。7.死锁的原理及分析7.1. MVCC MySQL InnoDB存储引擎，实现的是基于多版本并发控制协议—MVCC(Multi-Version Concurrency Control) MVCC最大的好处，相信也是耳熟能详：读不加锁，读写不冲突。在读多写少的OLTP应用中，读写不冲突是非常重要的，极大的增加了系统的并发性能，这也是为什么现阶段，几乎所有的RDBMS，都支持了MVCC。7.2. 2PL：Two-Phase Locking 传统RDBMS（关系数据库管理系统）加锁的一个原则，就是2PL (二阶段锁)：Two-Phase Locking。相对而言，2PL比较容易理解，说的是锁操作分为两个阶段：加锁阶段与解锁阶段，并且保证加锁阶段与解锁阶段不相交。下面，仍旧以MySQL为例，来简单看看2PL在MySQL中的实现。transactionmysqlbegin;加锁阶段insert into加insert对应的锁update table加update对应的锁delete from加delete对应的锁commit解锁阶段 将insert、update、delete的锁全部解开 上面的例子可以看出2PL就是将加锁、解锁分为两个阶段，并且互相不干扰。加锁阶段只加锁，解锁阶段只解锁。7.3 为什么会发生死锁 MyISAM中是不会产生死锁的，因为MyISAM总是一次性获得所需的全部锁，要么全部满足，要么全部等待。而在InnoDB中，锁是逐步获得的，就造成了死锁的可能。（不过现在一般都是InnoDB引擎，关于MyISAM不做考虑） 在InnoDB中，行级锁并不是直接锁记录，而是锁索引。索引分为主键索引和非主键索引两种，如果一条sql语句操作了主键索引，MySQL就会锁定这条主键索引；如果一条语句操作了非主键索引，MySQL会先锁定该非主键索引，再锁定相关的主键索引。 当两个事务同时执行，一个锁住了主键索引，在等待其他相关索引。另一个锁定了非主键索引，在等待主键索引。这样就会发生死锁。通过两个SQL死锁的例子来说明1.两个session的两条语句 这种情况很好理解，首先session1获得 id=1的锁 session2获得id=5的锁，然后session想要获取id=5的锁 等待，session2想要获取id=1的锁 ，也等待！2.两个session的一条语句 这种情况需要我们了解数据的索引的检索顺序原理简单说下：普通索引上面保存了主键索引，当我们使用普通索引检索数据时，如果所需的信息不够，那么会继续遍历主键索引。 假设默认情况是RR隔离级别，针对session 1 从name索引出发，检索到的是（hdc,1）（hdc,6）不仅会加name索引上的记录X锁，而且会加聚簇索引上的记录X锁，加锁顺序为先[1,hdc,100]，后[6,hdc,10] 这个顺序是因为B+树结构的有序性。而Session 2，从pubtime索引出发，[10,6],[100,1]均满足过滤条件，同样也会加聚簇索引上的记录X锁，加锁顺序为[6,hdc,10]，后[1,hdc,100]。发现没有，跟Session 1的加锁顺序正好相反，如果两个Session恰好都持有了第一把锁，请求加第二把锁，死锁就发生了。避免死锁，这里只介绍常见的三种如果不同程序会并发存取多个表，尽量约定以相同的顺序访问表，可以大大降低死锁机会。在同一个事务中，尽可能做到一次锁定所需要的所有资源，减少死锁产生概率；对于非常容易产生死锁的业务部分，可以尝试使用升级锁定颗粒度，通过表级锁定来减少死锁产生的概率；
![[精选] 这篇MySQL锁写的很有深度，请深入](http://www.quhe.net/usr/uploads/2023/03/2084728866.png)