Designing a High‑Concurrency Flash‑Sale System: Architecture, Strategies, and Implementation Details

Today we will discuss the architecture of a flash‑sale system from seven different dimensions, focusing on the following key points:

Nginx + front‑back separation + CDN cache + gateway (rate limiting + circuit breaking)

Cluster routing layer + Redis (cache hot data, distributed lock)

MQ cluster

Business processing layer

Database layer (read‑write separation, hot‑spot isolation)

1. Characteristics of Flash‑Sale Business

Massive simultaneous page refreshes

Massive simultaneous purchase attempts

Potential malicious competition using automated tools

2. Overall Design

2.1 Peak‑Limiting and Rate‑Limiting

Front‑end + Redis intercepts requests; only requests that successfully decrement Redis counters proceed downstream.

MQ buffers orders, protecting the order‑processing layer; consumers fetch tasks according to their capacity.

Introduce answer‑type captchas and random request sleep to smooth traffic spikes.

2.2 Nginx Design Details

Key Nginx configurations include static‑dynamic separation, gzip compression, and upstream server health checks.

server {
    listen 8088;
    location ~ \.(gif|jpg|jpeg|png|bmp|swf)$ {
        root C:/Users/502764158/Desktop/test;
    }
    location ~ \.(jsp|do)$ {
        proxy_pass http://localhost:8082;
    }
}

gzip on;
 gzip_min_length 1k;
 gzip_buffers 4 16k;
 gzip_comp_level 3;
 gzip_disable "MSIE [1-6]\\.";
 gzip_types text/plain application/x-javascript text/css application/xml text/javascript image/jpeg image/gif image/png;

Additional upstream configuration for load balancing and failover:

upstream netitcast.com {
    server 127.0.0.1:8080;
    server 127.0.0.1:38083;
    server 127.0.0.1:8083;
}
server {
    listen 88;
    server_name localhost;
    location / {
        proxy_pass http://netitcast.com;
        proxy_connect_timeout 1;
        fail_timeout 5;
    }
}

2.3 Page Optimization (Static‑Dynamic Separation)

Keep flash‑sale pages lightweight: small images, minimal JS/CSS, and separate static resources.

Use asynchronous refresh for purchase actions to avoid full page reloads.

Leverage Nginx static file serving, gzip compression, or Varnish caching to reduce server load.

2.4 Redis Cluster Usage

Distributed (pessimistic) lock to ensure only one request succeeds.

Cache hot data (e.g., inventory) and set expiration to avoid stale locks.

Implement fast feedback loops: if lock acquisition fails, retry quickly after a short pause.

2.5 Message‑Queue Rate Limiting

Use MQ (e.g., RocketMQ) consumer thread pools and built‑in throttling to smooth spikes; separate queues for flash‑sale and normal business to prevent queue saturation.

2.6 Database Design

Split transactions to improve concurrency (e.g., separate inventory decrement from order creation).

Consider sharding/read‑write separation for hot data, while being aware of distributed‑transaction complexities.

Sample SQL for inventory decrement: UPDATE inventory SET stock = stock - 1 WHERE id = ? AND stock > 0;

2.7 Captcha Design for Anti‑Bot Protection

Introduce answer‑type captchas to block automated tools and give genuine users a chance.

Delay requests based on human reaction time; responses faster than a threshold are flagged as bots.

Two approaches: refresh captcha on failure (higher server load) or validate locally with MD5‑hashed answers tied to user‑specific data.

3. Precautions

To achieve high concurrency, trade‑offs in transaction handling are necessary:

Split large transactions (e.g., inventory update + order creation) into smaller ones to reduce lock contention.

When sharding, be prepared for distributed‑transaction challenges; use log‑based reconciliation if needed.

Avoid single points of failure across all layers and consider graceful degradation (temporarily disabling non‑essential features during peak load).

Overall, the design emphasizes front‑end rate limiting, back‑end isolation, asynchronous processing, and robust safety mechanisms to ensure the flash‑sale system can handle massive traffic while maintaining reliability.