2. 程式人生 > 實用技巧 >[整理] 一個簡單版本的秒殺系統設計

[整理] 一個簡單版本的秒殺系統設計

阿新 • • 發佈：2020-12-19

目錄
簡單版本的，只用於併發比較小的場景。
常用的三種設計策略：1.寫入記憶體而不是寫入硬碟；2.非同步處理而不是同步處理；3.分散式處理；這裡只用了1。
另外不涉及前端，也不涉及機器秒殺和安全策略。

秒殺系統的難點

  • 高併發、負載壓力大
  • 競爭資源有限
  • 對其它業務有影響
  • 提防黃牛黨

秒殺系統的場景

  • 商品搶購
  • 群紅包
  • 優惠券領取
  • 搶火車票
  • 線上預約

設計原則

頁面 -> 站點 -> 服務 -> 資料庫

  • 儘量將壓力攔截在上游
    系統的瓶頸往往在資料庫，資料庫併發能力有限。

  • 充分利用快取
    讀多寫少意味著必須充分利用快取

  • 熱點隔離

    • 業務隔離（預售報名、分時段）
      將秒殺業務獨立出來，儘量不與其他業務關聯，以減少對其他業務的依賴性。譬如秒殺業務只保留使用者id，商品id，數量等重要屬性，通過中介軟體傳送給業務系統，完成後續的處理。

    • 系統隔離
      將秒殺業務單獨部署，以減少對其他業務伺服器的壓力。

    • 資料隔離
      由於秒殺對DB的壓力很大，將DB單獨部署，不與其他業務DB放一起，避免對DB的壓力。

使用DB完成秒殺系統

1. 初始化專案

以Springboot，mysql，jpa為技術方案。
新建Springboot專案，pom如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
 
	<groupId>com.tianyalei</groupId>
	<artifactId>common</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
 
	<name>common</name>
	<description>Demo project for Spring Boot</description>
 
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
 
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>
 
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<optional>true</optional><!-- optional=true,依賴不會傳遞，該專案依賴devtools；之後依賴myboot專案的專案如果想要使用devtools，需要重新引入 -->
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.18</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
 
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

avaBean

import javax.persistence.*;

@Entity
public class GoodInfo {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    //數量
    private int amount;
    //商品編碼
    @Column(unique = true)
    private String code;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public int getAmount() {
        return amount;
    }
 
    public void setAmount(int amount) {
        this.amount = amount;
    }
 
    public String getCode() {
        return code;
    }
 
    public void setCode(String code) {
        this.code = code;
    }
}

dao層，注意一下sql語句，where條件中的amount - count >= 0是關鍵，該語句能嚴格保證不超賣。

import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
 
public interface GoodInfoRepository extends CrudRepository<GoodInfo, Integer> {
    @Query("update GoodInfo set amount = amount - ?2 where code = ?1 and amount - ?2 >= 0")
    @Modifying
    int updateAmount(String code, int count);
}

service介面

public interface GoodInfoService {
    void add(GoodInfo goodInfo);
    void delete(GoodInfo goodInfo);
    int update(String code, int count);
}

Service實現類

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service("db")
public class GoodInfoDbService implements GoodInfoService {
 
    @Autowired
    private GoodInfoRepository goodInfoRepository;
 
    @Transactional
    public int update(String code, int count) {
        return goodInfoRepository.updateAmount(code, count);
    }
 
    public void add(GoodInfo goodInfo) {
        goodInfoRepository.save(goodInfo);
    }
 
    public void delete(GoodInfo goodInfo) {
        goodInfoRepository.deleteAll();
    }
}

yml配置檔案

pring:
  jpa:
    database: mysql
    show-sql: true
    hibernate:
      ddl-auto: update
  datasource:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/test
      username: root
      password:
  redis:
        host: localhost
        port: 6379
        password:
        pool:
          max-active: 8
          max-idle: 8
          min-idle: 0
          max-wait: 10000
  profiles:
    active: dev
server:
  port: 8080

以上即是基本配置。

2. 模擬併發訪問搶購

新建junit測試類

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
 
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTest {
 
    @Resource(name = "db")
    private GoodInfoService service;
 
    private String goodCode = "iphone7";
    /**
     * 機器總數量
     */
    private int goodAmount = 100;
    /**
     * 併發量
     */
    private int threadNum = 200;
 
    //銷售量
    private int goodSale = 0;
 
    //買成功的數量
    private int accountNum = 0;
    //買成功的人的ID集合
    private List<Integer> successUsers = new ArrayList<>();
 
    private GoodInfo goodInfo;
 
    /*當建立 CountDownLatch 物件時，物件使用建構函式的引數來初始化內部計數器。每次呼叫 countDown() 方法,
     CountDownLatch 物件內部計數器減一。當內部計數器達到0時， CountDownLatch 物件喚醒全部使用 await() 方法睡眠的執行緒們。*/
    private CountDownLatch countDownLatch = new CountDownLatch(threadNum);
 
    @Test
    public void contextLoads() {
        for (int i = 0; i < threadNum; i++) {
            new Thread(new UserRequest(goodCode, 7, i)).start();
            countDownLatch.countDown();
        }
 
        //讓主執行緒等待200個執行緒執行完，休息2秒，不休息的話200條執行緒還沒執行完，就列印了
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----------購買成功的使用者數量----------為" + accountNum);
        System.out.println("-----------銷售量--------------------為" + goodSale);
        System.out.println("-----------剩餘數量------------------為" + (goodAmount - goodSale));
        System.out.println(successUsers);
    }
 
    private class UserRequest implements Runnable {
 
        private String code;
        private int buyCount;
        private int userId;
 
        public UserRequest(String code, int buyCount, int userId) {
            this.code = code;
            this.buyCount = buyCount;
            this.userId = userId;
        }
 
        @Override
        public void run() {
            try {
                //讓執行緒等待，等200個執行緒建立完一起執行
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //如果更新資料庫成功，也就代表購買成功了
            if (service.update(code, buyCount) > 0) {
                //對service加鎖，因為很多執行緒在訪問同一個service物件，不加鎖將導致購買成功的人數少於預期，且數量不對，可自行測試
                synchronized (service) {
                    //銷售量
                    goodSale += buyCount;
                    accountNum++;
                    //收錄購買成功的人
                    successUsers.add(userId);
                }
            }
        }
    }
 
    @Before
    public void add() {
        goodInfo = new GoodInfo();
        goodInfo.setCode(goodCode);
        goodInfo.setAmount(goodAmount);
        service.add(goodInfo);
    }
 
    @After
    public void delete() {
        service.delete(goodInfo);
    }
}

注意，由於是模擬併發，需要保證200個執行緒同時啟動去訪問資料庫，所以使用了CountDownLatch類，在呼叫UserRequest執行緒的start方法後，會先進入await狀態，等待200個執行緒建立完畢後，一起執行。

注意，由於是多執行緒操作service，必然導致資料不同步，所以需要對service加synchronize鎖，來保證service的update方法能夠正確執行。如果不加，可以自行測試，會導致少賣。
執行該測試類，看列印的結果。

可以多次執行，並修改每個人的購買數量、總商品數量、執行緒數，看看結果是否正確。

如修改為每人購買8個

mysql支援的併發訪問量有限，倘若併發量較小，可以採用上面的update的sql就能控制住，否則要使用nosql。

使用Redis完成秒殺系統

1. 修改程式碼

新建一個redis的service實現類

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

@Service("redis")
public class GoodInfoRedisService implements GoodInfoService {
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    @Override
    public void add(GoodInfo goodInfo) {
        redisTemplate.opsForValue().set(goodInfo.getCode(), goodInfo.getAmount() + "");
    }
 
    @Override
    public void delete(GoodInfo goodInfo) {
        redisTemplate.delete(goodInfo.getCode());
    }
 
    @Override
    public int update(String code, int count) {
        if (redisTemplate.opsForValue().increment(code, -count) < 0) {
            return -1;
        }
        return 1;
    }
}

我們使用RedisTemplate的increment來保證操作的原子性。

注意一下update方法，如果剩餘數量小於0，則返回失敗。

由於使用了RedisTemplate，需要先配置一下。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
 
@SpringBootApplication
public class CommonApplication {
 
	@Bean
	public RedisTemplate getRedisTemplate(JedisConnectionFactory jedisConnectionFactory) {
		RedisTemplate redisTemplate = new StringRedisTemplate();
		redisTemplate.setConnectionFactory(jedisConnectionFactory);
		return redisTemplate;
	}
 
	public static void main(String[] args) {
		SpringApplication.run(CommonApplication.class, args);
	}
}

2. 測試

將MyTest中的Service介面填充為redis

@Resource(name = "redis")
    private GoodInfoService service;

其他的不用變，直接執行即可。

可以看到redis同樣完成了搶購資格的分配。

相關推薦

[整理] 一個簡單版本的秒殺系統設計

目錄秒殺系統的難點秒殺系統的場景設計原則使用DB完成秒殺系統1. 初始化專案2. 模擬併發訪問搶購使用Redis完成秒殺系統1. 修改程式碼2. 測試

如何設計一個優秀的秒殺系統？

前言 如果問起秒殺系統如何設計，相信都能說出個123來，但是如果細究其中的細節點，很多人估計就無法很快的打上來了。本文從六個方面，來簡要講一下秒殺系統要如何設計，應該主要哪些事情。

你如何設計一個高效能的秒殺系統

秒殺系統場景特點 秒殺時大量使用者會在同一時間同時進行搶購，網站瞬時訪問流量激增。

《吊打面試官》系列-秒殺系統設計

你知道的越多，你不知道的越多 點贊再看，養成習慣 GitHub上已經開源 github.com/JavaFamily 有一線大廠面試點腦圖和個人聯絡方式，歡迎Star和指教

秒殺系統設計思路

業務特點： 1、瞬時併發量大，秒殺時會有大量使用者在同一時間進行搶購，瞬時併發訪問量突增幾倍、甚至幾十倍以上

秒殺系統設計

秒殺活動是指網路商家為促銷等目的組織會網上限時搶購活動，這種活動具有瞬時併發量大、庫存量少和業務邏輯簡單等特點。設計一個秒殺系統需要考慮的因素很多，比如對現有業務的影響、網路頻寬消耗以及超賣等因素。本

怎麼設計一個秒殺系統

什麼是秒殺 百度百科對秒殺這個詞的解釋有多個，第一種是： 在某些領域以壓倒性的優勢超越其他人，或者是在極短時間（比如一秒鐘）內解決對手，該種語言通常使用在網路遊戲中。

如何設計一個秒殺系統？

一、秒殺應該考慮哪些問題？ 1.1：超賣問題 假如備貨只有100個，但是最終超賣了200，這就叫超賣。一般來講秒殺系統的價格都比較低，如果超賣將嚴重影響公司的財產利益。

springboot整合redis實現簡單秒殺系統

本文例項為大家分享了springboot整合redis實現簡單秒殺系統的具體程式碼，供大家參考，具體內容如下

如何設計出騷氣的秒殺系統？

https://mp.weixin.qq.com/s/4vIghjvNzs1nsP2qTq0ZmA 前言 一：秒殺應該考慮哪些問題 二：秒殺系統的設計和技術方案

面試官：如何設計出騷氣的秒殺系統？

前言 秒殺系統相信很多人見過，比如京東或者淘寶的秒殺，小米手機的秒殺，那麼秒殺系統的後臺是如何實現的呢？我們如何設計一個秒殺系統呢？對於秒殺系統應該考慮哪些問題？如何設計出騷氣的秒殺系統？本期我們就來探

前端學習（2851）：簡單秒殺系統學習之相對定位

<html> <head > <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

前端學習（2850）：簡單秒殺系統學習之絕對定位

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

高併發下如何設計秒殺系統？

高併發下如何設計秒殺系統？ 設計一個秒殺系統，需要考慮這些問題： 如何解決這些問題呢？

秒殺系統要如何設計？

前言高併發下如何設計秒殺系統？這是一個高頻面試題。這個問題看似簡單，但是裡面的水很深，它考查的是高併發場景下，從前端到後端多方面的知識。

秒殺系統有那麼複雜嗎？

限制流量 靜態資源 靜態資源怎麼得要上個CDN吧，要不買伺服器也得花錢，還要配置，多麻煩

秒殺系統的藝術

12306搶票,極限併發帶來的思考? 每到節假日期間,一二線城市返鄉、外出遊玩的人們幾乎都面臨著一個問題：搶火車票!雖然現在大多數情況下都能訂到票,但是放票瞬間即無票的場景，相信大家都深有體會。尤其是春節期間，大

SpringBoot使用Redisson實現分散式鎖（秒殺系統）

前面講完了Redis的分散式鎖的實現，接下來講Redisson的分散式鎖的實現，一般提及到Redis的分散式鎖我們更多的使用的是Redisson的分散式鎖，Redis的官方也是建議我們這樣去做的。Redisson點我可以直接跳轉到Redisson的

如何通過SpringBoot實現商城秒殺系統

這篇文章主要介紹瞭如何通過SpringBoot實現商城秒殺系統,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java秒殺系統-2.7-Jedis redis.clients.jedis.exceptions.JedisConnectionException:問題解決

 1. application.properties #thymeleaf spring.thymeleaf.prefix=classpath:/templates/ spring.thymeleaf.suffix=.html