前言：最近小王同學又遇到了一個需求：線上的業務運行了一段時間，後來隨著使用人數增多，出現了一個問題是這樣的，一個訂單會重複建立幾次，導致資料庫裡出現了很多垃圾資料。在測試同學的不斷測試下，發現問題出在了前端的一個提交按鈕上，有的使用者比較“著急”，提交訂單時候，一下子快速的點了5、6次（這手速沒有幾年是練不出來的，咳咳），導致請求一下子都湧進來，後端進行了重複處理。專案經理讓小王優化這個點，絕對不能建立多次。還有一個需求是這樣的，在與第三方對接過程中，對方提供了token進行時效性驗證，過一段時間token就會失效.後臺有定時任務在獲取，但是偶爾會出現token失效，這是因為在獲取的時候，定時任務正在跑，可能正在獲取最新的token中，這個時候如何過一段時間(比如800毫秒之後)再請求呢？小王仰望天空45度，思考起來了。。。

本篇部落格的目錄

一：時間控制的幾種方案

1.1: 從執行緒方面解決

 最簡單粗暴的一種實現方案：Thread.sleep(800)，但是很快就被小王給pass掉了。為什麼呢？雖然這種方式可以，但是存在一個隱患，如果在多執行緒環境下，執行緒很容易被interrupt,這樣程式碼就會丟擲異常，這樣執行緒就會掛起，導致整個執行緒異常結束。實在是不夠優雅，違背了我們設計的初衷。

1.2:使用Timer

查閱了jdk，我發現有個實現定時的類，使用它是可以的，在jdk中提供了定時器類，這個類的主要作用就是控制一定的時間來簡單的定時執行某個任務。有點簡單的elasticJob的設計味道。接下來看一下，用timmer如何實現延時。。有點驚喜，我們來寫一個最簡單的例子來看一下如何實現定時任務：

public class TimmerTest {
   /**
     * 測試方法
     */
    public void test() {
        Timer timer = new Timer();
        timer.schedule(new MyTask(), 800);
    }
    
    public class MyTask extends TimerTask {
        
        /**
         * 執行方法
         */
        @Override
        public void run() {
            System.out.println(
 
"輸出");
        }
    }
}

 這是一個很簡單的定時器實現，可以看出它只需要將方法對應的類繼承自MyTask就可以實現定時執行，這種方法是可以實現延時的效果，但是它有一個致命的缺點：對程式碼的侵入性太大，為了實現定時我們不得已將對應的方法封裝成一個類，然後放在定時器裡執行。這樣的、是可以的，但未免也有點太得不償失了。為此我要更改整個類的結構，對於修改一個東西，我們要儘量按照最簡單的方式最好的效果來實現，所以這種方案也應該pass掉。

1.3:redis延時

在redis中存在一個命令：EXPIRE，這個命令可以設定鍵存活的時間。一旦超過指定的時間，redis就會將鍵對應的值給刪除掉，因此可以利用這一特性，我們來曲線實現延時功能。在redis的實際命令如下：

 通過EXPIRE命令可以設定鍵的過期時間，一旦超過預設的時間，值就會變成（nil）。利用這一點,加入一些業務引數，我們就可以有效的實現延時的目的。通過redis的過期時間使用redis的好處有以下幾點：

1:對程式碼的侵入性低，不用額外起另外的執行緒來執行。只需要加入一個方法就可以對單流程的時間控制

2:實現方便靈活，通過key設值可以加入一些唯一性的id來表示業務含義,從而保證業務的穩健實現

3:簡單,真正的程式碼實現起來只有很少，下面會給出程式碼示範。

二：redis

2.1：maven中引入redis

引入spring-boot-starter-data-redis，這是springboot專門針對redis出的整合依賴庫，整合度要比jedis、和redssion都要好，所以推薦這個依賴庫：

  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

2.2: 在springboot中配置redis

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    
    @Autowired
    private RedisTemplate redisTemplate;
    
    /**
     * redisTemplate例項化
     *
     * @return
     */
    @Bean
    public RedisTemplate redisTemplateInit() {
        //設定序列化Key的例項化物件
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //設定序列化Value的例項化物件
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
    
}

2.2：redisTemplate模板工具類

@Component
public class RedisManager {
    
    private static final Logger LOGGER = LoggerFactory.getLogger(RedisManager.class);
    
    @Autowired
    private RedisTemplate redisTemplate;
    
    /**
     * 設定物件
     *
     * @param key key
     * @param value value值
     * @param <T> 返回值泛型
     * @return 正確的值：<T> 錯誤的值：null
     */
    @SuppressWarnings("unchecked")
    public <T> ValueOperations<String, T> setObject(final String key, final T value) {
        final ValueOperations<String, T> operation = redisTemplate.opsForValue();
        operation.set(key, value);
        return operation;
    }
    
    /**
     * 設定物件及失效時間 (單位：秒)
     *
     * @param key key
     * @param value value值
     * @param <T> 返回值泛型
     * @param time 秒值
     * @return 正確的值：<T> 錯誤的值：null
     */
    @SuppressWarnings("unchecked")
    public <T> ValueOperations<String, T> setObject(final String key, final T value, final long time) {
        final ValueOperations<String, T> operation = redisTemplate.opsForValue();
        operation.set(key, value, time, TimeUnit.SECONDS);
        return operation;
    }


    /**
     * 設定物件及失效時間（單位：毫秒）
     *
     * @param key key
     * @param value value值
     * @param <T> 返回值泛型
     * @param time 秒值
     * @return 正確的值：<T> 錯誤的值：null
     */
    @SuppressWarnings("unchecked")
    public <T> ValueOperations<String, T> setObjectForMillSeconds(final String key, final T value, final long time) {
        final ValueOperations<String, T> operation = redisTemplate.opsForValue();
        operation.set(key, value, time, TimeUnit.MILLISECONDS);
        return operation;
    }
    
    /**
     * 獲取物件
     *
     * @param key 鍵
     * @return 正確的值：Object值物件<br>
     * 錯誤的值：null
     */
    @SuppressWarnings("unchecked")
    public Object getObject(final String key) {
        final ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        if (valueOperations == null || !redisTemplate.hasKey(key)) {
            return null;
        }
        final Object object = valueOperations.get(key);
        return object;
    }
    
    /**
     * 從快取中獲取string值
     *
     * @param key
     * @return*/
    @SuppressWarnings("unchecked")
    public String getString(final String key) {
        String value = "";
        final ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        if (valueOperations != null && redisTemplate.hasKey(key)) {
            final Object object = valueOperations.get(key);
            if (null != object) {
                LOGGER.info("--getString--object not empty");
                value = object.toString();
            } else {
                LOGGER.info("--getString--object empty");
            }
        }
        return value;
    }

2.2：在redis中實現時間控制

2.2.1:在流程中停留一段時間，通過無限迴圈來不斷的從redis取數值，一旦取到的值為null（redis的鍵值為null）就退出，這樣的寫法有點類似於以前CAS的些許味道，通過無限迴圈比較值。

import com.youjia.orders.redis.RedisManager;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Objects;

/**
 * @Auther: Yrion
 * @Date: 2019-01-11 23:36
 */

public class RedisTest extends OrderProviderApplicationTests {
    
    @Autowired
    private RedisManager redisManager;
    
    @Test
    public void test() {
        controlTime("10000001", 10L);
    }
    
    public void controlTime(String requestId, Long timeOut) {
        
        if (Objects.isNull(requestId) || Objects.isNull(timeOut)) {
            return;
        }
        //something code
        final String value = "value";
        redisManager.setObject(requestId, value, timeOut);
        final long startTime = System.currentTimeMillis();
        System.out.println("開始控制時間");
        //start
        for (; ; ) {
            if (Objects.isNull(redisManager.getObject(requestId))) {
                break;
            }
        }
        final long endTime = System.currentTimeMillis();
        
        final long useTime = endTime - startTime;
        
        System.out.println("一共耗費時間：" + useTime);
    }
}

outPut:

開始控制時間
一共耗費時間：10042

2.2.2:禁止提交一個訂單太過於頻繁

 /**
     * 防止提交過於頻繁
     */
    public  void preventFrequentSubmit(Long orderId) throws  Exception{
        
        //some code
        final String key = String.valueOf(orderId);
        
        final String value = "orderValue";
        
        if (redisManager.getObject(String.valueOf(orderId))!=null){
            throw  new Exception("提交訂單太過頻繁，請10秒後重試！");
        }else {
            redisManager.setObject(orderId,value,10);
        }
        
        //continue
        
    }

三：總結

 本篇博文講述了在平時工作中，我們可能會遇到的一些關於時間控制的問題，在這個問題上我又進行了進一步的探討，如何實現優雅的解決問題？我們解決問題不僅僅是要把這個問題解決了，而是要考慮如何更好更秒的解決，這就要善於利用一些中介軟體或者工具類提供的功能特性，善於發現、及時變通，把這種特性利用到我們的程式碼中，會對我們的開發起到推波助瀾、如虎添翼的作用！