如何设计并实现一个秒杀系统？（含完整代码）

桃扇骨 2022-01-10 04:31 144阅读 0赞

点击上方石杉的架构笔记，右上角选择“**设为星标**”

每日早8点半，技术文章准时送上

公众号后台回复“**学习**”，获取作者独家秘制精品资料

![640?wx\_fmt=png][640_wx_fmt_png]

往期文章

[BAT 面试官是如何360°无死角考察候选人的（上篇）][BAT _360]

[每秒上万并发下的Spring Cloud参数优化实战][Spring Cloud]

[分布式事务如何保障实际生产中99.99%高可用][99.99]

[记一位朋友斩获 BAT 技术专家Offer的面试经历][BAT _Offer]

[亿级流量架构系列之如何支撑百亿级数据的存储与计算][Link 1]

![640?wx\_fmt=png][640_wx_fmt_png]

## 本文来源：crossoverJie ##

## 前言 ##

之前在 Java-Interview 中提到过秒杀架构的设计，这次基于其中的理论简单实现了一下。

> 本次采用循序渐进的方式逐步提高性能达到并发秒杀的效果，文章较长，请准备好瓜子板凳^\_^

本文所有涉及的代码：

*  https://github.com/crossoverJie/SSM
 *  https://github.com/crossoverJie/distributed-redis-tool

首先来看看最终架构图：

![640?wx\_fmt=png][640_wx_fmt_png 1]

先简单根据这个图谈下请求的流转，因为后面不管怎么改进这个都是没有变的。

*  前端请求进入 `web` 层，对应的代码就是 `controller`
 *  之后将真正的库存校验、下单等请求发往 `Service` 层（其中 RPC 调用依然采用的 `dubbo`，只是更新为最新版本，本次不会过多讨论 dubbo 相关的细节，有兴趣的可以查看 基于dubbo 的分布式架构）
 *  `Service` 层再对数据进行落地，下单完成

## 无限制 ##

其实抛开秒杀这个场景来说正常的一个下单流程可以简单分为以下几步：

*  校验库存
 *  扣库存
 *  创建订单
 *  支付

基于上文的架构所以我们有了以下实现：

先看看实际项目的结构：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg]

还是和以前一样：

*  提供出一个 `API` 用于 `Service` 层实现，以及 `web` 层消费。
 *  web 层简单来说就是一个 `SpringMVC`。
 *  `Service` 层则是真正的数据落地。
 *  `SSM-SECONDS-KILL-ORDER-CONSUMER` 则是后文会提到的 `Kafka` 消费。

数据库也是只有简单的两张表模拟下单：

CREATE TABLE `stock` (	
      `id` int(11) unsigned NOT NULL AUTO_INCREMENT,	
      `name` varchar(50) NOT NULL DEFAULT '' COMMENT '名称',	
      `count` int(11) NOT NULL COMMENT '库存',	
      `sale` int(11) NOT NULL COMMENT '已售',	
      `version` int(11) NOT NULL COMMENT '乐观锁，版本号',	
      PRIMARY KEY (`id`)	
    ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;	
    CREATE TABLE `stock_order` (	
      `id` int(11) unsigned NOT NULL AUTO_INCREMENT,	
      `sid` int(11) NOT NULL COMMENT '库存ID',	
      `name` varchar(30) NOT NULL DEFAULT '' COMMENT '商品名称',	
      `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',	
      PRIMARY KEY (`id`)	
    ) ENGINE=InnoDB AUTO_INCREMENT=55 DEFAULT CHARSET=utf8;

web 层 `controller` 实现:

1.  `   @Autowired`
2.  `   private StockService stockService;`
3.    
    
4.  `   @Autowired`
5.  `   private OrderService orderService;`
6.    
    
7.  `   @RequestMapping("/createWrongOrder/{sid}")`
8.  `   @ResponseBody`
9.  `   public String createWrongOrder(@PathVariable int sid) {`
10. `       logger.info("sid=[{}]", sid);`
11. `       int id = 0;`
12. `       try {`
13. `           id = orderService.createWrongOrder(sid);`
14. `       } catch (Exception e) {`
15. `           logger.error("Exception",e);`
16. `       }`
17. `       return String.valueOf(id);`
18. `   }`

其中 web 作为一个消费者调用看 `OrderService` 提供出来的 dubbo 服务。

Service 层， `OrderService` 实现：

首先是对 API 的实现(会在 API 提供出接口)：

1.  `@Service`
2.  `public class OrderServiceImpl implements OrderService {`
3.    
    
4.  `   @Resource(name = "DBOrderService")`
5.  `   private com.crossoverJie.seconds.kill.service.OrderService orderService ;`
6.    
    
7.  `   @Override`
8.  `   public int createWrongOrder(int sid) throws Exception {`
9.  `       return orderService.createWrongOrder(sid);`
10. `   }`
11. `}`

这里只是简单调用了 `DBOrderService` 中的实现，DBOrderService 才是真正的数据落地，也就是写数据库了。

DBOrderService 实现：

1.  `Transactional(rollbackFor = Exception.class)`
2.  `@Service(value = "DBOrderService")`
3.  `public class OrderServiceImpl implements OrderService {`
4.  `   @Resource(name = "DBStockService")`
5.  `   private com.crossoverJie.seconds.kill.service.StockService stockService;`
6.    
    
7.  `   @Autowired`
8.  `   private StockOrderMapper orderMapper;`
9.    
    
10. `   @Override`
11. `   public int createWrongOrder(int sid) throws Exception{`
12.   
    
13. `       //校验库存`
14. `       Stock stock = checkStock(sid);`
15.   
    
16. `       //扣库存`
17. `       saleStock(stock);`
18.   
    
19. `       //创建订单`
20. `       int id = createOrder(stock);`
21.   
    
22. `       return id;`
23. `   }`
24.   
    
25. `   private Stock checkStock(int sid) {`
26. `       Stock stock = stockService.getStockById(sid);`
27. `       if (stock.getSale().equals(stock.getCount())) {`
28. `           throw new RuntimeException("库存不足");`
29. `       }`
30. `       return stock;`
31. `   }`
32.   
    
33. `   private int saleStock(Stock stock) {`
34. `       stock.setSale(stock.getSale() + 1);`
35. `       return stockService.updateStockById(stock);`
36. `   }`
37.   
    
38. `   private int createOrder(Stock stock) {`
39. `       StockOrder order = new StockOrder();`
40. `       order.setSid(stock.getId());`
41. `       order.setName(stock.getName());`
42. `       int id = orderMapper.insertSelective(order);`
43. `       return id;`
44. `   }        `
45.   
    
46. `}`

> 预先初始化了 10 条库存。

手动调用下 `createWrongOrder/1` 接口发现：

库存表：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 1]

订单表：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 2]

一切看起来都没有问题，数据也正常。但是当用 `JMeter` 并发测试时：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 3]

测试配置是：300个线程并发，测试两轮来看看数据库中的结果：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 4]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 5]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 6]

请求都响应成功，库存确实也扣完了，但是订单却生成了 **124** 条记录。这显然是典型的超卖现象。

> 其实现在再去手动调用接口会返回库存不足，但为时晚矣。

##     ##

## 乐观锁更新 ##

怎么来避免上述的现象呢？最简单的做法自然是乐观锁了，来看看具体实现：

> 其实其他的都没怎么改，主要是 Service 层。

1.  `   @Override`
2.  `   public int createOptimisticOrder(int sid) throws Exception {`
3.    
    
4.  `       //校验库存`
5.  `       Stock stock = checkStock(sid);`
6.    
    
7.  `       //乐观锁更新库存`
8.  `       saleStockOptimistic(stock);`
9.    
    
10. `       //创建订单`
11. `       int id = createOrder(stock);`
12.   
    
13. `       return id;`
14. `   }`
15.   
    
16. `   private void saleStockOptimistic(Stock stock) {`
17. `       int count = stockService.updateStockByOptimistic(stock);`
18. `       if (count == 0){`
19. `           throw new RuntimeException("并发更新库存失败") ;`
20. `       }`
21. `   }`

对应的 XML：

1.  `   <update< span=""> id="updateByOptimistic" parameterType="com.crossoverJie.seconds.kill.pojo.Stock">`
2.  `       update stock`
3.  `       `
4.  `           sale = sale + 1,`
5.  `           version = version + 1,`
6.  `       `
7.    
    
8.  `       WHERE id = #{id,jdbcType=INTEGER}`
9.  `       AND version = #{version,jdbcType=INTEGER}`
10.   
    
11. `   `

同样的测试条件，我们再进行上面的测试 `/createOptimisticOrder/1`：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 7]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 8]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 9]

这次发现无论是库存订单都是 OK 的。

查看日志发现：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 10]

很多并发请求会响应错误，这就达到了效果。

###     ###

### 提高吞吐量 ###

为了进一步提高秒杀时的吞吐量以及响应效率，这里的 web 和 Service 都进行了横向扩展。

*  web 利用 Nginx 进行负载。
 *  Service 也是多台应用。

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 11]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 12]

再用 JMeter 测试时可以直观的看到效果。

> 由于我是在阿里云的一台小水管服务器进行测试的，加上配置不高、应用都在同一台，所以并没有完全体现出性能上的优势（ `Nginx` 做负载转发时候也会增加额外的网络消耗）。

###     ###

### shell 脚本实现简单的 CI ###

由于应用多台部署之后，手动发版测试的痛苦相信经历过的都有体会。

这次并没有精力去搭建完整的 CI CD，只是写了一个简单的脚本实现了自动化部署，希望对这方面没有经验的同学带来一点启发：

#### 构建 web ####

1.  `#!/bin/bash`
2.    
    
3.  `# 构建 web 消费者`
4.    
    
5.  `#read appname`
6.    
    
7.  `appname="consumer"`
8.  `echo "input="$appname`
9.    
    
10. `PID=$(ps -ef | grep $appname | grep -v grep | awk '{print $2}')`
11.   
    
12. `# 遍历杀掉 pid`
13. `for var in ${ PID[@]};`
14. `do`
15. `   echo "loop pid= $var"`
16. `   kill -9 $var`
17. `done`
18.   
    
19. `echo "kill $appname success"`
20.   
    
21. `cd ..`
22.   
    
23. `git pull`
24.   
    
25. `cd SSM-SECONDS-KILL`
26.   
    
27. `mvn -Dmaven.test.skip=true clean package`
28.   
    
29. `echo "build war success"`
30.   
    
31. `cp /home/crossoverJie/SSM/SSM-SECONDS-KILL/SSM-SECONDS-KILL-WEB/target/SSM-SECONDS-KILL-WEB-2.2.0-SNAPSHOT.war /home/crossoverJie/tomcat/tomcat-dubbo-consumer-8083/webapps`
32. `echo "cp tomcat-dubbo-consumer-8083/webapps ok!"`
33.   
    
34. `cp /home/crossoverJie/SSM/SSM-SECONDS-KILL/SSM-SECONDS-KILL-WEB/target/SSM-SECONDS-KILL-WEB-2.2.0-SNAPSHOT.war /home/crossoverJie/tomcat/tomcat-dubbo-consumer-7083-slave/webapps`
35. `echo "cp tomcat-dubbo-consumer-7083-slave/webapps ok!"`
36.   
    
37. `sh /home/crossoverJie/tomcat/tomcat-dubbo-consumer-8083/bin/startup.sh`
38. `echo "tomcat-dubbo-consumer-8083/bin/startup.sh success"`
39.   
    
40. `sh /home/crossoverJie/tomcat/tomcat-dubbo-consumer-7083-slave/bin/startup.sh`
41. `echo "tomcat-dubbo-consumer-7083-slave/bin/startup.sh success"`
42.   
    
43. `echo "start $appname success"`

####     ####

#### 构建 Service ####

1.  `# 构建服务提供者`
2.    
    
3.  `#read appname`
4.    
    
5.  `appname="provider"`
6.    
    
7.  `echo "input="$appname`
8.    
    
9.    
    
10. `PID=$(ps -ef | grep $appname | grep -v grep | awk '{print $2}')`
11.   
    
12. `#if [ $? -eq 0 ]; then`
13. `#    echo "process id:$PID"`
14. `#else`
15. `#    echo "process $appname not exit"`
16. `#    exit`
17. `#fi`
18.   
    
19. `# 遍历杀掉 pid`
20. `for var in ${ PID[@]};`
21. `do`
22. `   echo "loop pid= $var"`
23. `   kill -9 $var`
24. `done`
25.   
    
26. `echo "kill $appname success"`
27.   
    
28.   
    
29. `cd ..`
30.   
    
31. `git pull`
32.   
    
33. `cd SSM-SECONDS-KILL`
34.   
    
35. `mvn -Dmaven.test.skip=true clean package`
36.   
    
37. `echo "build war success"`
38.   
    
39. `cp /home/crossoverJie/SSM/SSM-SECONDS-KILL/SSM-SECONDS-KILL-SERVICE/target/SSM-SECONDS-KILL-SERVICE-2.2.0-SNAPSHOT.war /home/crossoverJie/tomcat/tomcat-dubbo-provider-8080/webapps`
40.   
    
41. `echo "cp tomcat-dubbo-provider-8080/webapps ok!"`
42.   
    
43. `cp /home/crossoverJie/SSM/SSM-SECONDS-KILL/SSM-SECONDS-KILL-SERVICE/target/SSM-SECONDS-KILL-SERVICE-2.2.0-SNAPSHOT.war /home/crossoverJie/tomcat/tomcat-dubbo-provider-7080-slave/webapps`
44.   
    
45. `echo "cp tomcat-dubbo-provider-7080-slave/webapps ok!"`
46.   
    
47. `sh /home/crossoverJie/tomcat/tomcat-dubbo-provider-8080/bin/startup.sh`
48. `echo "tomcat-dubbo-provider-8080/bin/startup.sh success"`
49.   
    
50. `sh /home/crossoverJie/tomcat/tomcat-dubbo-provider-7080-slave/bin/startup.sh`
51. `echo "tomcat-dubbo-provider-8080/bin/startup.sh success"`
52.   
    
53. `echo "start $appname success"`

之后每当我有更新，只需要执行这两个脚本就可以帮我自动构建。都是最基础的 Linux 命令，相信大家都看得明白。

## 乐观锁更新 + 分布式限流 ##

上文的结果看似没有问题，其实还差得远呢。这里只是模拟了 300 个并发没有问题，但是当请求达到了 3000 ，3W，300W 呢？

虽说可以横向扩展可以支撑更多的请求，但是能不能利用最少的资源解决问题呢？其实仔细分析下会发现：

> 假设我的商品一共只有 10 个库存，那么无论你多少人来买其实最终也最多只有 10 人可以下单成功。

所以其中会有 `99%` 的请求都是无效的。

大家都知道：大多数应用数据库都是压倒骆驼的最后一根稻草。通过 `Druid` 的监控来看看之前请求数据库的情况：

因为 Service 是两个应用。 ![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 13]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 14]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 15]

数据库也有 20 多个连接。

怎么样来优化呢？ 其实很容易想到的就是分布式限流。我们将并发控制在一个可控的范围之内，然后快速失败这样就能最大程度的保护系统。

### distributed-redis-tool ⬆️v1.0.3 ###

为此还对 https://github.com/crossoverJie/distributed-redis-tool 进行了小小的升级。

因为加上该组件之后所有的请求都会经过 Redis，所以对 Redis 资源的使用也是要非常小心。

#### API 更新 ####

修改之后的 API 如下：

1.  `@Configuration`
2.  `public class RedisLimitConfig {`
3.    
    
4.  `   private Logger logger = LoggerFactory.getLogger(RedisLimitConfig.class);`
5.    
    
6.  `   @Value("${redis.limit}")`
7.  `   private int limit;`
8.    
    
9.    
    
10. `   @Autowired`
11. `   private JedisConnectionFactory jedisConnectionFactory;`
12.   
    
13. `   @Bean`
14. `   public RedisLimit build() {`
15. `       RedisLimit redisLimit = new RedisLimit.Builder(jedisConnectionFactory, RedisToolsConstant.SINGLE)`
16. `               .limit(limit)`
17. `               .build();`
18.   
    
19. `       return redisLimit;`
20. `   }`
21. `}`

这里构建器改用了 `JedisConnectionFactory`，所以得配合 Spring 来一起使用。

并在初始化时显示传入 Redis 是以集群方式部署还是单机（强烈建议集群，限流之后对 Redis 还是有一定的压力）。

##### 限流实现 #####

既然 API 更新了，实现自然也要修改：

1.  `   /**`
2.  `    * limit traffic`
3.  `    * @return if true`
4.  `    */`
5.  `   public boolean limit() {`
6.    
    
7.  `       //get connection`
8.  `       Object connection = getConnection();`
9.    
    
10. `       Object result = limitRequest(connection);`
11.   
    
12. `       if (FAIL_CODE != (Long) result) {`
13. `           return true;`
14. `       } else {`
15. `           return false;`
16. `       }`
17. `   }`
18.   
    
19. `   private Object limitRequest(Object connection) {`
20. `       Object result = null;`
21. `       String key = String.valueOf(System.currentTimeMillis() / 1000);`
22. `       if (connection instanceof Jedis){`
23. `           result = ((Jedis)connection).eval(script, Collections.singletonList(key), Collections.singletonList(String.valueOf(limit)));`
24. `           ((Jedis) connection).close();`
25. `       }else {`
26. `           result = ((JedisCluster) connection).eval(script, Collections.singletonList(key), Collections.singletonList(String.valueOf(limit)));`
27. `           try {`
28. `               ((JedisCluster) connection).close();`
29. `           } catch (IOException e) {`
30. `               logger.error("IOException",e);`
31. `           }`
32. `       }`
33. `       return result;`
34. `   }`
35.   
    
36. `   private Object getConnection() {`
37. `       Object connection ;`
38. `       if (type == RedisToolsConstant.SINGLE){`
39. `           RedisConnection redisConnection = jedisConnectionFactory.getConnection();`
40. `           connection = redisConnection.getNativeConnection();`
41. `       }else {`
42. `           RedisClusterConnection clusterConnection = jedisConnectionFactory.getClusterConnection();`
43. `           connection = clusterConnection.getNativeConnection() ;`
44. `       }`
45. `       return connection;`
46. `   }`

如果是原生的 Spring 应用得采用 `@SpringControllerLimit(errorCode=200)`注解。

实际使用如下，web 端：

![640?wx\_fmt=png][640_wx_fmt_png 2]

Service 端就没什么更新了，依然是采用的乐观锁更新数据库。

再压测看下效果 `/createOptimisticLimitOrderByRedis/1`：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 16]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 17]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 18]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 19]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 20]

首先是看结果没有问题，再看数据库连接以及并发请求数都有**明显的下降**。

##     ##

## 乐观锁更新 + 分布式限流 + Redis 缓存 ##

其实仔细观察 Druid 监控数据发现这个 SQL 被多次查询：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 21]

其实这是实时查询库存的 SQL，主要是为了在每次下单之前判断是否还有库存。

**这也是个优化点**。

这种数据我们完全可以放在内存中，效率比在数据库要高很多。

由于我们的应用是分布式的，所以堆内缓存显然不合适，Redis 就非常适合。

这次主要改造的是 Service 层：

*  每次查询库存时走 Redis。
 *  扣库存时更新 Redis。
 *  需要提前将库存信息写入 Redis（手动或者程序自动都可以）。

主要代码如下：

1.  `   @Override`
2.  `   public int createOptimisticOrderUseRedis(int sid) throws Exception {`
3.  `       //检验库存，从 Redis 获取`
4.  `       Stock stock = checkStockByRedis(sid);`
5.    
    
6.  `       //乐观锁更新库存 以及更新 Redis`
7.  `       saleStockOptimisticByRedis(stock);`
8.    
    
9.  `       //创建订单`
10. `       int id = createOrder(stock);`
11. `       return id ;`
12. `   }`
13.   
    
14.   
    
15. `   private Stock checkStockByRedis(int sid) throws Exception {`
16. `       Integer count = Integer.parseInt(redisTemplate.opsForValue().get(RedisKeysConstant.STOCK_COUNT + sid));`
17. `       Integer sale = Integer.parseInt(redisTemplate.opsForValue().get(RedisKeysConstant.STOCK_SALE + sid));`
18. `       if (count.equals(sale)){`
19. `           throw new RuntimeException("库存不足 Redis currentCount=" + sale);`
20. `       }`
21. `       Integer version = Integer.parseInt(redisTemplate.opsForValue().get(RedisKeysConstant.STOCK_VERSION + sid));`
22. `       Stock stock = new Stock() ;`
23. `       stock.setId(sid);`
24. `       stock.setCount(count);`
25. `       stock.setSale(sale);`
26. `       stock.setVersion(version);`
27.   
    
28. `       return stock;`
29. `   }    `
30.   
    
31.   
    
32. `   /**`
33. `    * 乐观锁更新数据库 还要更新 Redis`
34. `    * @param stock`
35. `    */`
36. `   private void saleStockOptimisticByRedis(Stock stock) {`
37. `       int count = stockService.updateStockByOptimistic(stock);`
38. `       if (count == 0){`
39. `           throw new RuntimeException("并发更新库存失败") ;`
40. `       }`
41. `       //自增`
42. `       redisTemplate.opsForValue().increment(RedisKeysConstant.STOCK_SALE + stock.getId(),1) ;`
43. `       redisTemplate.opsForValue().increment(RedisKeysConstant.STOCK_VERSION + stock.getId(),1) ;`
44. `   }    `

压测看看实际效果 `/createOptimisticLimitOrderByRedis/1`：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 22]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 23]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 24]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 25]

最后发现数据没问题，数据库的请求与并发也都下来了。

## 乐观锁更新 + 分布式限流 + Redis 缓存 + Kafka 异步 ##

最后的优化还是想如何来再次提高吞吐量以及性能的。我们上文所有例子其实都是同步请求，完全可以利用同步转异步来提高性能啊。

这里我们将写订单以及更新库存的操作进行异步化，利用 `Kafka` 来进行解耦和队列的作用。

每当一个请求通过了限流到达了 Service 层通过了库存校验之后就将订单信息发给 Kafka ，这样一个请求就可以直接返回了。

消费程序再对数据进行入库落地。因为异步了，所以最终需要采取回调或者是其他提醒的方式提醒用户购买完成。

这里代码较多就不贴了，消费程序其实就是把之前的 Service 层的逻辑重写了一遍，不过采用的是 SpringBoot。

感兴趣的朋友可以看下:

https://github.com/crossoverJie/SSM/tree/master/SSM-SECONDS-KILL/SSM-SECONDS-KILL-ORDER-CONSUMER

## 总结 ##

其实经过上面的一顿优化总结起来无非就是以下几点：

*  尽量将请求拦截在上游。
 *  还可以根据 UID 进行限流。
 *  最大程度的减少请求落到 DB。
 *  多利用缓存。
 *  同步操作异步化。
 *  fail fast，尽早失败，保护应用。

码字不易，这应该是我写过字数最多的了，想想当年高中 800 字的作文都憋不出来?，可想而知是有多难得了。

**以上内容欢迎讨论**。

**END**

**划至底部，点击“在看”，是你来过的仪式感！**

![640?wx\_fmt=png][640_wx_fmt_png]

**推荐阅读**：

*  [简历写了会Kafka，面试官90%会让你讲讲acks参数对消息持久化的影响！][Kafka_90_acks]  
    
    
      
    
 *  [面试最让你手足无措的一个问题：你的系统如何支撑高并发？][Link 2]

*  [Java高阶必备：如何优化Spring Cloud微服务注册中心架构？][Java_Spring Cloud]

*  [高并发场景下，如何保证生产者投递到消息中间件的消息不丢失？][Link 3]

*  [从团队自研的百万并发中间件系统的内核设计看Java并发性能优化！][Java]

*  [如果20万用户同时访问一个热点缓存，如何优化你的缓冲架构？][20]

**更多文章：**

*  [2018年原创汇总][2018]
 *  [2019年原创汇总（持续更新）][2019]
 *  [爆款推荐][Link 4]
 *  [面试专栏][Link 5]

![640?wx\_fmt=png][640_wx_fmt_png]

欢迎长按下图关注公众号**石杉的架构笔记**，后台回复“**学习**”，获取作者独家秘制精品资料

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 26]

**BAT架构经验倾囊相授**

![640?wx\_fmt=gif][640_wx_fmt_gif]

[640_wx_fmt_png]: /images/20220109/a70f3e467df54f98b0ef564be0f524b3.png
[BAT _360]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484144&idx=1&sn=a6b86d38a762e317ba78e2500fb1a8ff&chksm=fba6eaf3ccd163e5403a01be51216780040511b2ddc4d5750ace6e46b4242ceaf77d0432c680&scene=21#wechat_redirect
[Spring Cloud]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247483777&idx=1&sn=f144ee415bb743f5422314907fc7d819&chksm=fba6e982ccd160945aa5c53434e933e2f03e89d9faf634f0b573c1f7b6f4d6d2635cad091276&scene=21#wechat_redirect
[99.99]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247483876&idx=1&sn=51f8eadc16efd6b89eb1f3c6abe67e25&chksm=fba6e9e7ccd160f183b344d4773841ad8df9a2c099a16aae516ddb45aef7eaccb83570d171fe&scene=21#wechat_redirect
[BAT _Offer]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484170&idx=1&sn=6c178884c1c5399e37562b9dc66cff6c&chksm=fba6eb09ccd1621ff8821b37f12d6df8a1d269ddc95ad10c0a4e71a3bf0017952bf19978d8ec&scene=21#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247483948&idx=1&sn=e75aa8b5cfae1363391801e2f74bd2ee&chksm=fba6ea2fccd163390520dbc62b6170c7f3d456207e623fce4ded036fea525a6782a31098b905&scene=21#wechat_redirect
[640_wx_fmt_png 1]: /images/20220109/4f69964c450f4365b99975375b9c0a78.png
[640_wx_fmt_jpeg]: /images/20220109/b286d1bfbab347b9bcf8dc81b13321b7.png
[640_wx_fmt_jpeg 1]: /images/20220109/43e54d72c3ad419dad3eba7d2e5b13c9.png
[640_wx_fmt_jpeg 2]: /images/20220109/2527bb48c20442b686bf32be66543961.png
[640_wx_fmt_jpeg 3]: /images/20220109/b43e2a2925d7417a91f6b77bdf6c40a1.png
[640_wx_fmt_jpeg 4]: /images/20220109/17c4d35a84304d12a8871032b8758492.png
[640_wx_fmt_jpeg 5]: /images/20220109/4a32122501cf41d781524b33a807b5fc.png
[640_wx_fmt_jpeg 6]: /images/20220109/87b277ab2d054f7699fa0a19124645dd.png
[640_wx_fmt_jpeg 7]: /images/20220109/bfa73fd2ec0f473fbcb9960b10cce767.png
[640_wx_fmt_jpeg 8]: /images/20220109/c0182a809fa94e1fbd880f095ba8d52d.png
[640_wx_fmt_jpeg 9]: /images/20220109/6e901b41e18646e9ac6169f952bc1908.png
[640_wx_fmt_jpeg 10]: /images/20220109/c83cf7bd407045d480183a2ec51ab93a.png
[640_wx_fmt_jpeg 11]: /images/20220109/c7176ebaff6a4653aac86cc213051870.png
[640_wx_fmt_jpeg 12]: /images/20220109/3122f49f77e64f9ead5741d4468a1a05.png
[640_wx_fmt_jpeg 13]: /images/20220109/e8e41344ed384469b729ba50087ddce9.png
[640_wx_fmt_jpeg 14]: /images/20220109/57af3b2324234547b6f2ae600a6a2109.png
[640_wx_fmt_jpeg 15]: /images/20220109/375e7591d62f4c17a47eecb6b4c785e8.png
[640_wx_fmt_png 2]: /images/20220109/f0975a26b92647dca0f94cffc4a57736.png
[640_wx_fmt_jpeg 16]: /images/20220109/ae3a5159a8344339bf5c8f4e65135cd6.png
[640_wx_fmt_jpeg 17]: /images/20220109/cf6813b97db84214b0e9d38d755f2386.png
[640_wx_fmt_jpeg 18]: /images/20220109/340d1761c22a4f19a146cf44c2ee28e4.png
[640_wx_fmt_jpeg 19]: /images/20220109/dfe5f1e7f63b492da7541a02061366b7.png
[640_wx_fmt_jpeg 20]: /images/20220109/f37dd27b38be4e1786aa8b400e72aaa6.png
[640_wx_fmt_jpeg 21]: /images/20220109/6bc41a5c367b48b78ba4812f42509860.png
[640_wx_fmt_jpeg 22]: /images/20220109/38440240251c48ac8b77a406e56a950f.png
[640_wx_fmt_jpeg 23]: /images/20220109/ac318b8105f7454b9001b1f078807ab2.png
[640_wx_fmt_jpeg 24]: /images/20220109/9a651273163f443283a751b84620746f.png
[640_wx_fmt_jpeg 25]: /images/20220109/e1c53e095b2c4073b87325ef809143be.png
[Kafka_90_acks]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247485069&idx=1&sn=abd8ddc19fbb49c11c8ad9e1ffdff147&chksm=fba6ee8eccd1679874d5bd19109ed8cb3daadf59dabe67c906f8caed0714ba2dda16f5a032ce&scene=21#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484429&idx=1&sn=d8038c21ecd733b8bb7ff784014243f9&chksm=fba6ec0eccd165189e92a294ab2b7cd6796982c188befe05c27f4e96ae5cd39f2baf436cf37d&scene=21#wechat_redirect
[Java_Spring Cloud]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484680&idx=1&sn=d25e1f81ad75f68dd88755173843efad&chksm=fba6ed0bccd1641d7edfd05431904b96f2e3da7c04b3a75c2a350e374733f59971c01ddd9ae6&scene=21#wechat_redirect
[Link 3]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484377&idx=1&sn=373832e0d050bb0618448f4403f02f2a&chksm=fba6ebdaccd162cca4a26199554cbfbc37c4aec56fe54c3864a0a9cfc3255884ed212512e5cd&scene=21#wechat_redirect
[Java]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484395&idx=1&sn=46c756600ba36d94eb4439cf29810cae&chksm=fba6ebe8ccd162fef42bb35360df8ec6c75e1a9af1acc83ba333b3f35191ba8864c16e0a31da&scene=21#wechat_redirect
[20]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484401&idx=1&sn=823cffa4a1aa73335bdfb7c02e8c85f0&chksm=fba6ebf2ccd162e422b1b496f5790ebdf7f6d11adb8d2e00957ca371dcca0514a3fde09af521&scene=21#wechat_redirect
[2018]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247485040&idx=2&sn=e6eba27a4a912cbd320f28e6d8716241&chksm=fba6ee73ccd16765d9d59ad38dc29bb983439f8c91bda5aef068e79ce35cc6c87869e96481cb&scene=21#wechat_redirect
[2019]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247485185&idx=2&sn=df2470abbcedee1792246dfb81acb446&chksm=fba6ef02ccd166143a04c7a233c1a32b43ce003e6790543354c0248a01d92421de6f3e3b42c5&scene=21#wechat_redirect
[Link 4]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484866&idx=3&sn=b1018261f230a065b0888bc9b66d6df9&chksm=fba6edc1ccd164d70ff5cc4d31641562f9ba747e992b64041c29317b66f61e3c86566fce0a3d&scene=21#wechat_redirect
[Link 5]: http://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247485185&idx=3&sn=278ce173dd5af6bce78ad9125bed2f45&chksm=fba6ef02ccd16614b5f562c021d18f5db2bc79ba3b33a2bf590db8cc121a3f8e94b4284990c4&scene=21#wechat_redirect
[640_wx_fmt_jpeg 26]: /images/20220109/c23473a0a10b4c11bb204f741b4c1596.png
[640_wx_fmt_gif]: /images/20220109/7c704fbc679d4b9d8e40183152695c3b.png