文档章节

PHP使用数据库的并发问题

烫烫烫烫烫烫
 烫烫烫烫烫烫
发布于 2014/11/15 00:10
字数 1949
阅读 1539
收藏 56

原载于我的博客 http://starlight36.com/post/php-db-concurrency

在并行系统中并发问题永远不可忽视。尽管PHP语言原生没有提供多线程机制,那并不意味着所有的操作都是线程安全的。尤其是在操作诸如订单、支付等业务系统中,更需要注意操作数据库的并发问题。 接下来我通过一个案例分析一下PHP操作数据库时并发问题的处理问题。 

首先,我们有这样一张数据表:

mysql> select * from counter;
+----+-----+
| id | num |
+----+-----+
|  1 |   0 |
+----+-----+
1 row in set (0.00 sec)
这段代码模拟了一次业务操作:
<?php
function dummy_business() {
	$conn = mysqli_connect('127.0.0.1', 'public', 'public') or die(mysqli_error());
	mysqli_select_db($conn, 'test');
	for ($i = 0; $i < 10000; $i++) {
		mysqli_query($conn, 'UPDATE counter SET num = num + 1 WHERE id = 1');
	}
	mysqli_close($conn);
}
	
for ($i = 0; $i < 10; $i++) {
	$pid = pcntl_fork();
	
	if($pid == -1) {
		die('can not fork.');
	} elseif (!$pid) {
		dummy_business();
		echo 'quit'.$i.PHP_EOL;
		break;
	}
}
?>

上面的代码模拟了10个用户同时并发执行一项业务的情况,每次业务操作都会使得num的值增加1,每个用户都会执行10000次操作,最终num的值应当是100000。 

运行这段代码,num的值和我们预期的值是一样的:

mysql> select * from counter;
+----+--------+
| id | num    |
+----+--------+
|  1 | 100000 |
+----+--------+
1 row in set (0.00 sec)
这里不会出现问题,是因为单条UPDATE语句操作是原子的,无论怎么执行,num的值最终都会是100000。 然而很多情况下,我们业务过程中执行的逻辑,通常是先查询再执行,并不像上面的自增那样简单:
<?php
function dummy_business() {
	$conn = mysqli_connect('127.0.0.1', 'public', 'public') or die(mysqli_error());
	mysqli_select_db($conn, 'test');
	for ($i = 0; $i < 10000; $i++) {
		$rs = mysqli_query($conn, 'SELECT num FROM counter WHERE id = 1');
		mysqli_free_result($rs);
		$row = mysqli_fetch_array($rs);
		$num = $row[0];
		mysqli_query($conn, 'UPDATE counter SET num = '.$num.' + 1 WHERE id = 1');
	}
	mysqli_close($conn);
}
	
for ($i = 0; $i < 10; $i++) {
	$pid = pcntl_fork();
	
	if($pid == -1) {
		die('can not fork.');
	} elseif (!$pid) {
		dummy_business();
		echo 'quit'.$i.PHP_EOL;
		break;
	}
}
?>
改过的脚本,将原来的原子操作UPDATE换成了先查询再更新,再次运行我们发现,由于并发的缘故程序并没有按我们期望的执行:
mysql> select * from counter;
+----+------+
| id | num  |
+----+------+
|  1 | 21495|
+----+------+
1 row in set (0.00 sec)
入门程序员特别容易犯的错误是,认为这是没开启事务引起的。现在我们给它加上事务:
<?php
function dummy_business() {
	$conn = mysqli_connect('127.0.0.1', 'public', 'public') or die(mysqli_error());
	mysqli_select_db($conn, 'test');
	for ($i = 0; $i < 10000; $i++) {
		mysqli_query($conn, 'BEGIN');
		$rs = mysqli_query($conn, 'SELECT num FROM counter WHERE id = 1');
		mysqli_free_result($rs);
		$row = mysqli_fetch_array($rs);
		$num = $row[0];
		mysqli_query($conn, 'UPDATE counter SET num = '.$num.' + 1 WHERE id = 1');
		if(mysqli_errno($conn)) {
			mysqli_query($conn, 'ROLLBACK');
		} else {
			mysqli_query($conn, 'COMMIT');
		}
	}
	mysqli_close($conn);
}
	
for ($i = 0; $i < 10; $i++) {
	$pid = pcntl_fork();
	
	if($pid == -1) {
		die('can not fork.');
	} elseif (!$pid) {
		dummy_business();
		echo 'quit'.$i.PHP_EOL;
		break;
	}
}
?>
依然没能解决问题:
mysql> select * from counter;
+----+------+
| id | num  |
+----+------+
|  1 | 16328|
+----+------+
1 row in set (0.00 sec)
请注意,数据库事务依照不同的事务隔离级别来保证事务的ACID特性,也就是说事务不是一开启就能解决所有并发问题。通常情况下,这里的并发操作可能带来四种问题:
  • 更新丢失:一个事务的更新覆盖了另一个事务的更新,这里出现的就是丢失更新的问题。
  • 脏读:一个事务读取了另一个事务未提交的数据。
  • 不可重复读:一个事务两次读取同一个数据,两次读取的数据不一致。
  • 幻象读:一个事务两次读取一个范围的记录,两次读取的记录数不一致。
通常数据库有四种不同的事务隔离级别:
隔离级别 脏读 不可重复读 幻读
Read uncommitted
Read committed ×
Repeatable read × ×
Serializable × × ×


大多数数据库的默认的事务隔离级别是提交读(Read committed),而MySQL的事务隔离级别是重复读(Repeatable read)。对于丢失更新,只有在序列化(Serializable)级别才可得到彻底解决。不过对于高性能系统而言,使用序列化级别的事务隔离,可能引起死锁或者性能的急剧下降。因此使用悲观锁和乐观锁十分必要。 并发系统中,悲观锁(Pessimistic Locking)和乐观锁(Optimistic Locking)是两种常用的锁:

  • 悲观锁认为,别人访问正在改变的数据的概率是很高的,因此从数据开始更改时就将数据锁住,直到更改完成才释放。悲观锁通常由数据库实现(使用SELECT...FOR UPDATE语句)。
  • 乐观锁认为,别人访问正在改变的数据的概率是很低的,因此直到修改完成准备提交所做的的修改到数据库的时候才会将数据锁住,完成更改后释放。
上面的例子,我们用悲观锁来实现:
<?php
function dummy_business() {
	$conn = mysqli_connect('127.0.0.1', 'public', 'public') or die(mysqli_error());
	mysqli_select_db($conn, 'test');
	for ($i = 0; $i < 10000; $i++) {
		mysqli_query($conn, 'BEGIN');
		$rs = mysqli_query($conn, 'SELECT num FROM counter WHERE id = 1 FOR UPDATE');
		if($rs == false || mysqli_errno($conn)) {
			// 回滚事务
			mysqli_query($conn, 'ROLLBACK');
			// 重新执行本次操作
			$i--;
			continue;
		}
		mysqli_free_result($rs);
		$row = mysqli_fetch_array($rs);
		$num = $row[0];
		mysqli_query($conn, 'UPDATE counter SET num = '.$num.' + 1 WHERE id = 1');
		if(mysqli_errno($conn)) {
			mysqli_query($conn, 'ROLLBACK');
		} else {
			mysqli_query($conn, 'COMMIT');
		}
	}
	mysqli_close($conn);
}
	
for ($i = 0; $i < 10; $i++) {
	$pid = pcntl_fork();
	
	if($pid == -1) {
		die('can not fork.');
	} elseif (!$pid) {
		dummy_business();
		echo 'quit'.$i.PHP_EOL;
		break;
	}
}
?>
可以看到,这次业务以期望的方式正确执行了:
mysql> select * from counter;
+----+--------+
| id | num    |
+----+--------+
|  1 | 100000 |
+----+--------+
1 row in set (0.00 sec)
由于悲观锁在开始读取时即开始锁定,因此在并发访问较大的情况下性能会变差。对MySQL Inodb来说,通过指定明确主键方式查找数据会单行锁定,而查询范围操作或者非主键操作将会锁表。 接下来,我们看一下如何使用乐观锁解决这个问题,首先我们为counter表增加一列字段:
mysql> select * from counter;
+----+------+---------+
| id | num  | version |
+----+------+---------+
|  1 | 1000 |    1000 |
+----+------+---------+
1 row in set (0.01 sec)
实现方式如下:
<?php
function dummy_business() {
	$conn = mysqli_connect('127.0.0.1', 'public', 'public') or die(mysqli_error());
	mysqli_select_db($conn, 'test');
	for ($i = 0; $i < 10000; $i++) {
		mysqli_query($conn, 'BEGIN');
		$rs = mysqli_query($conn, 'SELECT num, version FROM counter WHERE id = 1');
		mysqli_free_result($rs);
		$row = mysqli_fetch_array($rs);
		$num = $row[0];
		$version = $row[1];
		mysqli_query($conn, 'UPDATE counter SET num = '.$num.' + 1, version = version + 1 WHERE id = 1 AND version = '.$version);
		$affectRow = mysqli_affected_rows($conn);
		if($affectRow == 0 || mysqli_errno($conn)) {
			// 回滚事务重新提交
			mysqli_query($conn, 'ROLLBACK');
			$i--;
			continue;
		} else {
			mysqli_query($conn, 'COMMIT');
		}
	}
	mysqli_close($conn);
}
	
for ($i = 0; $i < 10; $i++) {
	$pid = pcntl_fork();
	
	if($pid == -1) {
		die('can not fork.');
	} elseif (!$pid) {
		dummy_business();
		echo 'quit'.$i.PHP_EOL;
		break;
	}
}
?>
这次,我们也得到了期望的结果:
mysql> select * from counter;
+----+--------+---------+
| id | num    | version |
+----+--------+---------+
| 1  | 100000 | 100000  |
+----+--------+---------+
1 row in set (0.01 sec)

由于乐观锁最终执行的方式相当于原子化UPDATE,因此在性能上要比悲观锁好很多。 在使用Doctrine ORM框架的环境中,Doctrine原生提供了对悲观锁和乐观锁的支持。具体的使用方式请参考手册: http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/transactions-and-concurrency.html#locking-support 

Hibernate框架中同样提供了对两种锁的支持,在此不再赘述了。 在高性能系统中处理并发问题,受限于后端数据库,无论何种方式加锁性能都无法高效处理如电商秒杀抢购量级的业务。使用NoSQL数据库、消息队列等方式才能更有效地完成业务的处理。 

参考文章

© 著作权归作者所有

共有 人打赏支持
烫烫烫烫烫烫
粉丝 9
博文 7
码字总数 9897
作品 2
大连
技术主管
加载中

评论(7)

烫烫烫烫烫烫
烫烫烫烫烫烫

引用来自“水人”的评论

学习了!作为一个菜鸟,我想问的,这些成熟框架,应该已经处理了这些问题了吧。

引用来自“名字字数不够长”的评论

Doctrine ORM 和 Hibernate都提供了支持悲观锁和乐观锁的机制,用起来就可以了。

引用来自“水人”的评论

yii和thinkphp有此功能不。。。
这两个框架不了解
水人
水人

引用来自“水人”的评论

学习了!作为一个菜鸟,我想问的,这些成熟框架,应该已经处理了这些问题了吧。

引用来自“名字字数不够长”的评论

Doctrine ORM 和 Hibernate都提供了支持悲观锁和乐观锁的机制,用起来就可以了。
yii和thinkphp有此功能不。。。
烫烫烫烫烫烫
烫烫烫烫烫烫

引用来自“水人”的评论

学习了!作为一个菜鸟,我想问的,这些成熟框架,应该已经处理了这些问题了吧。
Doctrine ORM 和 Hibernate都提供了支持悲观锁和乐观锁的机制,用起来就可以了。
水人
水人
学习了!作为一个菜鸟,我想问的,这些成熟框架,应该已经处理了这些问题了吧。
钱途无梁
钱途无梁
谢谢分享,,一般会用悲观锁
无羁
无羁
码一个
五毛钱的饼
五毛钱的饼
mark
inhere/php-queue

php 的队列实现 php的队列使用包装, 默认自带支持 三个级别的队列操作。 基于数据库(mysql/sqlite)的队列实现 基于 php 实现 基于 redis 实现 - 操作具有原子性,并发操作不会有问题 基于共享...

inhere
2017/06/13
0
0
异步 mysql 客户端--async-mysql-php

PHP异步并发访问mysql简单实现。 在实际的开发过程中,我们常常会遇到需要操作多张表,多个库的情况。有时因为一些限制我们不能进行连表(例如,异地数据库),所以只能用php串行访问后再在p...

呼延平
2015/07/23
723
1
mysql中的LAST_INSERT_ID()分析

今天跟人讨论php高并发下的LASTINSERTID的正确性问题,一开始大家都比较模糊,后来经过大家共同查询资料,对这个问题有了比较清晰的了解,特发此文,以为纪念。 首先看mysql中的LASTINSERTI...

赵开锦
2012/06/21
0
6
Nginx 第三方模块-漫谈缘起

本文的部分内容和图片摘录于http://tengine.taobao.org/download/nginx@taobao.pdf 为什么要使用nginx模块?我个人觉得taobao这个ppt来做说明是最好不过了 从web服务器结构开始说起: 第一个...

王二狗子11
01/08
0
0
用php实现异步执行任务的队列(二)

六、队列具体实现三:写执行队列的程序 根据设计,执行队列的程序文件是 doqueue.php , 它的主要功能是把任务从队列表里取出来,并且在后台执行。 doqueue.php部分代码: 七、具体任务的业务...

_c_q
2016/09/08
293
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

OSChina 周三乱弹 —— 公司女同事约我

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @莱布妮子:分享水木年华的单曲《蝴蝶花(2002年大提琴版)》 《蝴蝶花(2002年大提琴版)》- 水木年华 手机党少年们想听歌,请使劲儿戳(这里) ...

小小编辑
2分钟前
0
3
Linux环境搭建 | VMware下共享文件夹的实现

在进行程序开发的过程中,我们经常要在主机与虚拟机之间传递文件,比如说,源代码位于虚拟机,而在主机下阅读或修改源代码,这里就需要使用到 「共享文件」 这个机制了。本文介绍了两种共享文...

良许Linux
今天
5
0
JUC锁框架——AQS源码分析

JUC锁介绍 Java的并发框架JUC(java.util.concurrent)中锁是最重要的一个工具。因为锁,才能实现正确的并发访问。而AbstractQueuedSynchronizer(AQS)是一个用来构建锁和同步器的框架,使用A...

长头发-dawn
今天
3
0
docker中安装了RabbitMQ后无法访问其Web管理页面

在官网找了"$ docker run -d --hostname my-rabbit --name some-rabbit -p 8080:15672 rabbitmq:3-management"这条安装命令,在docker上安装了RabbitMQ,,结果输入http://localhost:8080并不......

钟然千落
今天
4
1
spring-cloud | 分布式session共享

写在前面的话 各位小伙伴,你们有福了,这一节不仅教大家怎么实现分布式session的问题,还用kotlin开发,喜欢kotlin的小伙伴是不是很开心! 以前在写Android的时候,就对客户端请求有一定的认...

冯文议
今天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部