设计高并发秒杀系统：保障稳定性与数据一致性



✨✨谢谢大家捧场，祝屏幕前的小伙伴们每天都有好运相伴左右，一定要天天开心哦！✨✨ 
🎈🎈作者主页： 喔的嘛呀🎈🎈

目录

引言

一. 系统架构设计

1. 系统架构图

二、 系统流程

三、流程实现（简单代码示范）

1、用户访问秒杀页面，点击秒杀按钮发起秒杀请求

前端部分（HTML + JavaScript）：

后端部分（Java + Spring Boot）：

2、前端负载均衡器将请求分发到多个前端应用服务器上。

Nginx配置示例：

Apache配置示例：

3、前端应用服务器验证用户身份，检查秒杀活动是否开始，是否已经结束。

前端应用服务器（使用Java + Spring Boot）：

4、前端应用服务器请求缓存服务器获取商品信息和库存数量

前端应用服务器（Java + Spring Boot）：

5、缓存负载均衡器将请求分发到多个缓存应用服务器上。

Redis Cluster配置示例：

Memcached Cluster配置示例：

缓存应用服务器（Java + Spring Boot）：

6、缓存应用服务器返回商品信息和库存数量给前端应用服务器

缓存应用服务器（Java + Spring Boot）：

7、前端应用服务器根据库存数量判断是否可以参与秒杀，如果可以则生成订单。

前端应用服务器（Java + Spring Boot）：

8、前端应用服务器将订单信息发送到后端负载均衡器

前端应用服务器（Java + Spring Boot）：

8、后端负载均衡器将请求分发到多个后端应用服务器上

后端负载均衡器（简化示例）：

9、后端应用服务器消费订单信息，根据订单信息生成订单，并更新库存数量。

后端应用服务器（Java + Spring Boot）：

10、后端应用服务器将订单信息写入数据库集群

后端应用服务器（Java + Spring Boot）：

11、 分布式锁用于保护对库存数量的操作，确保数据的一致性。

后端应用服务器（Java + Spring Boot）：

 总结

引言

设计高并发秒杀系统是一个挑战性的任务，需要考虑到系统的性能、稳定性和数据一致性。本文将介绍如何设计一个高并发的秒杀系统，使用消息队列和分布式锁来确保系统的稳定性和数据一致性。

一. 系统架构设计

我们的高并发秒杀系统将采用以下架构：

  • 前端页面：提供秒杀活动的入口，展示商品信息和剩余库存数量。
  • 后端服务：处理用户请求，验证用户身份，检查库存，并生成订单。
  • 数据库：存储商品信息和订单信息。
  • 缓存：缓存商品信息和库存数量，减少对数据库的访问压力。
  • 消息队列：用于异步处理订单生成和库存扣减操作，确保系统的高可用性和稳定性。
  • 分布式锁：用于保护对库存数量的操作，确保数据一致性。

1. 系统架构图

                                        +-------------------------------------+
                                        |             前端负载均衡器                |
                                        +-----------+--------------+--------------+
                                                    |                          |
                                        +-----------v--------------+--------------+
                                        |        前端应用服务器           |       CDN      |
                                        +-----------+--------------+--------------+
                                                    |                          |
        +----------------------+---------v----------+--------------+-------v--------+-------------+
        |            缓存层                |         |          后端应用服务器           |       数据库集群      |
        +-----------+--------------+         +-----------+--------------+--------------+
                    |                          |                          |
        +-----------v--------------+         +-----------v--------------+--------------+
        |          缓存服务器           |         |         消息队列              |       主数据库         |
        +-----------+--------------+         +-----------+--------------+--------------+
                    |                          |                          |
        +-----------v--------------+         +-----------v--------------+
        |        缓存存储(Redis)    |         |     业务数据存储(MySQL)    |
        +---------------------------+         +---------------------------+

在这个架构中：

  • 前端负载均衡器：负责将用户请求分发到多个前端应用服务器和CDN上，实现请求的负载均衡，如Nginx。
  • 前端应用服务器：处理用户请求，包括验证用户身份、检查秒杀活动是否开始、是否已经结束等，如Tomcat。
  • CDN：用于加速网页内容传输，提高访问速度和用户体验。
  • 缓存层：使用缓存层存储热点数据，减轻数据库压力，如Redis。
  • 缓存服务器：用于存储缓存数据，如Redis服务器。
  • 消息队列：用于处理订单生成和库存扣减等业务逻辑，提高系统的并发处理能力，如RabbitMQ。
  • 业务数据存储：存储业务数据，如MySQL数据库集群。

通过以上架构设计，可以实现一个高并发的秒杀系统，保证系统的性能、稳定性和数据一致性，为用户提供良好的秒杀体验。

二、 系统流程

  1. 用户访问秒杀页面，点击秒杀按钮发起秒杀请求。
  2. 前端负载均衡器将请求分发到多个前端应用服务器上。
  3. 前端应用服务器验证用户身份，检查秒杀活动是否开始，是否已经结束。
  4. 前端应用服务器请求缓存服务器获取商品信息和库存数量。
  5. 缓存负载均衡器将请求分发到多个缓存应用服务器上。
  6. 缓存应用服务器返回商品信息和库存数量给前端应用服务器。
  7. 前端应用服务器根据库存数量判断是否可以参与秒杀，如果可以则生成订单。
  8. 前端应用服务器将订单信息发送到后端负载均衡器。
  9. 后端负载均衡器将请求分发到多个后端应用服务器上。
  10. 后端应用服务器消费订单信息，根据订单信息生成订单，并更新库存数量。
  11. 后端应用服务器将订单信息写入数据库集群。
  12. 分布式锁用于保护对库存数量的操作，确保数据的一致性。

三、流程实现（简单代码示范）

1、用户访问秒杀页面，点击秒杀按钮发起秒杀请求

流程如下：

前端部分（HTML + JavaScript）：

<!DOCTYPE html>
<html>
<head>
    <title>秒杀页面</title>
</head>
<body>
    <h1>欢迎参加秒杀活动！</h1>
    <button id="seckillButton">秒杀按钮</button>
    <div id="result"></div>

    <script>
        document.getElementById("seckillButton").addEventListener("click", function() {
            // 模拟用户ID和商品ID
            var userId = 123;
            var productId = 456;

            fetch("/seckill", {
                method: "POST",
                headers: {
                    "Content-Type": "application/json"
                },
                body: JSON.stringify({ userId: userId, productId: productId })
            })
            .then(response => response.json())
            .then(data => {
                document.getElementById("result").innerText = data.message;
            });
        });
    </script>
</body>
</html>

后端部分（Java + Spring Boot）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class SeckillApplication {

    private boolean seckillStarted = true; // 模拟秒杀活动是否开始
    private int stock = 10; // 模拟商品库存

    public static void main(String[] args) {
        SpringApplication.run(SeckillApplication.class, args);
    }

    @RestController
    public class SeckillController {

        @PostMapping("/seckill")
        public String seckill(@RequestBody SeckillRequest request) {
            if (!seckillStarted) {
                return "秒杀活动未开始";
            }

            if (stock <= 0) {
                return "商品已售罄";
            }

            // 模拟生成订单
            stock--;
            return "秒杀成功";
        }
    }

    public static class SeckillRequest {
        private Long userId;
        private Long productId;

        // 省略getter和setter方法
    }
}

2、前端负载均衡器将请求分发到多个前端应用服务器上。

前端负载均衡器将请求分发到多个前端应用服务器上，可以通过配置负载均衡器（如Nginx、Apache等）来实现。以下是一个简单的示例：

假设有两台前端应用服务器，分别运行在不同的端口上（假设为8001和8002）。

Nginx配置示例：

upstream frontends {
    server 127.0.0.1:8001;
    server 127.0.0.1:8002;
}

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://frontends;
    }
}

在这个示例中，Nginx配置了一个名为frontends的upstream，其中包含两台前端应用服务器的地址和端口。当收到用户请求时，Nginx会根据一定的负载均衡算法（如轮询、权重等）将请求转发到这些服务器上。

Apache配置示例：

<Proxy balancer://frontends>
    BalancerMember http://127.0.0.1:8001
    BalancerMember http://127.0.0.1:8002
</Proxy>

<VirtualHost *:80>
    ServerName example.com

    ProxyPass / balancer://frontends/
    ProxyPassReverse / balancer://frontends/
</VirtualHost>

在这个示例中，Apache配置了一个名为frontends的负载均衡器，其中包含两台前端应用服务器的地址和端口。当收到用户请求时，Apache会将请求转发到这些服务器上，实现负载均衡。

3、前端应用服务器验证用户身份，检查秒杀活动是否开始，是否已经结束。

以下是一个简单的示例，展示前端应用服务器验证用户身份，检查秒杀活动是否开始或结束的过程：

前端应用服务器（使用Java + Spring Boot）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class FrontendApplication {

    private boolean seckillStarted = true; // 模拟秒杀活动是否开始
    private boolean seckillEnded = false; // 模拟秒杀活动是否结束

    public static void main(String[] args) {
        SpringApplication.run(FrontendApplication.class, args);
    }

    @RestController
    public class SeckillController {

        @PostMapping("/seckill")
        public String seckill(@RequestBody SeckillRequest request) {
            // 验证用户身份，假设用户身份验证通过
            if (!isUserAuthenticated(request.getUserId())) {
                return "用户身份验证失败";
            }

            // 检查秒杀活动是否开始或结束
            if (!isSeckillStarted()) {
                return "秒杀活动未开始";
            }

            if (isSeckillEnded()) {
                return "秒杀活动已结束";
            }

            // 处理秒杀请求
            return "秒杀请求处理中";
        }

        private boolean isUserAuthenticated(Long userId) {
            // 省略实际的用户身份验证逻辑
            return true;
        }

        private boolean isSeckillStarted() {
            // 省略实际的秒杀活动开始检查逻辑
            return seckillStarted;
        }

        private boolean isSeckillEnded() {
            // 省略实际的秒杀活动结束检查逻辑
            return seckillEnded;
        }
    }

    public static class SeckillRequest {
        private Long userId;
        private Long productId;

        // 省略getter和setter方法
    }
}

在这个示例中，前端应用服务器通过Spring Boot框架实现了一个简单的/seckill接口，接收用户的秒杀请求。在处理请求之前，先验证用户身份，然后检查秒杀活动是否开始或结束。如果用户身份验证失败，则返回"用户身份验证失败"；如果秒杀活动未开始，则返回"秒杀活动未开始"；如果秒杀活动已结束，则返回"秒杀活动已结束"；否则处理秒杀请求。

4、前端应用服务器请求缓存服务器获取商品信息和库存数量

前端应用服务器（Java + Spring Boot）：

首先，需要在前端应用服务器中配置缓存服务器的地址和端口信息，以便发送请求。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class FrontendApplication {

    private static final String CACHE_SERVER_URL = "http://cache-server:8080"; // 缓存服务器地址

    public static void main(String[] args) {
        SpringApplication.run(FrontendApplication.class, args);
    }

    @RestController
    public class SeckillController {

        private final RestTemplate restTemplate = new RestTemplate();

        @PostMapping("/seckill")
        public String seckill(@RequestBody SeckillRequest request) {
            // 请求缓存服务器获取商品信息和库存数量
            String url = CACHE_SERVER_URL + "/product/" + request.getProductId();
            ProductInfo productInfo = restTemplate.getForObject(url, ProductInfo.class);

            if (productInfo == null) {
                return "获取商品信息失败";
            }

            // 处理秒杀请求
            return "请求处理中";
        }
    }

    public static class SeckillRequest {
        private Long userId;
        private Long productId;

        // 省略getter和setter方法
    }

    public static class ProductInfo {
        private Long productId;
        private String productName;
        private int stock;

        // 省略getter和setter方法
    }
}

在这个示例中，前端应用服务器使用RestTemplate发送GET请求到缓存服务器的/product/{productId}路由，获取商品信息和库存数量。如果成功获取到商品信息，则继续处理秒杀请求；否则返回"获取商品信息失败"。

5、缓存负载均衡器将请求分发到多个缓存应用服务器上。

缓存负载均衡器将请求分发到多个缓存应用服务器上，可以通过配置缓存负载均衡器（如Redis Cluster、Memcached Cluster等）来实现。以下是一个简单的示例：

假设有两台缓存应用服务器，分别运行在不同的地址和端口上（假设为cache-server1:6379和cache-server2:6379）。

Redis Cluster配置示例：

# 启动redis-server节点1
redis-server --port 6379

# 启动redis-server节点2
redis-server --port 6380

# 创建Redis Cluster
redis-cli --cluster create cache-server1:6379 cache-server2:6379 --cluster-replicas 1

在这个示例中，我们创建了一个包含两个主节点和一个从节点的Redis Cluster。缓存负载均衡器可以将请求分发到这个Redis Cluster上，实现缓存的负载均衡。

Memcached Cluster配置示例：

# 安装memcached
sudo apt-get update
sudo apt-get install memcached

# 启动memcached节点1
memcached -p 11211 -d

# 启动memcached节点2
memcached -p 11212 -d

# 配置memcached集群
echo "add 127.0.0.1 11212" | nc 127.0.0.1 11211

在这个示例中，我们创建了一个包含两个节点的Memcached Cluster。缓存负载均衡器可以将请求分发到这个Memcached Cluster上，实现缓存的负载均衡。

在实际生产环境中，需要根据具体需求和负载情况来配置缓存负载均衡器，并保证缓存服务器之间的数据同步和一致性。

6、缓存应用服务器返回商品信息和库存数量给前端应用服务器

缓存应用服务器（Java + Spring Boot）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@SpringBootApplication
public class CacheServerApplication {

    private static final Map<Long, ProductInfo> productCache = new HashMap<>();

    public static void main(String[] args) {
        SpringApplication.run(CacheServerApplication.class, args);
    }

    @RestController
    public class CacheController {

        @GetMapping("/product/{productId}")
        public ProductInfo getProductInfo(@PathVariable Long productId) {
            // 从缓存中获取商品信息
            return productCache.getOrDefault(productId, new ProductInfo(productId, "Unknown", 0));
        }
    }

    public static class ProductInfo {
        private Long productId;
        private String productName;
        private int stock;

        public ProductInfo(Long productId, String productName, int stock) {
            this.productId = productId;
            this.productName = productName;
            this.stock = stock;
        }

        // 省略getter和setter方法
    }
}

在这个示例中，缓存应用服务器通过Spring Boot框架实现了一个简单的/cache接口，接收前端应用服务器的商品信息请求。根据商品ID从缓存中获取商品信息，如果缓存中不存在该商品信息，则返回一个未知商品信息。

6、缓存应用服务器返回商品信息和库存数量给前端应用服务器

缓存应用服务器（Java + Spring Boot）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@SpringBootApplication
public class CacheServerApplication {

    private static final Map<Long, ProductInfo> productCache = new HashMap<>();

    public static void main(String[] args) {
        SpringApplication.run(CacheServerApplication.class, args);
    }

    @RestController
    public class CacheController {

        @GetMapping("/product/{productId}")
        public ProductInfo getProductInfo(@PathVariable Long productId) {
            // 从缓存中获取商品信息
            return productCache.getOrDefault(productId, new ProductInfo(productId, "Unknown", 0));
        }
    }

    public static class ProductInfo {
        private Long productId;
        private String productName;
        private int stock;

        public ProductInfo(Long productId, String productName, int stock) {
            this.productId = productId;
            this.productName = productName;
            this.stock = stock;
        }

        // 省略getter和setter方法
    }
}

在这个示例中，缓存应用服务器通过Spring Boot框架实现了一个简单的/cache接口，接收前端应用服务器的商品信息请求。根据商品ID从缓存中获取商品信息，如果缓存中不存在该商品信息，则返回一个未知商品信息。

7、前端应用服务器根据库存数量判断是否可以参与秒杀，如果可以则生成订单。

前端应用服务器（Java + Spring Boot）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@SpringBootApplication
public class FrontendApplication {

    private static final Map<Long, Integer> stockMap = new HashMap<>(); // 模拟商品库存
    private static final Map<Long, Boolean> seckillMap = new HashMap<>(); // 模拟秒杀活动是否开始
    private static final Map<Long, Boolean> seckillEndMap = new HashMap<>(); // 模拟秒杀活动是否结束
    private static final Map<Long, Long> userOrders = new HashMap<>(); // 模拟用户订单

    public static void main(String[] args) {
        // 初始化商品库存
        stockMap.put(1L, 10);
        // 初始化秒杀活动状态
        seckillMap.put(1L, true);
        // 初始化秒杀活动结束状态
        seckillEndMap.put(1L, false);

        SpringApplication.run(FrontendApplication.class, args);
    }

    @RestController
    public class SeckillController {

        @PostMapping("/seckill")
        public String seckill(@RequestBody SeckillRequest request) {
            Long productId = request.getProductId();
            Long userId = request.getUserId();

            // 判断秒杀活动是否开始或结束
            if (!seckillMap.getOrDefault(productId, false)) {
                return "秒杀活动未开始";
            }

            if (seckillEndMap.getOrDefault(productId, true)) {
                return "秒杀活动已结束";
            }

            // 判断库存是否足够
            Integer stock = stockMap.getOrDefault(productId, 0);
            if (stock <= 0) {
                return "商品已售罄";
            }

            // 生成订单
            userOrders.put(userId, productId);
            // 更新库存
            stockMap.put(productId, stock - 1);

            return "秒杀成功";
        }
    }

    public static class SeckillRequest {
        private Long userId;
        private Long productId;

        // 省略getter和setter方法
    }
}

在这个示例中，前端应用服务器根据商品ID获取库存数量，判断秒杀活动是否开始或结束，以及库存是否足够。如果满足条件，则生成订单并更新库存，返回秒杀成功；否则返回相应的错误信息。

8、前端应用服务器将订单信息发送到后端负载均衡器

前端应用服务器（Java + Spring Boot）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class FrontendApplication {

    private static final String LOAD_BALANCER_URL = "http://backend-load-balancer";

    public static void main(String[] args) {
        SpringApplication.run(FrontendApplication.class, args);
    }

    @RestController
    public class OrderController {

        private final RestTemplate restTemplate = new RestTemplate();

        @PostMapping("/order")
        public String placeOrder(@RequestBody OrderRequest request) {
            // 向后端负载均衡器发送订单信息
            String url = LOAD_BALANCER_URL + "/order";
            return restTemplate.postForObject(url, request, String.class);
        }
    }

    public static class OrderRequest {
        private Long orderId;
        private Long productId;
        private Long userId;

        // 省略getter和setter方法
    }
}

在这个示例中，前端应用服务器通过Spring Boot框架实现了一个简单的/order接口，接收订单信息，并使用RestTemplate将订单信息发送到后端负载均衡器的/order接口。

8、后端负载均衡器将请求分发到多个后端应用服务器上

后端负载均衡器（简化示例）：

在实际应用中，后端负载均衡器可以使用诸如Nginx、HAProxy、AWS ELB等工具来实现。这里简化为直接在Java中模拟负载均衡器的行为。

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class LoadBalancer {

    private List<String> backendServers;

    public LoadBalancer() {
        backendServers = new ArrayList<>();
        backendServers.add("http://backend-server1");
        backendServers.add("http://backend-server2");
        // 添加更多后端服务器...
    }

    public String selectBackendServer() {
        // 模拟负载均衡算法，这里简单使用随机选择
        Random random = new Random();
        int index = random.nextInt(backendServers.size());
        return backendServers.get(index);
    }

    public static void main(String[] args) {
        LoadBalancer loadBalancer = new LoadBalancer();
        // 模拟请求分发给后端服务器
        for (int i = 0; i < 10; i++) {
            String backendServer = loadBalancer.selectBackendServer();
            System.out.println("Request sent to: " + backendServer);
        }
    }
}

在这个示例中，LoadBalancer类模拟了一个简单的负载均衡器，它维护了一个后端服务器列表，并实现了一个简单的随机选择算法来选择后端服务器。在实际应用中，需要根据实际情况选择合适的负载均衡算法。

9、后端应用服务器消费订单信息，根据订单信息生成订单，并更新库存数量。

后端应用服务器（Java + Spring Boot）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@SpringBootApplication
public class BackendApplication {

    private static final Map<Long, Integer> stockMap = new HashMap<>();

    public static void main(String[] args) {
        // 初始化库存数量
        stockMap.put(1L, 10);

        SpringApplication.run(BackendApplication.class, args);
    }

    @RestController
    public class OrderController {

        @PostMapping("/order")
        public String createOrder(@RequestBody OrderRequest request) {
            Long orderId = request.getOrderId();
            Long productId = request.getProductId();
            Long userId = request.getUserId();

            // 判断库存是否足够
            Integer stock = stockMap.getOrDefault(productId, 0);
            if (stock <= 0) {
                return "商品已售罄";
            }

            // 生成订单
            String orderInfo = "订单信息：订单号-" + orderId + "，商品ID-" + productId + "，用户ID-" + userId;
            // 更新库存数量
            stockMap.put(productId, stock - 1);

            return "生成订单成功：" + orderInfo;
        }
    }

    public static class OrderRequest {
        private Long orderId;
        private Long productId;
        private Long userId;

        // 省略getter和setter方法
    }
}

在这个示例中，后端应用服务器通过Spring Boot框架实现了一个简单的/order接口，接收订单信息，并根据订单信息生成订单，并更新库存数量。如果库存不足，则返回"商品已售罄"。

10、后端应用服务器将订单信息写入数据库集群

将订单信息写入数据库集群是一个关键的步骤，需要考虑到数据的一致性和高可用性。下面是一个详细全面的示例，演示如何将订单信息写入数据库集群：

后端应用服务器（Java + Spring Boot）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

@SpringBootApplication
public class BackendApplication {

    public static void main(String[] args) {
        SpringApplication.run(BackendApplication.class, args);
    }

    @RestController
    public class OrderController {

        @PostMapping("/order")
        public String createOrder(@RequestBody OrderRequest request) {
            Long orderId = request.getOrderId();
            Long productId = request.getProductId();
            Long userId = request.getUserId();

            // 生成订单
            String orderInfo = "订单信息：订单号-" + orderId + "，商品ID-" + productId + "，用户ID-" + userId;

            // 将订单信息写入数据库集群
            boolean success = writeToDatabase(orderInfo);

            if (success) {
                return "生成订单成功：" + orderInfo;
            } else {
                return "生成订单失败：" + orderInfo;
            }
        }

        private boolean writeToDatabase(String orderInfo) {
            // 连接数据库集群 这里为了方便演示没有用yaml进行配置
            String url = "jdbc:mysql://database-cluster:3306/database";
            String user = "user";
            String password = "password";
            try (Connection connection = DriverManager.getConnection(url, user, password)) {
                // 写入订单信息
                String sql = "INSERT INTO orders (order_info) VALUES (?)";
                try (PreparedStatement statement = connection.prepareStatement(sql)) {
                    statement.setString(1, orderInfo);
                    int rowsAffected = statement.executeUpdate();
                    return rowsAffected > 0;
                }
            } catch (SQLException e) {
                e.printStackTrace();
                return false;
            }
        }
    }

    public static class OrderRequest {
        private Long orderId;
        private Long productId;
        private Long userId;

        // 省略getter和setter方法
    }
}

11、 分布式锁用于保护对库存数量的操作，确保数据的一致性。

分布式锁用于保护对库存数量的操作，确保数据的一致性。下面是一个详细全面的示例，演示如何使用Redis实现分布式锁来保护对库存数量的操作：

后端应用服务器（Java + Spring Boot）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;

@SpringBootApplication
public class BackendApplication {

    private static final String REDIS_HOST = "localhost";
    private static final int REDIS_PORT = 6379;
    private static final String LOCK_KEY = "inventory_lock";
    private static final String INVENTORY_KEY = "inventory";

    public static void main(String[] args) {
        SpringApplication.run(BackendApplication.class, args);
    }

    @RestController
    public class OrderController {

        @PostMapping("/order")
        public String createOrder(@RequestBody OrderRequest request) {
            Long orderId = request.getOrderId();
            Long productId = request.getProductId();
            Long userId = request.getUserId();

            // 获取分布式锁
            try (Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT)) {
                boolean locked = false;
                while (!locked) {
                    locked = jedis.setnx(LOCK_KEY, "locked") == 1;
                    if (!locked) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                }

                // 获取锁成功，处理订单
                int stock = Integer.parseInt(jedis.get(INVENTORY_KEY));
                if (stock > 0) {
                    // 生成订单
                    String orderInfo = "订单信息：订单号-" + orderId + "，商品ID-" + productId + "，用户ID-" + userId;
                    System.out.println("生成订单成功：" + orderInfo);

                    // 更新库存数量
                    jedis.set(INVENTORY_KEY, String.valueOf(stock - 1));
                } else {
                    System.out.println("商品已售罄");
                }

                // 释放锁
                jedis.del(LOCK_KEY);
            }

            return "订单处理完成";
        }
    }

    public static class OrderRequest {
        private Long orderId;
        private Long productId;
        private Long userId;

        // 省略getter和setter方法
    }
}

在这个示例中，后端应用服务器通过Spring Boot框架实现了一个简单的/order接口，接收订单信息，并使用Redis实现分布式锁来保护对库存数量的操作。当多个请求同时到达时，只有一个请求能够获得锁并处理订单，其他请求需要等待锁释放后才能继续处理。这样可以保证对库存数量的操作是原子性的，从而确保数据的一致性。

 总结

设计高并发的秒杀系统需要考虑到多个方面，包括系统架构、技术选型、流程设计和代码实现等。通过合理的架构设计和技术选型，可以实现一个稳定高效的秒杀系统，为用户提供良好的购物体验。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/435900.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Github 2024-03-07 开源项目日报Top10

Github 2024-03-07 开源项目日报Top10

根据Github Trendings的统计，今日(2024-03-07统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下： 开发语言项目数量Python项目4C++项目3C#项目1TypeScript项目1非开发语言项目1HTML项目1CSS项目1屏幕截图转代码应用 创建周期：114 天开发语言：TypeScript, Pyt…
阅读更多...
【VTKExamples::PolyData】第五十三期 WeightedTransformFilter

【VTKExamples::PolyData】第五十三期 WeightedTransformFilter

很高兴在雪易的CSDN遇见你 VTK技术爱好者 QQ：870202403 公众号：VTK忠粉 前言 本文分享VTK样例WeightedTransformFilter，并解析接口vtkWeightedTransformFilter，希望对各位小伙伴有所帮助！ 感谢各位小伙伴的点赞+关注，小易会继续努力分享，一起进步！ 你的点赞就…
阅读更多...
二维码门楼牌管理系统应用场景：助力紧急服务

二维码门楼牌管理系统应用场景：助力紧急服务

文章目录 前言一、紧急服务部门的传统挑战二、二维码门楼牌管理系统的优势三、实际应用案例分析四、未来展望 前言 随着城市化的快速发展&#xff0c;传统的门牌管理系统已无法满足现代社会的需求。二维码门楼牌管理系统的出现&#xff0c;为紧急服务部门&#xff08;如警察、…
阅读更多...
RabbitMQ 交换器

RabbitMQ 交换器

RabbitMQ 交换器 官方例子 http://www.rabbitmq.com/getstarted.html direct 如上图所示&#xff0c;两个队列绑定到了direct交换器上&#xff0c;第一个队列绑定的 binding key 为 orange &#xff0c;第二个队列有两个绑定&#xff0c;分别是 black 和 green 。 如上图所示…
阅读更多...
C#，入门教程(26)——数据的基本概念与使用方法

C#，入门教程(26)——数据的基本概念与使用方法

上一篇&#xff1a; C#&#xff0c;入门教程(25)——注释&#xff08;Comments&#xff09;你会吗&#xff1f;看多图演示&#xff0c;学真正注释。https://blog.csdn.net/beijinghorn/article/details/124681888 本文所述的知识基本上适用于C/C&#xff0c;java等其他语言。 …
阅读更多...
脉宽调制PWM控制器有哪些国产替代可选择？

脉宽调制PWM控制器有哪些国产替代可选择？

一、脉宽调制PWM简介 PWM的理论基础为面积等效原理&#xff0c;这个原理简单描述就是冲量相等&#xff08;信号对时间的积分&#xff0c;即面积&#xff09;而形状不同的窄脉冲加在具有惯性的环节上时&#xff0c;其效果基本相同。冲量相等而形状不同的窄脉冲加在具有惯性的环…
阅读更多...
基于机器学习的垃圾分类

基于机器学习的垃圾分类

1绪论 1.1问题背景 垃圾分类有减少环境污染、节省土地资源、再生资源的利用、提高民众价值观念等的好处&#xff0c;在倡导绿色生活&#xff0c;注重环境保护的今天&#xff0c;正确的垃圾分类和处理对我们的生态环境显得尤为重要。 在国外很多国家&#xff0c;经过了几十年…
阅读更多...
vue3+ts项目创建 使用npm create vue@latest

vue3+ts项目创建 使用npm create vue@latest

npm create vuelatest相关创建代码&#xff1a;
阅读更多...
[Spring Boot] 集成Nacos

[Spring Boot] 集成Nacos

文章目录 Spring Boot 集成nacosSpring Boot版本pom配置引入bootstrap.yml 增加配置启动项目 版本对应关系2022.x 分支2021.x 分支2.2.x 分支 组件版本关系 Spring Boot 集成nacos Spring Boot版本 本文采用 2.6.13 其他版本可见文末版本对应 <parent><groupId>o…
阅读更多...
Tomcat介绍在IDEA中创建JavaWeb工程

Tomcat介绍在IDEA中创建JavaWeb工程

文章目录 一、WEB服务器服务器概述使用Java代码手写web服务器 二、服务器软件Web服务器服务器软件的使用步骤 三、TomcatTomcat的下载Tomcat的安装与卸载Tomcat的启动与关闭常见问题 四、新建Java Web项目并将项目部署到tomcat中新建Java Web项目将项目部署到Tomcat中出现的问题…
阅读更多...
1.3 数据库系统的结构

1.3 数据库系统的结构

目录 1.3.1 数据库系统模式的概念 1.3.2 数据库系统的三级模式结构 1. 模式 2. 外模式 3.内模式&#xff08;也称存储模式&#xff09; 1.3.3 数据库的二级映像功能与数据独立性 1.外模式&#xff0f;模式映像 2.模式&#xff0f;内模式映像 1.3.4 总结 模式 内模式…
阅读更多...
Linux——线程同步互斥（线程安全）

Linux——线程同步互斥（线程安全）

线程互斥 进程线程间的互斥相关背景概念 临界资源&#xff1a;多线程执行流共享的资源就叫做临界资源临界区&#xff1a;每个线程内部&#xff0c;访问临界资源的代码&#xff0c;就叫做临界区互斥&#xff1a;任何时刻&#xff0c;互斥保证有且只有一个执行流进入临界区&…
阅读更多...
K倍区间 刷题笔记

K倍区间 刷题笔记

法一 前缀和暴力搜索 &#xff08;数据大会超时&#xff09; #include<iostream> #include<cstring> #include<algorithm> #include<cstdio> using namespace std; const int N100010; int a[N],s[N]; int n,k; int main(){ cin>>n>>…
阅读更多...
第3部分 原理篇3可验证凭证（VC）（1）

第3部分 原理篇3可验证凭证（VC）（1）

3.3. 可验证凭证 3.3.1. 本节内容概述 本聪老师&#xff1a;今天开始去中心化身份中另一个最重要的概念可验证凭证&#xff08;verifiable credential&#xff09;的学习。凭证&#xff0c;也就是证件&#xff0c;在人类生活中不可或缺。可验证凭证实现了凭证的机器可读、加密…
阅读更多...
微信小程序（五十一）页面背景（全屏）

微信小程序（五十一）页面背景（全屏）

注释很详细&#xff0c;直接上代码 上一篇 新增内容&#xff1a; 1.页面背景的基本写法 2.去除默认上标题实习全屏背景 3. 背景适配细节 源码&#xff1a; index.wxss page{/* 背景链接 */background-image: url(https://pic3.zhimg.com/v2-a76bafdecdacebcc89b5d4f351a53e6a_…
阅读更多...
嵌入式开发的常用软件、学习资源网站推荐

嵌入式开发的常用软件、学习资源网站推荐

1、软件推荐 1.1、文本编辑软件 ——Notepad 1、适合编写和查看文本文件&#xff0c;也可以安装插件来查看二进制文件、对比文件 2、参考博客&#xff1a;《Notepad实用小技巧》&#xff1b; 1.2、PDF文件阅读软件——福昕PDF阅读器 福昕PDF阅读器&#xff0c;在官网就可以下载…
阅读更多...
部署YOLOv8模型的实用常见场景

部署YOLOv8模型的实用常见场景

可以的话&#xff0c;GitHub上点个小心心&#xff0c;翻不了墙的xdm&#xff0c;csdn也可以点个赞&#xff0c;谢谢啦 车流量检测&#xff08;开源代码github&#xff09;&#xff1a; test3 meiqisheng/YOLOv8-DeepSORT-Object-Tracking (github.com) 车牌检测&#xff0…
阅读更多...
Docker前后端项目部署

Docker前后端项目部署

目录 一、搭建项目部署的局域网 二、redis安装 三、MySQL安装 四、若依后端项目搭建 4.1 使用Dockerfile自定义镜像 五、若依前端项目搭建 一、介绍前后端项目 二、搭建项目部署的局域网 搭建net-ry局域网&#xff0c;用于部署若依项目 docker network create net-ry -…
阅读更多...
node模块分类

node模块分类

模块 分类 在node种有很多模块&#xff0c;有我们自己写的javascript文件&#xff0c;也会有javascript自带的&#xff0c;还有我们可以下载别人写好的javascript。主要分为三大类。 1. 内置模块 在安装node的时候就自带的模块&#xff0c;比如说http、fs、path等。内置模块一…
阅读更多...
如何远程访问电脑文件？

如何远程访问电脑文件？

远程访问电脑文件是当今数字化时代中十分常见且实用的技术。它允许我们从任何地方的计算机或移动设备访问和操作我们的电脑中的文件。无论是远程工作、远程学习、远程协作还是方便地获得自己计算机上的重要文件&#xff0c;远程访问电脑文件都为我们提供了巨大的便利。 在远程访…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站