常见并发问题解决方案

序

现在网上关于秒杀，抢票，超卖等并发场景的文章已经烂大街了。之前看过很多，但从来没自己测试过。今天心血来潮，想落地一下。

虽然解决的方法很多，可不一定都适合各种具体场景，所以过一遍流程，也能更好的把握哪些场景更适合怎样的方法，此篇文章的目的就是如此。

再啰嗦一句：并发和大流量是两码事，小流量也可以有并发。

业务逻辑

老板发福利，400个奖，不能发重，不能发超，大家快来抢啊！

准备工作

环境

脚本：PHP，框架：Laravel，web服务器：Nginx，数据库：MySQL，NoSQL：Redis，并发压测工具：Go-stress-testing-linux，系统：CentOS7。

具体的脚本不重要，这里用的是自己比较熟悉的。

数据库表结构

code

字段	类型	说明
id	int11 unsigned not null	自增主键
code	char14 not null	14位Char unique
status	bit1 not null	0未发放 1已发放
update_time	datetime	发放时间 未发放为null

code_out

字段	类型	说明
id	int11 unsigned not null	自增主键
code_id	nt11 unsigned not null	code表主键
create_time	datetime not null	发放时间 默认CURRENT_TIMESTAMP

code_out表主要用来表现并发问题。

正常情况下，code_out表数据量和code表status=1的数据量必须一样，且code_out表一定没有code_id相同的记录，否则同一code肯定被发给了多个用户。

这里补充下，时间为什么没有用timestamp。

其实以前我也喜欢用timestamp类型的，可自从有一次遇到有记录的实际创建时间是18xx年，导致客户劈头盖脸来骂了一顿这种情况之后，就改掉了这个习惯。当然我也不是说timestamp不好，而是人总是有惯性思维。

再补充一下，为什么很多字段要可以不允许为null。

字段为null是很危险的，它可能导致查询的数据和实际逻辑要求的不一致，并且null比空字符串会占用更多的空间。所以，除非业务要求区分”0”和”没有”，都建议字段不允许null，怎么算都不划算对吧。

数据填充

php复制代码use Illuminate\Support\Str;

// 原谅我放纵不羁爱自由，懒得建模型了，直接用DB类走起
for ($i = 0; $i < 100; $i++) {
    \DB::table('code')
        ->insert([
            'code' => Str::random(14),
        ]);
}

安装go-stress-testing-linux

go-stress-testing-linux是Go写的压测工具。

git上有打成二进制的可执行文件，下载即可（github搜索link1st/go-stress-testing）。

下载后记得赋予文件可执行权限哦。想偷懒的话，就直接拷贝到/usr/bin下吧。如果使用二进制文件的话，不需要装go环境。

为什么选择go-stress-testing-linux？

它的运行原理是利用Go的携程发起并发，是真正意义上的多线程并发。

安装Redis

不再赘述，网上教程很多。

安装php redis扩展

这一步可选，php有很多种方式可以和redis互通，个人更喜欢这种原始的方法。

让游戏开始吧

压测参数

go复制代码go-stress-testing-linux -c 1500 -n 2 -u {url}

模拟1500个用户，每个用户请求2次。看上去数字并不大对吧？

压测过程

没有任何保护措施

开抢咯

php复制代码$remain = \DB::table('code')
    ->where('status', 0)
    ->select('id', 'code')
    ->first();
if (null == $remain) {
    return [
        'code' => 500,
        'msg' => 'no code available',
        'data' => null
    ];
}
\DB::table('code')
    ->where('id', $remain->id)
    ->update([
        'status' => 1,
        'out_time' => date('Y-m-d H:i:s', $_SERVER['REQUEST_TIME'])
    ]);
\DB::table('code_out')
    ->insert([
        'code_id' => $remain->id
    ]);
return [
    'code' => 200,
    'msg' => 'congratulations',
    'data' => $remain->code
];

结果

php复制代码┬────┬──────┬──────┬──────┬────────┬────────┬────────┬────────┬────────┬────────┬────────┬
│ 耗时│ 并发数│ 成功数│ 失败数│   qps  │ 最长耗时 │ 最短耗时 │ 平均耗时│ 下载字节│ 字节每秒 │ 错误码  │
┼────┼──────┼──────┼──────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼
│  1s│    81│    81│     0│ 2080.32│ 1000.70│  389.09│  721.04│        │        │  200:81│
│  2s│   310│   310│     0│ 1173.30│ 1971.56│  389.09│ 1278.44│        │        │ 200:310│
│  3s│   545│   545│     0│  835.09│ 2949.67│  389.09│ 1796.22│        │        │ 200:545│
│  4s│   778│   778│     0│  657.16│ 3924.38│  389.09│ 2282.54│        │        │ 200:778│
│  5s│  1005│  1005│     0│  545.64│ 4908.34│  389.09│ 2749.07│        │        │200:1005│
│  6s│  1233│  1233│     0│  464.19│ 5949.70│  389.09│ 3231.45│        │        │200:1233│
│  7s│  1451│  1453│     0│  404.71│ 6909.48│  389.09│ 3706.35│        │        │200:1453│
│  8s│  1500│  1680│     0│  365.77│ 7277.43│  389.09│ 4100.99│        │        │200:1680│
│  9s│  1500│  1902│     0│  341.60│ 7277.43│  389.09│ 4391.14│        │        │200:1902│
│ 10s│  1500│  2128│     0│  324.08│ 7277.43│  389.09│ 4628.53│        │        │200:2128│
│ 11s│  1500│  2336│     0│  311.62│ 7277.43│  389.09│ 4813.55│        │        │200:2336│
│ 12s│  1500│  2558│     0│  301.01│ 7277.43│  389.09│ 4983.29│        │        │200:2558│
│ 13s│  1500│  2794│     0│  292.18│ 7277.43│  389.09│ 5133.82│        │        │200:2794│
│ 14s│  1500│  3000│     0│  286.16│ 7277.43│  389.09│ 5241.89│        │        │200:3000│

数据验证

sql复制代码select count(*) from `code` where `status` = 1;
# 400
select count(*) from code_out;
# 3000
select count(*), code_id from code_out group by code_id having count(*) > 1;
# 竟然有216条记录，其中吉尼斯记录获取者是code_id=2的奖项，它被发了43次！
# 当然，其他很多code也被重复发了很多次

结论

可以看到，不加任何保护措施的情况下，代码造成了同一code发给了多个用户的情况，一上线那就是事故！

为什么会造成这种情况呢？其实原因很简单：MySQL查询和更新都需要一定时间的，更新过程中，后来的线程读到的还是老数据！代码可不会管这么多，拿到就继续用咯。

同时，这也证明压测工具确实模拟出了并发场景。

版本控制

准备

sql复制代码# 给code加一个version列
alter table `code` add version bit(1) not null default 0;

开抢咯

php复制代码$remain = \DB::table('code')
    ->where('status', 0)
    ->select('id', 'code')
    ->first();
if (null == $remain) {
    return [
        'code' => 500,
        'msg' => 'no code available',
        'data' => null
    ];
}
$res = \DB::table('code')
    ->where('id', $remain->id)
    ->where('version', 0)
    ->update([
        'status' => 1,
        'out_time' => date('Y-m-d H:i:s', $_SERVER['REQUEST_TIME']),
        'version' => 1
    ]);
if (0 == $res) {
    return [
        'code' => 500,
        'msg' => 'no code available',
        'data' => null
    ];
}
\DB::table('code_out')
    ->insert([
        'code_id' => $remain->id
    ]);
return [
    'code' => 200,
    'msg' => 'congratulations',
    'data' => $remain->code
];

结果

php复制代码┼────┬──────┬──────┬──────┬───────┬────────┬────────┬────────┬────────┬────────┬────────┼
│ 耗时│ 并发数│ 成功数│ 失败数│  qps  │ 最长耗时 │ 最短耗时 │ 平均耗时│ 下载字节│ 字节每秒 │  错误码 │
┼────┼──────┼──────┼──────┼───────┼────────┼────────┼────────┼────────┼────────┼────────┼
│  1s│   104│   104│     0│2049.70│  993.69│  395.58│  731.81│        │        │ 200:104│
│  2s│   338│   338│     0│1179.55│ 1988.44│  395.58│ 1271.67│        │        │ 200:338│
│  3s│   557│   557│     0│ 853.74│ 2935.61│  395.58│ 1756.98│        │        │ 200:557│
│  4s│   803│   803│     0│ 662.97│ 3952.94│  395.58│ 2262.55│        │        │ 200:803│
│  5s│  1036│  1036│     0│ 549.07│ 4917.70│  395.58│ 2731.88│        │        │200:1036│
│  6s│  1283│  1283│     0│ 463.21│ 5912.17│  395.58│ 3238.26│        │        │200:1283│
│  7s│  1496│  1524│     0│ 402.64│ 6887.29│  395.58│ 3725.45│        │        │200:1524│
│  8s│  1500│  1774│     0│ 366.77│ 7060.28│  395.58│ 4089.79│        │        │200:1774│
│  9s│  1500│  2015│     0│ 345.61│ 7060.28│  395.58│ 4340.16│        │        │200:2015│
│ 10s│  1500│  2252│     0│ 330.46│ 7060.28│  395.58│ 4539.15│        │        │200:2252│
│ 11s│  1500│  2491│     0│ 319.09│ 7060.28│  395.58│ 4700.83│        │        │200:2491│
│ 12s│  1500│  2733│     0│ 310.39│ 7060.28│  395.58│ 4832.66│        │        │200:2733│
│ 13s│  1500│  2993│     0│ 302.99│ 7060.28│  395.58│ 4950.65│        │        │200:2993│
│ 13s│  1500│  3000│     0│ 302.82│ 7060.28│  395.58│ 4953.50│        │        │200:3000│

数据验证

sql复制代码select count(*) from `code` where `status` = 1;
# 333
select count(*) from code_out;
# 333
select count(*), code_id from code_out group by code_id having count(*) > 1;
# 无记录

结论

很遗憾，奖没发完呢，因为部分线程抢到了同一个记录，但由于收到了版本控制，所以那些没有更新到数据的线程只能怪自己运气不好咯。

这里用到了MySQL默认的MVCC，不知道的童鞋赶紧Google一下吧。

其实，利用InnoDB的事务隔离也可以达到目的哦，但是如果没有深刻理解的话，搞不好会玩火自焚呢（如果造成死锁，无论行表，都会严重影响业务）。

顺便说一句，大名鼎鼎的Elasticsearch也是用的这种方式解决这种问题的哦。

使用缓存

准备

php复制代码// redis稍微封装一下
private function redis(): \Redis {
    $redis = new \Redis();
    $redis->connect('{host}', {port});
    $redis->auth('{password}');
    return $redis;
}

// 预热数据，将code放入Redis set中
$code = \DB::table('code')
    ->select('code')
    ->get();
$redis = $this->redis();
$redis->connect('{host}', {port});
foreach ($code as $v) {
    $redis->sAdd('code', $v);
}

开抢咯

php复制代码$redis = $this->redis();
$code = $redis->spop('code');
if (null == $code) {
    return [
        'code' => 500,
        'msg' => 'no code available',
        'data' => null
    ];
}
$exist = \DB::table('code')
    ->where('code', $code)
    ->where('status', 0)
    ->select('id')
    ->first();
if (null == $exist) {
    return [
        'code' => 500,
        'msg' => 'invalid code',
        'data' => null
    ];
}
\DB::table('code')
    ->where('id', $exist->id)
    ->update([
        'status' => 1,
        'out_time' => date('Y-m-d H:i:s', $_SERVER['REQUEST_TIME'])
    ]);
\DB::table('code_out')
    ->insert([
        'code_id' => $exist->id
    ]);
return [
    'code' => 200,
    'msg' => 'congratulations',
    'data' => $code
];

结果

php复制代码┼────┬───────┬───────┬───────┬────────┬────────┬────────┬────────┬────────┬────────┬────────┼
│ 耗时│ 并发数 │ 成功数 │ 失败数 │  qps   │ 最长耗时 │ 最短耗时 │ 平均耗时│ 下载字节 │ 字节每秒│ 错误码  │
┼────┼───────┼───────┼───────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼
│  1s│     68│     68│      0│ 1880.27│  955.80│  704.57│  797.76│        │        │ 200:68 │
│  2s│    278│    278│      0│ 1146.86│ 1979.88│  704.57│ 1307.92│        │        │ 200:278│
│  3s│    540│    540│      0│  795.13│ 2928.10│  704.57│ 1886.49│        │        │ 200:540│
│  4s│    697│    697│      0│  687.85│ 3467.25│  704.57│ 2180.72│        │        │ 200:697│
│  5s│   1058│   1058│      0│  509.59│ 4935.67│  704.57│ 2943.54│        │        │200:1058│
│  6s│   1207│   1207│      0│  464.16│ 5791.64│  704.57│ 3231.65│        │        │200:1207│
│  7s│   1500│   1682│      0│  377.43│ 6835.16│  704.57│ 3974.30│        │        │200:1682│
│  8s│   1500│   1966│      0│  359.36│ 6835.16│  704.57│ 4174.10│        │        │200:1966│
│  9s│   1500│   2277│      0│  349.38│ 6835.16│  704.57│ 4293.34│        │        │200:2277│
│ 10s│   1500│   2560│      0│  344.16│ 6835.16│  704.57│ 4358.40│        │        │200:2560│
│ 11s│   1500│   2848│      0│  341.15│ 6835.16│  704.57│ 4396.88│        │        │200:2848│
│ 11s│   1500│   3000│      0│  339.30│ 6835.16│  704.57│ 4420.93│        │        │200:3000│

数据验证

sql复制代码select count(*) from `code `where `status` = 1;
# 400
select count(*) from code_out;
# 400
select count(*), code_id from code_out group by code_id having count(*) > 1;
# 无记录

结论

可以看到，利用Redis单线程特性，并发问题已经解决啦。

并发锁

开抢咯

php复制代码$redis = $this->redis();
if (false === $redis->setnx('lock', 1)) {
    return [
        'code' => 500,
        'msg' => 'no code available',
        'data' => null
    ];
}
// 避免死锁
$redis->expire('lock', 10);
try {
    $remain = \DB::table('code')
        ->where('status', 0)
        ->select('id', 'status')
        ->first();
    if (null == $remain) {
        return [
            'code' => 500,
            'msg' => 'no code available',
            'data' => null
        ];
    }
    \DB::table('code')
        ->where('id', $remain->id)
        ->update([
            'status' => 1,
            'out_time' => date('Y-m-d H:i:s', $_SERVER['REQUEST_TIME'])
        ]);
    \DB::table('code_out')
        ->insert([
            'code_id' => $remain->id
        ]);
    return [
        'code' => 200,
        'msg' => 'congratulations',
        'data' => $remain->code
    ];
} catch (\Exception $e) {
    // 异常
    return [
        'code' => 500,
        'msg' => 'no code available',
        'data' => null
    ];
} finally {
    // 释放锁
    $redis->del('lock');
}

结果

php复制代码┼────┬───────┬───────┬───────┬────────┬────────┬────────┬────────┬────────┬────────┬────────┼
│ 耗时│ 并发数 │ 成功数 │ 失败数 │   qps  │ 最长耗时 │ 最短耗时│ 平均耗时 │ 下载字节 │ 字节每秒│  错误码 │
│────┼───────┼───────┼───────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼
│  1s│      0│      0│      0│    0.00│    0.00│    0.00│    0.00│        │        │        │
│  2s│     39│     39│      0│  814.37│ 1886.71│ 1754.72│ 1841.90│        │        │  200:39│
│  3s│    287│    287│      0│  577.95│ 2974.69│ 1754.72│ 2595.40│        │        │ 200:287│
│  6s│    922│    922│      0│  434.78│ 4880.62│ 1754.72│ 3450.04│        │        │ 200:922│
│  5s│    695│    695│      0│  483.45│ 3675.15│ 1754.72│ 3102.72│        │        │ 200:695│
│  6s│   1352│   1352│      0│  363.11│ 5881.57│ 1754.72│ 4130.97│        │        │200:1352│
│  7s│   1453│   1489│      0│  352.77│ 6302.32│ 1754.72│ 4252.01│        │        │200:1489│
│  8s│   1500│   2046│      0│  345.42│ 7439.63│ 1754.72│ 4342.48│        │        │200:2046│
│  9s│   1500│   2304│      0│  344.51│ 7439.63│ 1754.72│ 4354.06│        │        │200:2304│
│ 10s│   1500│   2559│      0│  345.93│ 7439.63│ 1754.72│ 4336.18│        │        │200:2559│
│ 11s│   1500│   2818│      0│  342.97│ 7439.63│ 1754.72│ 4373.58│        │        │200:2818│
│ 12s│   1500│   3000│      0│  340.21│ 7439.63│ 1754.72│ 4409.07│        │        │200:3000│

数据验证

sql复制代码select count(*) from `code` where `status` = 1;
# 61
select count(*) from code_out;
# 61
select count(*), code_id from code_out group by code_id having count(*) > 1;
# 无记录

结论

虽然这里也用到了Redis的特性，但重点是并发锁的原理，用PHP的文件锁也可以实现这个功能。

在这个例子中，很遗憾，3000个请求只完成了61个奖的发放。因为锁住的时候就直接返回了结果，导致很多请求被拒绝了。但重点是避免了重发的问题！

总结

这里通过几个简单的例子，验证了用不同方法解决并发问题。虽然实际业务会更加复杂，但解决问题的方式，原理就是这些啦。

这里根据我的项目经验，给出一些建议：

Redis虽然是单线程（新版本的Redis已经是多线程的啦），但是连续的Redis操作可不一定了哦。例子：先get一个key，再set它，在并发情况下，结果可不一定是你想要的啦。

• 如果是数字的话，可以使用Redis的incr/decr这种连续操作的方法。
• 其他类型的话，可以使用Lua脚本一并发送命令，特殊语言如Java，可以用自己的锁来锁住代码块。

使用并发锁一定要注意死锁的问题，不管什么情况，都要及时释放锁，否则万一出现死锁问题，那就是重大事故！

好了，就说这么多了，希望对你有所帮助。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有