你好，感谢邀请，回答如下：

1.问题引入

电商的秒杀和抢购，对我们来说，都不是一个陌生的东西。然而，从技术的角度来说，这对于Web系统是一个巨大的考验。当一个Web系统，在一秒钟内收到数以万计甚至更多请求时，系统的优化和稳定至关重要。

2.大规模并发带来的挑战

高并发秒杀功能,整个Web系统遇到了很多的问题和挑战。如果Web系统不做针对性的优化，会轻而易举地陷入到异常状态。现在我们来讨论下，优化的思路和方法。

第一： 请求接口的合理设计

第二：高并发的挑战：一定要“快”

第三：重启与过载保护

第四：时间控制方案

1.从线程方面解决

最简单粗暴的一种实现方案：Thread.sleep(800)，但事实上这种方案一定会被很快pass，因为这种方式存在一个隐患，如果在多线程环境下，线程很容易被interrupt,这样代码就会抛出异常，这样线程就会挂起，导致整个线程异常结束。实在是不够优雅，违背了我们设计的初衷。

2.使用Timer

在jdk中提供了定时器类，类的主要作用就是控制一定的时间来简单的定时执行某个任务。有点简单的elasticJob的设计味道。下面一个最简单的例子来看一下如何实现定时任务：

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掉！

但是这里延伸一下，java可结合queartz实现的定时任务。

Quartz是一个任务调度框架。

一个例子：

package com.test.quartz; import static org.quartz.DateBuilder.newDate; import static org.quartz.JobBuilder.newJob; import static org.quartz.SimpleScheduleBuilder.simpleSchedule; import static org.quartz.TriggerBuilder.newTrigger; import java.util.GregorianCalendar; import org.quartz.JobDetail; import org.quartz.Scheduler; import org.quartz.Trigger; import org.quartz.impl.StdSchedulerFactory; import org.quartz.impl.calendar.AnnualCalendar; public class QuartzTest { public static void main(String[] args) { try { //创建scheduler Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler(); //定义一个Trigger Trigger trigger = newTrigger().withIdentity("trigger1", "group1") //定义name/group .startNow()//一旦加入scheduler，立即生效 .withSchedule(simpleSchedule() //使用SimpleTrigger .withIntervalInSeconds(1) //每隔一秒执行一次 .repeatForever()) //一直执行，奔腾到老不停歇 .build(); //定义一个JobDetail JobDetail job = newJob(HelloQuartz.class) //定义Job类为HelloQuartz类，这是真正的执行逻辑所在 .withIdentity("job1", "group1") //定义name/group .usingJobData("name", "quartz") //定义属性 .build(); //加入这个调度 scheduler.scheduleJob(job, trigger); //启动之 scheduler.start(); //运行一段时间后关闭 Thread.sleep(10000); scheduler.shutdown(true); } catch (Exception e) { e.printStackTrace(); } } }

package com.test.quartz; import java.util.Date; import org.quartz.DisallowConcurrentExecution; import org.quartz.Job; import org.quartz.JobDetail; import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; public class HelloQuartz implements Job { public void execute(JobExecutionContext context) throws JobExecutionException { JobDetail detail = context.getJobDetail(); String name = detail.getJobDataMap().getString("name"); System.out.println("say hello to " + name + " at " + new Date()); } }

这个例子覆盖了Quartz最重要的3个基本要素：

Scheduler：调度器。所有的调度都是由它控制。

Trigger： 定义触发的条件。例子中，它的类型是SimpleTrigger，每隔1秒中执行一次(什么是SimpleTrigger下面会有详述)。

JobDetail & Job： JobDetail 定义的是任务数据，而真正的执行逻辑是在Job中，例子中是HelloQuartz。 为什么设计成JobDetail + Job，不直接使用Job？这是因为任务是有可能并发执行，如果Scheduler直接使用Job，就会存在对同一个Job实例并发访问的问题。而JobDetail & Job 方式，sheduler每次执行，都会根据JobDetail创建一个新的Job实例，这样就可以规避并发访问的问题。

3.redis延时

通过EXPIRE命令可以设置键的过期时间，一旦超过预设的时间，值就会变成(nil)。利用这一点,加入一些业务参数，我们就可以有效的实现延时的目的。通过redis的过期时间使用redis的好处有以下几点：

1:对代码的侵入性低，不用额外起另外的线程来执行。只需要加入一个方法就可以对单流程的时间控制

2:实现方便灵活，通过key设值可以加入一些唯一性的id来表示业务含义,从而保证业务的稳健实现

3:简单,真正的代码实现起来只有很少

4.在springboot中配置redis简单示例：

pom.xml中依赖：

org.springframework.boot

spring-boot-starter-data-redis

io.lettuce

lettuce-core

redis.clients

jedis

redisTemplate实例化

@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;

}

}

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 返回值泛型

* @return 正确的值： 错误的值：null

*/

@SuppressWarnings("unchecked")

public ValueOperations setObject(final String key, final T value) {

final ValueOperations operation = redisTemplate.opsForValue();

operation.set(key, value);

return operation;

}

/**

* 设置对象及失效时间 (单位：秒)

*

* @param key key

* @param value value值

* @param 返回值泛型

* @param time 秒值

* @return 正确的值： 错误的值：null

*/

@SuppressWarnings("unchecked")

public ValueOperations setObject(final String key, final T value, final long time) {

final ValueOperations operation = redisTemplate.opsForValue();

operation.set(key, value, time, TimeUnit.SECONDS);

return operation;

}

/**

* 设置对象及失效时间(单位：毫秒)

*

* @param key key

* @param value value值

* @param 返回值泛型

* @param time 秒值

* @return 正确的值： 错误的值：null

*/

@SuppressWarnings("unchecked")

public ValueOperations setObjectForMillSeconds(final String key, final T value, final long time) {

final ValueOperations operation = redisTemplate.opsForValue();

operation.set(key, value, time, TimeUnit.MILLISECONDS);

return operation;

}

/**

* 获取对象

*

* @param key 键

* @return 正确的值：Object值对象

* 错误的值：null

*/

@SuppressWarnings("unchecked")

public Object getObject(final String key) {

final ValueOperations 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 valueOperations = redisTemplate.opsForValue();

if (valueOperations != null && redisTemplate.hasKey(key)) {

final Object object = valueOperations.get(key);

if (null != object) {

http://LOGGER.info("--getString--object not empty");

value = object.toString();

} else {

http://LOGGER.info("--getString--object empty");

}

}

return value;

}

在redis中实现时间控制

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);

}

}

这些回答希望能够给你一个思路以供参考。