Java實現(xiàn)高并發(fā)秒殺的七種方式

更新時間：2024年03月13日 10:17:51 作者：擁抱AI

本文主要介紹了Java實現(xiàn)高并發(fā)秒殺的六種方式,包括使用緩存、數(shù)據(jù)庫樂觀鎖、數(shù)據(jù)庫悲觀鎖、分布式鎖、隊列限流、令牌桶算法和限流器,具有一定的參考價值,感興趣的可以了解一下

1. 引言

在現(xiàn)代的互聯(lián)網(wǎng)應用中，秒殺活動是一種常見的需求，允許用戶在短時間內搶購有限的商品。然而，這種類型的活動可能會導致高并發(fā)的請求，對系統(tǒng)造成巨大的壓力。為了應對這種高并發(fā)的場景，我們需要實現(xiàn)一種能夠處理大量并發(fā)請求的秒殺系統(tǒng)。
秒殺系統(tǒng)通常需要處理以下挑戰(zhàn)：

高并發(fā)：在短時間內，大量的用戶可能會同時訪問秒殺活動頁面，導致系統(tǒng)壓力巨大。
數(shù)據(jù)一致性：在秒殺過程中，需要保證數(shù)據(jù)的準確性和一致性。
系統(tǒng)穩(wěn)定性：在秒殺過程中，系統(tǒng)需要能夠承受高并發(fā)的請求，保證系統(tǒng)的穩(wěn)定運行。
為了應對這些挑戰(zhàn)，我們可以使用多種技術來實現(xiàn)高并發(fā)的秒殺系統(tǒng)。以下是一些常見的實現(xiàn)方式：

2. 使用緩存

使用緩存是一種常見的秒殺系統(tǒng)實現(xiàn)方式。通過使用緩存，我們可以減少數(shù)據(jù)庫的訪問次數(shù)，提高系統(tǒng)的響應速度。在秒殺活動中，我們可以將商品的數(shù)量緩存到 Redis 中，并在用戶請求時直接從緩存中獲取商品數(shù)量。

import redis.clients.jedis.Jedis;
public class CacheBasedSecKill {
    private Jedis jedis;
    public CacheBasedSecKill(Jedis jedis) {
        this.jedis = jedis;
    }
    public boolean isProductAvailable(String productId) {
        String productKey = "product:" + productId;
        return jedis.exists(productKey) && jedis.decr(productKey) > 0;
    }
}

在這個示例中，我們創(chuàng)建了一個名為 CacheBasedSecKill 的類，它接受一個 Jedis 實例作為參數(shù)。我們定義了一個名為 isProductAvailable 的方法，它接受一個名為 productId 的字符串參數(shù)。我們使用 Redis 的 exists 命令檢查緩存中是否存在該商品的鍵，并使用 decr 命令減少商品的數(shù)量。如果商品的數(shù)量大于 0，我們返回 true，表示商品可用；否則返回 false。

3. 使用數(shù)據(jù)庫樂觀鎖

數(shù)據(jù)庫樂觀鎖是一種基于數(shù)據(jù)版本號或時間戳的鎖機制，用于處理并發(fā)更新操作。在秒殺活動中，我們可以使用樂觀鎖來處理商品數(shù)量的更新。

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class OptimisticLockBasedSecKill {
    private Connection connection;
    public OptimisticLockBasedSecKill(Connection connection) {
        this.connection = connection;
    }
    public boolean isProductAvailable(String productId) throws SQLException {
        String sql = "SELECT product_id, quantity, version FROM product WHERE product_id = ? FOR UPDATE";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, productId);
            ResultSet resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                int quantity = resultSet.getInt("quantity");
                int version = resultSet.getInt("version");
                if (quantity > 0) {
                    sql = "UPDATE product SET quantity = quantity - 1, version = version + 1 WHERE product_id = ? AND version = ?";
                    try (PreparedStatement updateStatement = connection.prepareStatement(sql)) {
                        updateStatement.setString(1, productId);
                        updateStatement.setInt(2, version);
                        int affectedRows = updateStatement.executeUpdate();
                        return affectedRows > 0;
                    }
                }
            }
        }
        return false;
    }
}

在這個示例中，我們創(chuàng)建了一個名為 OptimisticLockBasedSecKill 的類，它接受一個 Connection 實例作為參數(shù)。我們定義了一個名為 isProductAvailable 的方法，它接受一個名為 productId 的字符串參數(shù)。我們首先執(zhí)行一個 SELECT 查詢，獲取商品的 ID、數(shù)量和版本號。然后，我們檢查商品的數(shù)量是否大于 0。如果商品的數(shù)量大于 0，我們執(zhí)行一個 UPDATE 查詢，減少商品的數(shù)量并增加版本號。如果 UPDATE 查詢影響的行數(shù)大于 0，我們返回 true，表示商品可用；否則返回 false。

4. 使用數(shù)據(jù)庫悲觀鎖

數(shù)據(jù)庫悲觀鎖是一種基于排他鎖的機制，用于處理并發(fā)更新操作。在秒殺活動中，我們可以使用悲觀鎖來處理商品數(shù)量的更新。

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class PessimisticLockBasedSecKill {
    private Connection connection;
    public PessimisticLockBasedSecKill(Connection connection) {
        this.connection = connection;
    }
    public boolean isProductAvailable(String productId) throws SQLException {
        String sql = "SELECT quantity FROM product WHERE product_id = ? FOR UPDATE";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, productId);
            ResultSet resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                int quantity = resultSet.getInt("quantity");
                if (quantity > 0) {
                    sql = "UPDATE product SET quantity = quantity - 1 WHERE product_id = ?";
                    try (PreparedStatement updateStatement = connection.prepareStatement(sql)) {
                        updateStatement.setString(1, productId);
                        int affectedRows = updateStatement.executeUpdate();
                        return affectedRows > 0;
                    }
                }
            }
        }
        return false;
    }
}

在這個示例中，我們創(chuàng)建了一個名為 PessimisticLockBasedSecKill 的類，它接受一個 Connection 實例作為參數(shù)。我們定義了一個名為 isProductAvailable 的方法，它接受一個名為 productId 的字符串參數(shù)。我們首先執(zhí)行一個 SELECT 查詢，并使用 FOR UPDATE 子句獲取商品的排他鎖。然后，我們檢查商品的數(shù)量是否大于 0。如果商品的數(shù)量大于 0，我們執(zhí)行一個 UPDATE 查詢，減少商品的數(shù)量。如果 UPDATE 查詢影響的行數(shù)大于 0，我們返回 true，表示商品可用；否則返回 false。

5. 使用分布式鎖

分布式鎖是一種用于在分布式系統(tǒng)中控制對共享資源訪問的鎖機制。在秒殺活動中，我們可以使用分布式鎖來保證對商品數(shù)量的一致性訪問。

import redis.clients.jedis.Jedis;
public class DistributedLockBasedSecKill {
    private Jedis jedis;
    public DistributedLockBasedSecKill(Jedis jedis) {
        this.jedis = jedis;
    }
    public boolean isProductAvailable(String productId) {
        String lockKey = "lock:" + productId;
        String requestId = "request:" + Thread.currentThread().getId();
        while (true) {
            if (jedis.setnx(lockKey, requestId) == 1) {
                String quantity = jedis.get("product:" + productId);
                if (quantity != null && Integer.parseInt(quantity) > 0) {
                    jedis.decr("product:" + productId);
                    jedis.del(lockKey);
                    return true;
                }
                jedis.del(lockKey);
                return false;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在這個示例中，我們創(chuàng)建了一個名為 DistributedLockBasedSecKill 的類，它接受一個 Jedis 實例作為參數(shù)。我們定義了一個名為 isProductAvailable 的方法，它接受一個名為 productId 的字符串參數(shù)。我們首先嘗試使用 SETNX 命令獲取分布式鎖，如果成功獲取鎖，我們檢查商品的數(shù)量是否大于 0。如果商品的數(shù)量大于 0，我們減少商品的數(shù)量，并刪除鎖。如果獲取鎖失敗，我們等待一段時間后重試。

6. 使用隊列限流

隊列限流是一種基于隊列的限流機制，用于控制并發(fā)請求的數(shù)量。在秒殺活動中，我們可以使用隊列限流來限制同時處理的請求數(shù)量。

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class QueueBasedRateLimiter {
    private ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
    private int maxQueueSize;
    private ExecutorService executorService;
    public QueueBasedRateLimiter(int maxQueueSize) {
        this.maxQueueSize = maxQueueSize;
        this.executorService = Executors.newFixedThreadPool(maxQueueSize);
    }
    public boolean isProductAvailable(String productId) {
        if (queue.size() < maxQueueSize) {
            queue.add(productId);
            executorService.execute(() -> {
                try {
                    // 執(zhí)行秒殺邏輯
                } finally {
                    queue.poll();
                }
            });
            return true;
        }
        return false;
    }
}

在這個示例中，我們創(chuàng)建了一個名為 QueueBasedRateLimiter 的類，它接受一個名為 maxQueueSize 的整數(shù)參數(shù)。我們定義了一個名為 isProductAvailable 的方法，它接受一個名為 productId 的字符串參數(shù)。我們首先檢查隊列的大小是否小于最大隊列大小。如果小于，我們將商品 ID 添加到隊列中，并使用線程池執(zhí)行秒殺邏輯。如果等于或大于，我們返回 false。

7. 使用令牌桶算法和限流器

令牌桶算法是一種常見的限流算法，用于控制數(shù)據(jù)包的發(fā)送速率。在秒殺活動中，我們可以使用令牌桶算法來限制并發(fā)請求的數(shù)量。

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TokenBucketRateLimiter {
    private ConcurrentLinkedQueue<String> bucket = new ConcurrentLinkedQueue<>();
    private int maxTokens;
    private int refillRate;
    private ExecutorService executorService;
    public TokenBucketRateLimiter(int maxTokens, int refillRate) {
        this.maxTokens = maxTokens;
        this.refillRate = refillRate;
        this.executorService = Executors.newFixedThreadPool(maxTokens);
    }
    public boolean isProductAvailable(String productId) {
        synchronized (bucket) {
            while (bucket.size() >= maxTokens) {
                try {
                    bucket.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            bucket.add(productId);
            executorService.execute(() -> {
                try {
                    // 執(zhí)行秒殺邏輯
                } finally {
                    synchronized (bucket) {
                        bucket.remove(productId);
                        bucket.notifyAll();
                    }
                }
            });
            return true;
        }
    }
}

在這個示例中，我們創(chuàng)建了一個名為 TokenBucketRateLimiter 的類，它接受兩個名為 maxTokens 和 refillRate 的整數(shù)參數(shù)。我們定義了一個名為 isProductAvailable 的方法，它接受一個名為 productId 的字符串參數(shù)。
我們首先檢查令牌桶的大小是否達到最大令牌數(shù)。如果達到，我們等待直到有新的令牌被添加。一旦有新的令牌被添加，我們將商品 ID 添加到令牌桶中，并使用線程池執(zhí)行秒殺邏輯。如果令牌桶未滿，我們直接將商品 ID 添加到令牌桶中，并執(zhí)行秒殺邏輯。

8. 總結

本文詳細介紹了如何實現(xiàn)高并發(fā)秒殺功能，我們深入探討了七種常見的秒殺系統(tǒng)實現(xiàn)方式，包括使用緩存、數(shù)據(jù)庫樂觀鎖、數(shù)據(jù)庫悲觀鎖、分布式鎖、隊列限流、令牌桶算法和限流器。每種方式都有其優(yōu)缺點，適用于不同的場景。通過使用這些技術，我們可以有效地處理高并發(fā)的秒殺活動，保證系統(tǒng)的穩(wěn)定性和性能。

到此這篇關于Java實現(xiàn)高并發(fā)秒殺的七種方式的文章就介紹到這了,更多相關Java 高并發(fā)秒殺內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！