SSM框架學習之高並發秒殺業務--筆記5-- 並發優化

前幾節終於實現了這個高並發秒殺業務，現在問題是如何優化這個業務使其能扛住一定程度的並發量。

一. 優化分析

　　對於整個業務來說，首先是分析哪些地方會出現高並發，以及哪些地方會影響到了業務的性能。可能會出現高並發的地方：詳情頁，獲取系統時間，地址暴露接口，執行秒殺操作。

   　這個業務為什么要單獨獲取時間呢？用戶會在詳情頁大量刷新，為了優化這里，將detal.jsp詳情頁和一些靜態資源(css,js等）部署在CDN的節點上（至於這個CDN是什么，下面會說），也就是說用戶訪問詳情頁是不需要訪問我們的系統的，這樣就降低了服務器的負荷，但這個時候就拿不到系統的時間了，所以要單獨做一個請求來獲取當前的系統時間。

那么什么是CDN呢，content distribute network 內容分發網絡，本質上是一種加速用戶獲取數據的系統，把一些用戶頻繁訪問的靜態資源部署在離用戶最近的網絡節點上，關於CDN的具體解釋可以見這篇博文：http://blog.csdn.net/coolmeme/article/details/9468743。對於獲取系統時間這個操作，因為java訪問一次內存大約10ns，所以不需要優化。

對於秒殺地址接口，因為是經常變化的，所以不適合部署在CDN上，要部署在我們服務器的系統上，這里要用到服務器端緩存如：redis緩存服務器來進行優化。

redis緩存服務器：Redis是一個開源的使用ANSI C語言編寫、支持網絡、可基於內存亦可持久化的日志型、Key-Value數據庫，並提供多種語言的API。關於Redis，他是一個內存數據庫，即將硬盤上的部分數據緩存在內存中。對內度的讀取的速度要遠快於對硬盤的讀取，記得我們數據庫老師以前和我們說過，對於數據庫的設計而言，優化的最核心的部分是如何減少對磁盤的IO操作，因為磁盤的IO是其實就是硬盤的磁頭在讀磁片上的磁道，這是個機械運動，速度要遠慢於內存的讀寫。關於redis的一些知識，還要深入學習才行。

對於秒殺操作，這個是整個業務最核心的東西，不可能部署在CDN上，也不能使用redis緩存服務器，因為不可能在緩存中取減庫存，要在mysql中操作，否則會產生數據不一致的情況。老師也說了一些其他的優化方案，不過我聽不懂就是了，什么原子計數器，分布式MQ，消費消息並落地之類的。貌似和分布式系統有關？不明白啊，還得好好去學，先知道有這個東西先。

對於並發程序來說，拖慢速度的關鍵是事務控制，涉及到數據庫中的行級鎖，優化方向是：如何減少行級鎖的持有時間。那么優化思路是：將客戶端邏輯放到MySql服務端，同時避免網絡延遲和GC(垃圾回收)的影響。具體說就是把在客戶端中的事務控制放在MySql服務端。具體方式就是使用存儲過程，使整個事務在到MySql端完成。什么是存儲過程：在大型數據庫系統中，一組為了完成特定功能的SQL 語句集，存儲在數據庫中，經過第一次編譯后再次調用不需要再次編譯，用戶通過指定存儲過程的名字並給出參數（如果該存儲過程帶有參數）來執行它。具體見：存儲過程簡介。

二. 具體優化

1.redis后端緩存優化編碼

redis的下載和安裝，以及如何使用Redis的官方首選Java開發包Jedis：Windows下Redis的安裝使用。

在dao包下新建cache目錄，新建RedisDao類，用於訪問我們的redis。

RedisDao.java

package org.seckill.dao.cache;

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtobufIOUtil;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import org.seckill.entity.Seckill;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

/**
 * Created by yuxue on 2016/10/22.
 */
public class RedisDao {
    private final Logger logger= LoggerFactory.getLogger(this.getClass());
    private final JedisPool jedisPool;

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

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

    public Seckill getSeckill(long seckillId) {
        //redis操作邏輯
        try{
            Jedis jedis=jedisPool.getResource();
            try {
                String key="seckill:"+seckillId;
                //並沒有實現序列化機制
                //get->byte[]->反序列化->Object(Seckill)
                //采用自定義序列化
                //protostuff : pojo.
                byte[] bytes=jedis.get(key.getBytes());
                //緩存獲取到
                if(bytes!=null){
                    //空對象
                    Seckill seckill=schema.newMessage();
                    ProtostuffIOUtil.mergeFrom(bytes,seckill,schema);
                    //seckill被反序列化
                    return seckill;
                }
            }finally {
                jedis.close();
            }
        }catch (Exception e){
            logger.error(e.getMessage(),e);
        }
        return null;
    }

    public String putSeckill(Seckill seckill){
        // set Object(Seckill) -> 序列化 ->發送給redis
        try{
            Jedis jedis=jedisPool.getResource();
            try{
                String key="seckill:"+seckill.getSeckillId();
                byte[] bytes=ProtostuffIOUtil.toByteArray(seckill,schema,
                        LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
                //超時緩存
                int timeout=60*60;//1小時
                String result=jedis.setex(key.getBytes(),timeout,bytes);
                return result;
            }finally{
                jedis.close();
            }
        }catch (Exception e){
            logger.error(e.getMessage(),e);
        }
        return null;
    }

}

這里有個優化點是：redis並沒有實現對象的序列化，需要我們自己手動去序列化對象，當然這里可以讓對象實現Serializable接口，也就是用jdk提供的對象序列化機制。但是這里為了優化這個目的，我們需要一個速度更快得序列化機制，所以老師這里用的是基於谷歌Protobuff的ProtoStuff序列化機制。

ProtoStuff的依賴

<!--protostuff序列化依賴-->
      <dependency>
          <groupId>com.dyuproject.protostuff</groupId>
          <artifactId>protostuff-core</artifactId>
          <version>1.0.8</version>
      </dependency>
      <dependency>
          <groupId>com.dyuproject.protostuff</groupId>
          <artifactId>protostuff-runtime</artifactId>
          <version>1.0.8</version>
      </dependency>

 在spring-dao.xml配置RedisDao

<!--RedisDao-->
    <bean id="redisDao" class="org.seckill.dao.cache.RedisDao">
        <constructor-arg index="0" value="localhost"/>
        <constructor-arg index="1" value="6379"/>
    </bean>

 

修改SeckillServiceImpl.java為

package org.seckill.service.impl;

import org.apache.commons.collections.MapUtils;
import org.seckill.dao.SeckillDao;
import org.seckill.dao.SuccesskilledDao;
import org.seckill.dao.cache.RedisDao;
import org.seckill.dto.Exposer;
import org.seckill.dto.SeckillExecution;
import org.seckill.entity.Seckill;
import org.seckill.entity.SuccessKilled;
import org.seckill.enums.SeckillStatEnum;
import org.seckill.exception.RepeatKillException;
import org.seckill.exception.SeckillCloseException;
import org.seckill.exception.SeckillException;
import org.seckill.service.SeckillService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.DigestUtils;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by yuxue on 2016/10/15.
 */
@Service
public class SeckillServiceImpl implements SeckillService {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private SeckillDao seckillDao;

    @Autowired
    private SuccesskilledDao successkilledDao;

    @Autowired
    private RedisDao redisDao;

    //md5鹽值字符串，用於混淆MD5
    private final String salt = "fsladfjsdklf2jh34orth43hth43lth3";

    public List<Seckill> getSeckillList() {
        return seckillDao.queryAll(0, 4);
    }

    public Seckill getById(long seckillId) {
        return seckillDao.queryById(seckillId);
    }

    public Exposer exportSeckillUrl(long seckillId) {
        //優化點：緩存優化，超時的基礎上維護一致性
        //1.訪問redis
        Seckill seckill = redisDao.getSeckill(seckillId);
        if (seckill == null) {
            //2.若緩存中沒有則訪問數據庫
            seckill = seckillDao.queryById(seckillId);
            if (seckill == null) {
                return new Exposer(false, seckillId);
            } else {
                //3.放入redis
                redisDao.putSeckill(seckill);
            }
        }
        Date startTime = seckill.getStartTime();
        Date endTime = seckill.getEndTime();
        Date nowTime = new Date();
        if (nowTime.getTime() < startTime.getTime() ||
                nowTime.getTime() > endTime.getTime()) {
            return new Exposer(false, seckillId, nowTime.getTime(), startTime.getTime(), endTime.getTime());
        }
        //轉化特定字符串的過程，不可逆
        String md5 = getMD5(seckillId);
        return new Exposer(true, md5, seckillId);
    }

    private String getMD5(long seckillId) {
        String base = seckillId + "/" + salt;
        String md5 = DigestUtils.md5DigestAsHex(base.getBytes());
        return md5;
    }

    @Transactional
    /*
    * 使用注解控制事務方法的優點：
    * 1：開發團隊一致的約定
    * 2：保證事務方法的執行時間經可能的短，不要穿插其他網絡操作RPC/HTTP請求或者剝離到事務方法外部，使得
    *    這個事務方法是個比較干凈的對數據庫的操作
    * 3：不是所有的方法都需要事務，如只有一條修改操作，只讀操作不需要事務控制
    * */
    public SeckillExecution executeSeckill(long seckillId, long userPhone, String md5) throws SeckillException,
            RepeatKillException, SeckillCloseException {
        if (md5 == null || !md5.equals(getMD5(seckillId))) {
            throw new SeckillException("seckill data rewrite");
        }
        //執行秒殺邏輯：減庫存+記錄購買行為
        Date nowTime = new Date();

        try {
            //記錄購買行為
            int insertCount = successkilledDao.insertSucessSeckilled(seckillId, userPhone);
            //唯一：seckillId,userPhone
            if (insertCount <= 0) {
                //重復秒殺
                throw new RepeatKillException("seckill repeated");
            } else {
                //減庫存,熱點商品競爭
                int updateCount = seckillDao.reduceNumber(seckillId, nowTime);
                if (updateCount <= 0) {
                    //沒有更新到記錄，秒殺結束，rollback
                    throw new SeckillCloseException("seckill is close");
                } else {
                    //秒殺成功,commit
                    SuccessKilled successKilled = successkilledDao.queryByIdWithSeckill(seckillId, userPhone);
                    return new SeckillExecution(seckillId, SeckillStatEnum.SUCCESS, successKilled);
                }
            }
        } catch (SeckillCloseException e1) {
            throw e1;
        } catch (RepeatKillException e2) {
            throw e2;
        } catch (Exception e) {
            logger.error(e.getMessage());
            throw new SeckillException("seckill inner error" + e.getMessage());
        }
    }

    public SeckillExecution executeSeckillProdure(long seckillId, long userPhone, String md5){
        if (md5 == null || !md5.equals(getMD5(seckillId))) {
            return new SeckillExecution(seckillId, SeckillStatEnum.DATA_REWRITE);
        }
        Date killTime=new Date();
        Map<String,Object> map=new HashMap<String, Object>();
        map.put("seckillId",seckillId);
        map.put("phone",userPhone);
        map.put("killTime",killTime);
        map.put("result",null);
        try{
            seckillDao.killByProcedure(map);
            //獲取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){
            logger.error(e.getMessage(),e);
            return new SeckillExecution(seckillId,SeckillStatEnum.INNER_ERROR);
        }
    }
}

 

對於暴露秒殺接口exportSeckillUrl這個方法，原本是直接從數據庫中取Seckill對象的，現在優化為先在Redis緩存服務器中取，如果沒有則去數據庫中取，並將其放入Redis緩存中。這里還有個優化點就是在執行秒殺executeSeckill方法中

將insert操作放到了update之前。

2. 利用存儲過程

對於現在的update操作，還是在客戶端控制事務的，為了進一步優化，現在將update的操作邏輯放在Mysql端來執行，也就是利用存儲過程來完成商品更新操作，減少行級鎖的持有時間。

在src/main/sql目錄下新建seckill.sql, 編寫存儲過程

-- 秒殺執行存儲過程
DELIMITER $$ -- console ; 轉換為 $$
-- 定義存儲過程
-- 參數：in 輸入參數；out 輸出參數
-- row_count():返回上一條修改類型sql(delete, insert,update)的影響行數
-- row_count: 0:未修改；>0:表示修改的行數；<0:sql錯誤/未執行
CREATE PROCEDURE `seckill`.`execute_seckill`
  (in v_seckill_id bigint, in v_phone bigint,
    in v_kill_time timestamp,out r_result int)
  BEGIN
    DECLARE insert_count int DEFAULT 0;
    START TRANSACTION ;
    insert ignore into seccess_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
      ROLLBACK ;
      set r_result=-1;
    ELSEIF (insert_count<0) THEN
      ROLLBACK ;
      set r_result=-2;
    ELSE
      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
        ROLLBACK ;
        set r_result=0;
      ELSEIF (insert_count<0) THEN
        ROLLBACK ;
        set r_result=-2;
      ELSE
        COMMIT;
        set r_result=1;
      END IF;
    END IF;
  END;
$$
-- 存儲過程定義結束

DELIMITER ;
--
set @r_result=-3;
-- 執行存儲過程
call execute_seckill(1004,13225534035,now(),@r_result);
-- 獲取結果
select @r_result;

-- 存儲過程
-- 1：存儲過程優化：事務行級鎖持有時間
-- 2：不要過度依賴存儲過程
-- 3：簡單的邏輯可以應用存儲過程
-- 4：QPS:一個秒殺單6000/qps

 在Service層和dao層分別定義調用存儲過程的接口，然后在Mybatis中配置調用存儲過程

package org.seckill.service;

import org.seckill.dto.Exposer;
import org.seckill.dto.SeckillExecution;
import org.seckill.entity.Seckill;
import org.seckill.exception.RepeatKillException;
import org.seckill.exception.SeckillCloseException;
import org.seckill.exception.SeckillException;

import java.util.List;

/**
 * 業務接口:站在"使用者"角度設計接口
 * 三個方面：方法定一粒度，參數，返回類型/異常
 * Created by yuxue on 2016/10/15.
 */
public interface SeckillService {

    /**
     * 查詢所有秒殺記錄
     * @return
     */
    List<Seckill> getSeckillList( );

    /**
     * 查詢單個秒殺記錄
     * @param seckillId
     * @return
     */
    Seckill getById(long seckillId);

    /**
     * 秒殺開啟時輸出秒殺接口地址
     * 否則輸出系統時間和秒殺時間
     * @param seckillId
     */
    Exposer exportSeckillUrl(long seckillId);

    /**
     * 執行秒殺操作
     * @param seckillId
     * @param userPhone
     * @param md5
     */
    SeckillExecution executeSeckill(long seckillId, long userPhone, String md5)
        throws SeckillException,RepeatKillException,SeckillCloseException;

    /**
     * 執行秒殺操作by 存儲過程
     * @param seckillId
     * @param userPhone
     * @param md5
     */
    SeckillExecution executeSeckillProdure(long seckillId, long userPhone, String md5);
}

 

package org.seckill.dao;

import org.apache.ibatis.annotations.Param;
import org.seckill.entity.Seckill;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * Created by yuxue on 2016/10/12.
 */
public interface SeckillDao {

    /**
     * 減庫存
     * @param seckillId
     * @param killTime
     * @return 如果影響的行數大於1，表示更新記錄行數
     */
    int reduceNumber(@Param("seckillId") long seckillId,@Param("killTime") Date killTime);

    /**
     * 根據id查詢秒殺對象
     * @param seckillId
     * @return
     */
    Seckill queryById(long seckillId);

    /**
     * 根據偏移量查詢秒殺商品列表
     * @param offset
     * @param limit
     * @return
     */
    List<Seckill> queryAll(@Param("offset") int offset, @Param("limit") int limit);

    /**
     * 使用存儲過程執行秒殺
     * @param paramMap
     */
    void killByProcedure(Map<String,Object> paramMap);
}

 

下面的要點便是如何在Mybatis中配置killByProcedure這個接口，存儲過程的調用本質上是Mybatis在調用它，那么就得配置配置才行

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="org.seckill.dao.SeckillDao">


    <select id="queryById" resultType="Seckill" parameterType="long">
        select seckill_id,name,number,start_time, end_time, create_time
        from seckill
        where seckill_id=#{seckillId}
    </select>

    <update id="reduceNumber">
        update
          seckill
        set
          number=number -1
        where seckill_id = #{seckillId}
        and start_time <![CDATA[ <= ]]>   #{killTime}
        and end_time >= #{killTime}
        and number > 0;
    </update>

    <select id="queryAll" resultType="Seckill">
        select seckill_id,name,number,start_time,end_time,create_time
        from seckill
        order by create_time DESC
        limit #{offset},#{limit}
    </select>
    <!--mybatis調用存儲過程-->
    <select id="killByProcedure" statementType="CALLABLE">
        call execute_seckill（
        #｛seckillId,jdbcType=BIGINT,mode=IN｝,
        #｛phone,jdbcType=BIGINT,mode=IN｝,
        #｛killTime,jdbcType=TIMESTAMP,mode=IN｝,
        #｛result,jdbcType=INTEGER ,mode=OUT｝
        ）
    </select>

</mapper>

 

這里要記住配置這個存儲過程的一些參數。

<!--mybatis調用存儲過程-->
33     <select id="killByProcedure" statementType="CALLABLE">
34         call execute_seckill（
35         #｛seckillId,jdbcType=BIGINT,mode=IN｝,
36         #｛phone,jdbcType=BIGINT,mode=IN｝,
37         #｛killTime,jdbcType=TIMESTAMP,mode=IN｝,
38         #｛result,jdbcType=INTEGER ,mode=OUT｝
39         ）
40     </select>

 

SeckillServiceImpl里調用存儲過程來執行秒殺的方法executeSeckillProdure具體實現如下：

public SeckillExecution executeSeckillProdure(long seckillId, long userPhone, String md5){
        if (md5 == null || !md5.equals(getMD5(seckillId))) {
            return new SeckillExecution(seckillId, SeckillStatEnum.DATA_REWRITE);
        }
        Date killTime=new Date();
        Map<String,Object> map=new HashMap<String, Object>();
        map.put("seckillId",seckillId);
        map.put("phone",userPhone);
        map.put("killTime",killTime);
        map.put("result",null);
        try{
            seckillDao.killByProcedure(map);
            //獲取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){
            logger.error(e.getMessage(),e);
            return new SeckillExecution(seckillId,SeckillStatEnum.INNER_ERROR);
        }
    }

 

至此，優化篇就寫完了，寫得略微粗糙了點，好多細節都沒有具體分析，主要是快考試了，也沒什么時間寫博客了，忙死，估計這篇寫完后就好好復習准備期末考試了吧。至此，終於寫完了整個項目的過程，伴隨着自己的一些理解，以后還要修改修改。結尾老師總結了下這個課程涉及到的知識點又介紹了下一般網站的系統部署架構，什么Nginx，Jetty，rabbitmq之類的。。。不得不感嘆技術世界真是深似海，越學就會覺得自己不會的東西越多，不管怎樣，慢慢來吧，在技術的道路上前進着！！！