public static void main(String[] args) {
// TODO Auto-generated method stub
List list = new ArrayList();
list.add(“00000001”);
list.add(“00000002”);
list.add(“00000003”);
list.add(“00000004”);
list.add(“00000005”);
DelayQueue queue = new DelayQueue();
long start = System.currentTimeMillis();
for (int i = 0; i < 5; i++) {
//延迟三秒取出
queue.put(new OrderDelay(list.get(i),
TimeUnit.NANOSECONDS.convert(3, TimeUnit.SECONDS)));//入队
try {
queue.take().print();
System.out.println("After " +
(System.currentTimeMillis() - start) + " MilliSeconds");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
测试结果如下:
-
优点:效率高,任务触发时间延迟低。
-
缺点:
(1)服务器重启后,数据全部消失,怕宕机
(2)集群扩展相当麻烦
(3)因为内存条件限制的原因,比如下单未付款的订单数太多,那么很容易就出现OOM异常
(4)代码复杂度较高
====================================================================
时间轮算法可以类比于时钟,如上图箭头(指针)按某一个方向按固定频率轮动,每一次跳动称为一个 tick。
这样可以看出定时轮由个3个重要的属性参数,ticksPerWheel(一轮的tick数),tickDuration(一个tick的持续时间)以及 timeUnit(时间单位)
例如当ticksPerWheel=60,tickDuration=1,timeUnit=秒,这就和现实中的始终的秒针走动完全类似了。
如果当前指针指在1上面,我有一个任务需要4秒以后执行,那么这个执行的线程回调或者消息将会被放在5上。
那如果需要在20秒之后执行怎么办,由于这个环形结构槽数只到8,如果要20秒,指针需要多转2圈。位置是在2圈之后的5上面(20 % 8 + 1)
我们用Netty的HashedWheelTimer来实现
3.2.1 添加maven依赖
io.netty
netty-all
5.0.0.Alpha2
3.2.2 具体实现
import io.netty.util.HashedWheelTimer;
import io.netty.util.Timeout;
import io.netty.util.Timer;
import io.netty.util.TimerTask;
import java.util.concurrent.TimeUnit;
public class HashedWheelTimerTest {
static class MyTimerTask implements TimerTask{
boolean flag;
public MyTimerTask(boolean flag){
this.flag = flag;
}
public void run(Timeout timeout) throws Exception {
// TODO Auto-generated method stub
System.out.println(“要去数据库删除订单了。。。。”);
this.flag =false;
}
}
public static void main(String[] argv) {
MyTimerTask timerTask = new MyTimerTask(true);
Timer timer = new HashedWheelTimer();
timer.newTimeout(timerTask, 3, TimeUnit.SECONDS);//此处设置在时间轮第几个执行(本代码设置为第3格)
int i = 1;
while(timerTask.flag){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(i+“秒过去了”);
i++;
}
}
}
测试结果如下:
-
优点:效率高,任务触发时间延迟时间比delayQueue低,代码复杂度比delayQueue低。
-
缺点:
(1)服务器重启后,数据全部消失,怕宕机
(2)集群扩展相当麻烦
(3)因为内存条件限制的原因,比如下单未付款的订单数太多,那么很容易就出现OOM异常
======================================================================
对于redis缓存的实现我们有两种方式:
-
1.利用redis的zset,zset是一个有序集合,每一个元素(member)都关联了一个score,通过score排序来取集合中的值
-
2.使用redis的Keyspace Notifications(键空间机制),就是利用该机制可以在key失效之后,提供一个回调,实际上是redis会给客户端发送一个消息。
添加元素:ZADD key score member [[score member] [score member] …]
按顺序查询元素:ZRANGE key start stop [WITHSCORES]
查询元素score:ZSCORE key member
移除元素:ZREM key member [member …]
下面我通过实操来给大家演示一下
添加单个元素
redis> ZADD page_rank 10 google.com
添加多个元素
redis> ZADD page_rank 9 baidu.com 8 bing.com
(integer) 2
按顺序查询元素 0 -1表示查询所有
ZRANGE page_rank 0 -1 WITHSCORES
查询元素的score值
redis> ZSCORE page_rank bing.com
移除单个元素
redis> ZREM page_rank google.com
我们具体将其和和我们要实现的功能联系在一起呢?
4.1.1 添加redis依赖
org.springframework.boot
spring-boot-starter-redis
1.4.7.RELEASE
具体的实现如下:
import java.util.Calendar;
import java.util.Set;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Tuple;
public class AppTest {
private static final String ADDR = “192.168.1.2”;
private static final int PORT = 6379;
private static JedisPool jedisPool = new JedisPool(ADDR, PORT);
private static int waitTime = 10;//以10秒为基准
public static Jedis getJedis() {
return jedisPool.getResource();
}
//生产者,生成5个订单放进去
public void productionDelayMessage() {
long startTime = System.currentTimeMillis();
for (int i = 0; i < 5; i++) {
//延迟3秒
Calendar cal1 = Calendar.getInstance();
waitTime += 5;//每个订单之间的间隔为5秒
cal1.add(Calendar.SECOND, waitTime);
int second3later = (int) (cal1.getTimeInMillis() / 1000);
AppTest.getJedis().zadd(“OrderId”, second3later, “OID0000001” + i);
long endTime = System.currentTimeMillis();
System.out.println((endTime - startTime) / 1000 + “s:redis生成了一个订单任务:订单ID为” + “OID0000001” + i);
}
}
//消费者,取订单
public void consumerDelayMessage() {
Jedis jedis = AppTest.getJedis();
long startTime = System.currentTimeMillis();
while (true) {
Set items = jedis.zrangeWithScores(“OrderId”, 0, 1);
if (items == null || items.isEmpty()) {
System.out.println(“当前没有等待的任务”);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
continue;
}
int score = (int) ((Tuple) items.toArray()[0]).getScore();
Calendar cal = Calendar.getInstance();
int nowSecond = (int) (cal.getTimeInMillis() / 1000);
if (nowSecond >= score) {
String orderId = ((Tuple) items.toArray()[0]).getElement();
jedis.zrem(“OrderId”, orderId);
long endTime = System.currentTimeMillis();
System.out.println((endTime - startTime) / 1000 + “s:redis消费了一个任务:消费的订单OrderId为” + orderId);
}
}
}
public static void main(String[] args) {
AppTest appTest = new AppTest();
appTest.productionDelayMessage();//创建消费订单
appTest.consumerDelayMessage();//由消费者进行消费
}
}
测试结果如下:
通过上述结果我们可以看出每隔5秒消费了一笔订单
然而上面的实现却有一个致命的问题: 在高并发条件下,多消费者会取到同一个订单号
我们使用多线程进行测试一下
import java.util.concurrent.CountDownLatch;
public class ThreadTest {
private static final int threadNum = 10;//线程数
private static CountDownLatch cdl = new CountDownLatch(threadNum);
static class DelayMessage implements Runnable {
public void run() {
try {
cdl.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
AppTest appTest = new AppTest();
appTest.consumerDelayMessage();
}
}
public static void main(String[] args) {
AppTest appTest = new AppTest();
appTest.productionDelayMessage();
for (int i = 0; i < threadNum; i++) {
new Thread(new DelayMessage()).start();
cdl.countDown();
}
}
}
可以看出出现了多个线程消费同一个资源的情况,这种情况肯定是不允许的,所以给出两个解决方案让大家参考
-
1.用分布式锁,但是用分布式锁,性能下降了
-
2.对ZREM的返回值进行判断,只有大于0的时候,才消费数据
由于方案1涉及到java分布式锁的设计,后面我会专门出一期关于java分布式锁的内容讲解,同时也会将第一个方法的内容补全,下面我们先看看如何通过ZREM来进行解决多线程消费同一个订单的问题
4.1.2 解决多线程消费同一资源
我们将consumerDelayMessage()方法中的
改为以下内容
总目录展示
该笔记共八个节点(由浅入深),分为三大模块。
高性能。 秒杀涉及大量的并发读和并发写,因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。
一致性。 秒杀中商品减库存的实现方式同样关键。可想而知,有限数量的商品在同一时刻被很多倍的请求同时来减库存,减库存又分为“拍下减库存”“付款减库存”以及预扣等几种,在大并发更新的过程中都要保证数据的准确性,其难度可想而知。因此,将用一个节点来专门讲解如何设计秒杀减库存方案。
高可用。 虽然介绍了很多极致的优化思路,但现实中总难免出现一些我们考虑不到的情况,所以要保证系统的高可用和正确性,还要设计一个PlanB来兜底,以便在最坏情况发生时仍然能够从容应对。笔记的最后,将带你思考可以从哪些环节来设计兜底方案。
篇幅有限,无法一个模块一个模块详细的展示(这些要点都收集在了这份《高并发秒杀顶级教程》里),麻烦各位转发一下(可以帮助更多的人看到哟!)
由于内容太多,这里只截取部分的内容。
我们将consumerDelayMessage()方法中的
改为以下内容
总目录展示
该笔记共八个节点(由浅入深),分为三大模块。
高性能。 秒杀涉及大量的并发读和并发写,因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。
一致性。 秒杀中商品减库存的实现方式同样关键。可想而知,有限数量的商品在同一时刻被很多倍的请求同时来减库存,减库存又分为“拍下减库存”“付款减库存”以及预扣等几种,在大并发更新的过程中都要保证数据的准确性,其难度可想而知。因此,将用一个节点来专门讲解如何设计秒杀减库存方案。
高可用。 虽然介绍了很多极致的优化思路,但现实中总难免出现一些我们考虑不到的情况,所以要保证系统的高可用和正确性,还要设计一个PlanB来兜底,以便在最坏情况发生时仍然能够从容应对。笔记的最后,将带你思考可以从哪些环节来设计兜底方案。
篇幅有限,无法一个模块一个模块详细的展示(这些要点都收集在了这份《高并发秒杀顶级教程》里),麻烦各位转发一下(可以帮助更多的人看到哟!)
[外链图片转存中…(img-unKvMzXR-1714359573228)]
[外链图片转存中…(img-yPTafRf4-1714359573228)]
由于内容太多,这里只截取部分的内容。