Java seckill System IV: high concurrency optimization

This article is Optimization of Java high concurrency spike API Course notes.

Editor: IDEA

Java version: java8


I Second kill system environment construction and DAO layer design

II Second kill system Service layer

III Second kill system web layer

High concurrency optimization analysis

Where does concurrency occur? For a second kill of a commodity, naturally, there will be a high concurrency bottleneck under the specific commodity details page.

The red part is the occurrence point of high concurrency.

Why get the system time separately? Because not all resources are obtained from the server.

Therefore, you need to obtain the time separately to specify the current time of the server.

CDN: content distribution network, a system to accelerate users' access to data. Deployed on the network node closest to the user. There is no need to access the back-end server to hit the CDN.

Obtaining system time does not need to be optimized. The memory accessed once is about 10ns, and there is no back-end access.

Get seckill address: CDN cache cannot be used, which is suitable for server cache: redis, etc. Low cost of consistency maintenance.

Execute second kill operation: CDN cannot be used, back-end caching is difficult: inventory problem, one line data competition: hot goods.

Second kill scheme:

Cost analysis: operation and maintenance cost and stability: nosql,mq, etc. Development cost: data consistency, rollback scheme. Idempotency is difficult to guarantee: repeated second kill problem. Not suitable for novice architecture.

Why not use MySQL?

An update, MySQL can QPS very high.

java control transaction behavior analysis:

Bottleneck analysis:

Optimization analysis: row level locks are released after commit, so the optimization direction is to reduce the holding time of row level locks.

Delay analysis: local machine room, possibly 1ms, remote machine room:

The round-trip may take 20ms, and the maximum concurrency is 50QPS.

Optimization ideas:

Put the client logic on the MySQL server to avoid the impact of network delay and GC.

Two options:

  • Customize the SQL scheme: update /*+[auto_commit] * /. If successful, it will succeed. If unsuccessful, it will roll back. You need to modify the MySQL source code.
  • Using stored procedures: the whole transaction is completed on the MySQL side.

Optimization summary:

  • Front end control: exposed interface, button anti repetition
  • Dynamic and static data separation: CDN cache (static resources), backend cache (such as redis)
  • Transaction contention Optimization: reduce transaction lock time

redis backend optimized cache coding

Optimizing the address exposure interface using redis

Download and install redis.

D:\Program Files (x86)\\Redis>redis-cli.exe -h -p 6379> set myKey abc
OK> get myKey

Used in conjunction with java, pom.xml adds dependencies:

<!--redis Dependency introduction-->

<!--Serialization operation-->


In the file, the code that originally exposed the url is:

 * When the second kill is on, the second kill interface address is output
 * Otherwise, the system time and second kill time are output
 * @param seckillId
public Exposer exportSecKillUrl(long seckillId) {
    // Check database
    SecKill secKill = secKillDao.queryById(seckillId);
    if(secKill == null) {
        // id not found, false
        return new Exposer(false,seckillId);
    Date startTime = secKill.getStartTime();
    Date endTime = secKill.getEndTime();
    Date nowTime = new Date();
            || nowTime.getTime()>endTime.getTime()) {
        return new Exposer(false,seckillId, nowTime.getTime(),
    // Irreversible
    String md5 = getMD5(seckillId);
    return new Exposer(true,md5,seckillId);

Create under the DAO folder because it also deals with data.

public class RedisDao {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    private JedisPool jedisPool;
    public RedisDao(String ip,int port) {
        jedisPool = new JedisPool(ip,port);

    private RuntimeSchema<SecKill> schema = RuntimeSchema.createFrom(SecKill.class);

    public SecKill getSeckill(long seckillId) {
        // redis operation logic
        try {
            Jedis jedis = jedisPool.getResource();
            try {
                String key = "seckill:"+seckillId;
                // redis does not implement internal serialization
                // get gets a binary array byte [], through deserialization - > object (seckill)
                // Adopt custom serialization protostuff
                // protostuff:pojo has get set methods
                byte[] bytes = jedis.get(key.getBytes(StandardCharsets.UTF_8));
                // It is obtained. protostuff conversion is required
                // Byte array and schema are required
                if (bytes != null) {
                    // Create an empty object to put the object generated by deserialization
                    SecKill secKill = schema.newMessage();
                    // seckill is deserialized
                    return secKill;
            } finally {

        } catch (Exception e) {
        return null;

    public String putSeckill(SecKill secKill) {
        // Set: object (seckill) - > bytes [] serialization operation
        try {
            Jedis jedis = jedisPool.getResource();
            try {
                String key = "seckill:"+secKill.getSeckillId();
                byte[] bytes = ProtostuffIOUtil.toByteArray(secKill,schema,
                // Timeout cache
                int timeout = 60*60; // 1 hour
                String result = jedis.setex(key.getBytes(StandardCharsets.UTF_8),timeout,bytes);
                return result; //Adding cache information, success or failure
            } finally {
        } catch (Exception e) {
        return null;

There are two methods, put and get. Serialization is also involved. protostuff is used.

Before unit testing, RedisDao needs to be injected into spring-dao.xml:

<!--You need to configure it yourself redis dao-->
<bean id="redusDao" class="cn.orzlinux.dao.cache.RedisDao">
    <constructor-arg index="0" value="localhost" />
    <constructor-arg index="1" value="6379" />

Conduct unit tests:

//Tell JUnit the spring configuration file
public class RedisDaoTest {
    private long id = 1001;
    private RedisDao redisDao;

    private SecKillDao secKillDao;

    public void testSeckill() {
        // get and put
        // Get from cache
        SecKill secKill = redisDao.getSeckill(id);
        // No, just look it up in the database
        // Put it back to redis after finding it
        if(secKill==null) {
            secKill = secKillDao.queryById(id);
            if(secKill != null) {
                String result = redisDao.putSeckill(secKill);
                secKill = redisDao.getSeckill(id);

It can be verified by querying redis on the command line. It can be seen that:> get seckill:1001
"\b\xe9\a\x12\x11500\xe7\xa7\x92\xe6\x9d\x80iphone12\x18\xbc\x84=!\x00evL|\x01\x00\x00)\x00\xe4\xcd\xb3\xc5\x01\x00\x001\xf8z/N|\x01\x00\x00"> get seckill:1002

The reason why redis cache can be used here is that there may be thousands of people who kill a commodity. The URL s of these people accessing the commodity are the same. They don't need to search the database frequently. They can be directly stored in the cache.

Second kill operation concurrency optimization

Transaction execution:

Simple optimization

The collision probability of insert operation is low. The server determines whether to execute update according to the insert result, eliminates repeated second kill, and no longer locks update. Then update row level locks, which can reduce the holding time of row level locks.

Source code change database operation time:

public SeckillExecution executeSeckill(long seckillId, long userPhone, String md5) throws
        SeckillException, RepeatKillException, SeckillException {
    if(md5==null || !md5.equals(getMD5(seckillId))) {
        // The second kill data has been rewritten and modified
        throw new SeckillException("seckill data rewrite");
    // Execute the second Kill Logic: reduce inventory and record purchase behavior
    Date nowTime = new Date();

    try {
        // Record purchase behavior
        int insertCount = successKilledDao.insertSuccessKilled(seckillId,userPhone);
        if(insertCount<=0) {
            // Repeat second kill
            throw new RepeatKillException("seckill repeated");
        } else {
            // Reduce inventory. Hot commodity competition
            int updateCount = secKillDao.reduceNumber(seckillId,nowTime);
            if(updateCount<=0) {
                // No record updated, the second kill is over
                throw new SeckillCloseException("seckill is closed");
            } else {
                //Second kill success
                SuccessKilled successKilled = successKilledDao.queryByIdWithSeckill(seckillId,userPhone);
                return new SeckillExecution(seckillId, SecKillStatEnum.SUCCESS,successKilled);

    } catch (SeckillCloseException | RepeatKillException e1){
        throw e1;
    } catch (Exception e) {
        // All compile time exceptions are converted to run-time exceptions so that spring can roll back
        throw new SeckillException("seckill inner error"+e.getMessage());

Depth optimization

SQL transactions are executed on the MySQL side (stored procedures).

stored procedure

Stored Procedure is a set of SQL statements to complete specific functions in a large database system. It is stored in the database and is permanently valid after one compilation. Users execute it by specifying the name of the Stored Procedure and giving parameters (if the Stored Procedure has parameters). Stored Procedure is an important object in database.

The advantages are obvious. Let's talk about the disadvantages: difficult debugging and poor portability. If the business data model changes, the stored procedures of large projects will change greatly.

The stored procedure optimizes the holding time of transaction row level locks. Don't rely too much on stored procedures. Simple logic can rely on stored procedures.

Define a stored procedure:

-- Second kill execution stored procedure
DELIMITER $$ -- console ;Convert to\$\$ express sql The operation is ready
-- Define stored procedures
-- Parameters: in input parameter ; out Output parameters
-- row_count(): Returns the last modification type sql Number of affected rows
-- row_count: 0 Data not modified,>0 Number of rows modified,<0 sql Error or not executed

# SUCCESS(1, "second kill succeeded"),
# END(0, "end of second kill"),
# REPEAT_KILL(-1, "repeat second kill"),
# INNER_ERROR(-2, "system exception"),
# DATA_REWRITE(-3, "data tampering")
CREATE PROCEDURE `seckill`.`execute_seckill`
    (in v_seckill_id bigint, in v_phone bigint,
        in v_kill_time timestamp,out r_result int)
        DECLARE insert_count int DEFAULT 0;
        insert ignore into success_killed
            (seckill_id, user_phone,create_time)
            values (v_seckill_id,v_phone,v_kill_time);
        select row_count() into insert_count;
        IF (insert_count=0) THEN
            set r_result = -1;
        ELSEIF (insert_count<0) THEN
            set r_result = -2;
            update seckill
                set number = number-1
                where seckill_id = v_seckill_id
                    and end_time > v_kill_time
                    and start_time < v_kill_time
                    and number>0;
            select row_count() into insert_count;
            IF (insert_count = 0) THEN
                set r_result = 0;
            ELSEIF(insert_count<0) then
                set r_result = -2;
                set r_result = 1;
            end if;
        end if;
$$ -- End of stored procedure definition
delimiter ;

-- console Define variables
set @r_result=-3;
-- Execute stored procedure
call execute_seckill(1001,19385937587,now(),@r_result);
-- Get results
select @r_result;

In this way, the insert and update operations are completed on the server side.

To use this stored procedure, you need to add a new method in

// Using stored procedures to perform a second kill
void killByProcedure(Map<String,Object> paramMap);

Then implement sql statements through xml:

<!--mybatis Call stored procedure-->
<select id="killByProcedure" statementType="CALLABLE">
    call execute_seckill(

A new method is added to the SecKillService interface and implemented in

 * Stored procedure execution second kill
 * @param seckillId
 * @param userPhone
 * @param md5
 * @return
 * @throws SeckillException
 * @throws RepeatKillException
 * @throws SeckillCloseException
public SeckillExecution executeSeckillProcedure(long seckillId, long userPhone, String md5) {
    if(md5==null || !md5.equals(getMD5(seckillId))) {
        // The second kill data has been rewritten and modified
        throw new SeckillException("seckill data rewrite");
    Date nowTime = new Date();
    Map<String,Object> map = new HashMap<>();
    // When executing a stored procedure, only result is assigned
    try {
        // Get result
        int result = MapUtils.getInteger(map,"result",-2);
        if(result == 1) {
            SuccessKilled sk = successKilledDao.queryByIdWithSeckill(seckillId,userPhone);
            return new SeckillExecution(seckillId,SecKillStatEnum.SUCCESS,sk);
        } else {
            return new SeckillExecution(seckillId,SecKillStatEnum.stateOf(result));
    } catch (Exception e) {
        return new SeckillExecution(seckillId,SecKillStatEnum.INNER_ERROR);

Finally, the controller layer replaces the original execution second kill method with this one.

This article was published on

Keywords: Java MySQL Redis

Added by mishasoni on Thu, 07 Oct 2021 23:16:51 +0300