JAVA队列的使用

今天跟大家来看看如何在项目中使用队列。首先我们要知道使用队列的目的是什么?一般情况下,如果是一些及时消息的处理,并且处理时间很短的情况下是不需要使用队列的,直接阻塞式的方法调用就可以了。但是,如果在消息处理的时候特别费时间,这个时候如果有新的消息来了,就只能处于阻塞状态,造成用户等待。这个时候在项目中引入队列是十分有必要的。当我们接受到消息后,先把消息放到队列中,然后再用新的线程进行处理,这个时候就不会有消息的阻塞了。下面就跟大家介绍两种队列的使用,一种是基于内存的,一种是基于数据库的。

首先,我们来看看基于内存的队列。在Java的并发包中已经提供了BlockingQueue的实现,比较常用的有ArrayBlockingQueue和LinkedBlockingQueue,前者是以数组的形式存储,后者是以Node节点的链表形式存储。至于数组和链表的区别这里就不多说了。

BlockingQueue 队列常用的操作方法:

1.往队列中添加元素: add(), put(), offer()

2.从队列中取出或者删除元素: remove() element()  peek()   pool()  take()

每个方法的说明如下:

offer()方法往队列添加元素如果队列已满直接返回false,队列未满则直接插入并返回true;

add()方法是对offer()方法的简单封装.如果队列已满,抛出异常new IllegalStateException("Queue full");

put()方法往队列里插入元素,如果队列已经满,则会一直等待直到队列为空插入新元素,或者线程被中断抛出异常.

remove()方法直接删除队头的元素:

peek()方法直接取出队头的元素,并不删除.

element()方法对peek方法进行简单封装,如果队头元素存在则取出并不删除,如果不存在抛出异常NoSuchElementException()

pool()方法取出并删除队头的元素,当队列为空,返回null;

take()方法取出并删除队头的元素,当队列为空,则会一直等待直到队列有新元素可以取出,或者线程被中断抛出异常

offer()方法一般跟pool()方法相对应, put()方法一般跟take()方法相对应.日常开发过程中offer()与pool()方法用的相对比较频繁.

下面用一个例子来看看是怎么使用的。

  1. import java.util.concurrent.BlockingQueue;
  2. import java.util.concurrent.Executors;
  3. import java.util.concurrent.LinkedBlockingQueue;
  4. import java.util.concurrent.ScheduledExecutorService;
  5. import java.util.concurrent.TimeUnit;
  6. public class UserTask {
  7. //队列大小
  8. private final int QUEUE_LENGTH = 10000*10;
  9. //基于内存的阻塞队列
  10. private BlockingQueue<String> queue = new LinkedBlockingQueue<String>(QUEUE_LENGTH);
  11. //创建计划任务执行器
  12. private ScheduledExecutorService es = Executors.newScheduledThreadPool(1);
  13. /**
  14. * 构造函数,执行execute方法
  15. */
  16. public UserTask() {
  17. execute();
  18. }
  19. /**
  20. * 添加信息至队列中
  21. * @param content
  22. */
  23. public void addQueue(String content) {
  24. queue.add(content);
  25. }
  26. /**
  27. * 初始化执行
  28. */
  29. public void execute() {
  30. //每一分钟执行一次
  31. es.scheduleWithFixedDelay(new Runnable(){
  32. public void run() {
  33. try {
  34. String content = queue.take();
  35. //处理队列中的信息。。。。。
  36. System.out.println(content);
  37. } catch (InterruptedException e) {
  38. e.printStackTrace();
  39. }
  40. }
  41. }, 0, 1, TimeUnit.MINUTES);
  42. }
  43. }

以上呢,就是基于内存的队列的介绍,基于内存的队列,队列的大小依赖于JVM内存的大小,一般如果是内存占用不大且处理相对较为及时的都可以采用此种方法。如果你在队列处理的时候需要有失败重试机制,那么用此种队列就不是特别合适了。下面就说说基于数据库的队列。

基于数据库的队列,很好理解,就是接收到消息之后,把消息存入数据库中,设置消费时间、重试次数等,再用新的线程从数据库中读取信息,进行处理。首先来看看数据库的设计。

字段
类型
说明
queue_id
bigint
队列ID,唯一标识
create_time
bigint
创建时间
type
int
业务类型
status
int
处理状态位 : 1:有效可处理(active) 3:临时被占用 (locked) 5:处理完毕 标记删除(deleted)
consume_status
int
消费状态:1:未消费  2:消费成功 3:消费失败,等待下次消费 4:作废
update_time
bigint
更新时间
locker
varchar
占用标签
last_consume_time
bigint
最后一次消费时间
next_consume_time
bigint
可消费开始时间
consume_count
int
消费次数
json_data
text
数据信息 json格式

代码示例如下:

  1. /**
  2. * 批量获取 可以消费的消息
  3. * 先使用一个时间戳将被消费的消息锁定,然后再使用这个时间戳去查询锁定的数据。
  4. * @param count
  5. * @return
  6. */
  7. public List<Queue> findActiveQueueNew(int count) {
  8. //先去更新数据
  9. String locker = String.valueOf(System.currentTimeMillis())+random.nextInt(10000);
  10. int lockCount = 0;
  11. try {
  12. //将status为1的更新为3,设置locker,先锁定消息
  13. lockCount = queueDAO.updateActiveQueue(PayConstants.QUEUE_STATUS_LOCKED,
  14. PayConstants.QUEUE_STATUS_ACTIVE, count, locker);
  15. } catch (Exception e) {
  16. logger.error(
  17. "QueueDomainRepository.findActiveQueueNew error occured!"
  18. + e.getMessage(), e);
  19. throw new TuanRuntimeException(
  20. PayConstants.SERVICE_DATABASE_FALIURE,
  21. "QueueDomainRepository.findActiveQueue error occured!", e);
  22. }
  23. //如果锁定的数量为0,则无需再去查询
  24. if(lockCount == 0){
  25. return null;
  26. }
  27. //休息一会在再询,防止数据已经被更改
  28. try {
  29. Thread.sleep(1);
  30. } catch (Exception e) {
  31. logger.error("QueueDomainRepository.findActiveQueue error sleep occured!"
  32. + e.getMessage(), e);
  33. }
  34. List<Queue> activeList = null;
  35. try {
  36. activeList = queueDAO.getByLocker(locker);
  37. } catch (Exception e) {
  38. logger.error("QueueDomainRepository.findActiveQueue error occured!"
  39. + e.getMessage(), e);
  40. throw new TuanRuntimeException(
  41. PayConstants.SERVICE_DATABASE_FALIURE,
  42. "QueueDomainRepository.findActiveQueue error occured!",e);
  43. }
  44. return activeList;
  45. }

获取到消息之后,还需要再判断消息是否合法,如是否达到最大消费次数,消息是否已被成功消费,等,判断代码如下:

  1. /**
  2. * 验证队列modle 的合法性
  3. *
  4. * @param model
  5. * @return boolean true,消息还可以消费。false,消息不允许消费。
  6. */
  7. public boolean validateQueue(final QueueModel model){
  8. int consumeCount = model.getConsumeCount();
  9. if (consumeCount >= PayConstants.QUEUE_MAX_CONSUME_COUNT) {
  10. //消费次数超过了最大次数
  11. return false;
  12. }
  13. int consumeStatus = model.getConsumeStatus();
  14. if(consumeStatus == PayConstants.QUEUE_STATUS_CONSUMER_SUCCESS){
  15. //消息已经被成功消费
  16. return false;
  17. }
  18. QueueStatusEnum queueStatusEnum  = model.getQueueStatusEnum();
  19. if(queueStatusEnum == null || queueStatusEnum != QueueStatusEnum.LOCKED){
  20. //消息状态不正确
  21. return false;
  22. }
  23. String jsonData = model.getJsonData();
  24. if(StringUtils.isEmpty(jsonData)){
  25. //消息体为空
  26. return false;
  27. }
  28. return true;
  29. }

消息处理完毕之后,根据消费结果修改数据库中的状态。

  1. public void consume(boolean isDelete, Long consumeMinTime,
  2. String tradeNo,int consumeCount) {
  3. QueueDO queueDO  = new QueueDO();
  4. if (!isDelete) {
  5. //已经到了做大消费次数,消息作废 不再处理
  6. if (consumeCount >= PayConstants.QUEUE_MAX_CONSUME_COUNT) {
  7. //达到最大消费次数的也设置为消费成功
  8. queueDO.setConsumeStatus(PayConstants.QUEUE_STATUS_CONSUMER_SUCCESS);
  9. queueDO.setStatus(PayConstants.QUEUE_STATUS_CANCEL);
  10. } else {
  11. queueDO.setConsumeStatus(PayConstants.QUEUE_STATUS_CONSUMER_FAILED);
  12. //设置为可用状态等待下次继续发送
  13. queueDO.setStatus(PayConstants.QUEUE_STATUS_ACTIVE);
  14. }
  15. } else {
  16. //第三方消费成功
  17. queueDO.setConsumeStatus(PayConstants.QUEUE_STATUS_CONSUMER_SUCCESS);
  18. queueDO.setStatus(PayConstants.QUEUE_STATUS_DELETED);
  19. }
  20. queueDO.setNextConsumeTime(consumeMinTime == null ? QueueRuleUtil
  21. .getNextConsumeTime(consumeCount) : consumeMinTime);
  22. if (StringUtils.isNotBlank(tradeNo)) {
  23. queueDO.setTradeNo(tradeNo);
  24. }
  25. long now = System.currentTimeMillis();
  26. queueDO.setUpdateTime(now);
  27. queueDO.setLastConsumeTime(now);
  28. queueDO.setConsumeCount(consumeCount);
  29. queueDO.setQueueID(id);
  30. setQueueDOUpdate(queueDO);
  31. }

下次消费时间的计算如下:根据消费次数计算,每次消费存在递增的时间间隔。

  1. /**
  2. * 队列消费 开始时间 控制
  3. */
  4. public class QueueRuleUtil {
  5. public static long getNextConsumeTime(int consumeCount) {
  6. return getNextConsumeTime(consumeCount, 0);
  7. }
  8. public static long getNextConsumeSecond(int consumeCount) {
  9. return getNextConsumeTime(consumeCount, 0);
  10. }
  11. public static long getNextConsumeTime(int cousumeCount, int addInteval) {
  12. int secends = getNextConsumeSecond(cousumeCount,addInteval);
  13. return System.currentTimeMillis()+secends*1000;
  14. }
  15. public static int getNextConsumeSecond(int cousumeCount, int addInteval) {
  16. if (cousumeCount == 1) {
  17. return  addInteval + 10;
  18. } else if (cousumeCount == 2) {
  19. return  addInteval + 60;
  20. } else if (cousumeCount == 3) {
  21. return  addInteval + 60 * 5;
  22. } else if (cousumeCount == 4) {
  23. return  addInteval + 60 * 15;
  24. } else if (cousumeCount == 5) {
  25. return addInteval + 60 * 60;
  26. } else if (cousumeCount == 6){
  27. return addInteval + 60 * 60 *2;
  28. } else if(cousumeCount == 7){
  29. return addInteval + 60 * 60 *5;
  30. } else {
  31. return addInteval + 60 * 60 * 10;
  32. }
  33. }

除此之外,对于消费完成,等待删除的消息,可以将消息直接删除或者是进行备份。最好不要在该表中保留太多需要删除的消息,以免影响数据库的查询效率。

我们在处理消息的时候,首先对消息进行了锁定,设置了locker,如果系统出现异常的时候,也会产生消息一直处于被锁定的状态,此时可能还需要定期去修复被锁定的消息。

  1. /**
  2. * 批量获取 可以消费的消息
  3. *
  4. * @param count
  5. * @return
  6. */
  7. public void repairQueueByStatus(int status) {
  8. List<QueueDO> activeList = null;
  9. try {
  10. Map<String,Object> params = new HashMap<String,Object>();
  11. params.put("status", status);
  12. //下次消费时间在当前时间3小时以内的消息
  13. params.put("next_consume_time", System.currentTimeMillis()+3*60*1000);
  14. activeList =  queueDAO.findQueueByParams(params);
  15. } catch (Exception e) {
  16. logger.error("QueueDomainRepository.repairQueueByStatus find error occured!"
  17. + e.getMessage(), e);
  18. throw new TuanRuntimeException(
  19. PayConstants.SERVICE_DATABASE_FALIURE,
  20. "QueueDomainRepository.findQueueByStatus error occured!",e);
  21. }
  22. if (activeList == null || activeList.size() == 0) {
  23. return ;
  24. }
  25. for (QueueDO temp : activeList) {
  26. try {
  27. //status=1,可被消费
  28. queueDAO.update(temp.getQueueID(), PayConstants.QUEUE_STATUS_ACTIVE);
  29. } catch (Exception e) {
  30. logger.error("QueueDomainRepository.repairQueueByStatus  update error occured!"
  31. + e.getMessage(), e);
  32. throw new TuanRuntimeException(
  33. PayConstants.SERVICE_DATABASE_FALIURE,
  34. "QueueDomainRepository.repairQueueByStatus update error occured!",e);
  35. }
  36. }
  37. }

以上就是对两种队列的简单说明。在使用基于数据库的队列的时候,其中还使用到了事件处理机制,这部分的内容,就下次的时候再去介绍。

 
 
http://blog.csdn.net/yang5726685/article/details/54234569

JAVA队列的使用的更多相关文章

  1. java队列Queue及阻塞队列

    java队列 接口Queue类在java.util包,定义了以下6个方法 详细查看官方文档https://docs.oracle.com/javase/7/docs/api/java/util/Que ...

  2. Java:Java 队列的遍历

    Java队列到底有没有可以遍历的功能呢?暂且试一下吧 参考链接:stl容器遍历测试 1.LinkedList实现简单遍历 for(Iter =LocTimesSerials.size()-1; iSe ...

  3. Java队列集合的性能测试

    同时开10个线程存入和取出100万的数据,结论如下: DoubleBufferedQueue < ConcurrentLinkedQueue < ArrayBlockingQueue &l ...

  4. java队列——queue详细分析

    Queue: 基本上,一个队列就是一个先入先出(FIFO)的数据结构 Queue接口与List.Set同一级别,都是继承了Collection接口.LinkedList实现了Deque接 口.   Q ...

  5. java队列

    "队列"这个单词是英国人说的"排".在英国"排队"的意思就是站到一排当中去.计算机科学中,队列是一种数据结构,有点类似栈,只是在队列中第一个 ...

  6. Java队列学习

    队列是Java集合中的重要组成部分,具有先进先出的特性,使其具有广泛的应用场景,比如排队等.因此今天就来学习一下Java中的队列.本文的例子使用的Java8环境. 继承类图 学习队列,首先要知道它的类 ...

  7. Java队列Queue

    上个星期总结了一下synchronized相关的知识,这次将Queue相关的知识总结一下,和朋友们分享. 在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列.Java提供 ...

  8. Java队列——线程池创建的例子

    线程池为线程生命周期开销问题和资源不足问题提供了解决方案.通过对多个任务重用线程,线程创建的开销被分摊到了多个任务上.其好处是,因为在请求到达时线程已经存在,所以无意中也消除了线程创建所带来的延迟.这 ...

  9. Java队列——Disruptor 的使用

    .什么是 Disruptor  从功能上来看,Disruptor 是实现了“队列”的功能,而且是一个有界队列.那么它的应用场景自然就是“生产者-消费者”模型的应用场合了. 可以拿 JDK 的 Bloc ...

随机推荐

  1. Unity中Surface Shader执行过程

  2. N76E003的学习之路(一)

    N76E003是8051内核的一款单片机MCU,它提供丰富的特殊功能模块,包括: 1KRAM其中包括256字节SRAM,768字节XRAM. 最多可达18个标准管脚. 两组标准16位定时器/计数器:定 ...

  3. C++ template —— 深入模板基础(二)

    上一篇C++ template —— 模板基础(一)讲解了有关C++模板的大多数概念,日常C++程序设计中所遇到的很多问题,都可以从这部分教程得到解答.本篇中我们深入语言特性.------------ ...

  4. Eclipse cdt debug时‘Error while launching command: gdb.exe --version’

    1. 下载gdb,网上很多可以下载一个,解压放在mingw/bin下,由于该目录以在path制定,在CMD下,gdb -version会显示当前gdb版本信息. 2.按照该文档配置即可实现debug

  5. 深入理解Auto Layout 第一弹

    本文转载至 http://zhangbuhuai.com/2015/07/16/beginning-auto-layout-part-1/ By 张不坏 2015-07-16 更新日期:2015-07 ...

  6. iPhone X的缺口和CSS

    苹果公司(Apple)的发布会也开完了,新产品也将登陆了.估计很多开发人员看到iPhone X的设备是要崩溃了,特别对于前端开发人员更是如此. iPhone X的屏幕覆盖了整个手机的屏幕,为相机和其他 ...

  7. SharpGL学习笔记(六) 裁剪变换

    在OpenGL中,除了视景体定义的6个裁剪平面(上下左右前后)外, 用户还可以定义一个或者多个附加的裁剪平面,以去掉场景中无关的目标. 附加平面裁剪函数原型如下: ClipPlane(OpenGL.G ...

  8. mac下编译 boost编译工具b2

    cd boost_1_64_0/tools/build ./bootstrap.sh --with-toolset=gcc 输出: -n Bootstrapping the build engine ...

  9. LeetCode 44 Wildcard Matching(字符串匹配问题)

    题目链接:https://leetcode.com/problems/wildcard-matching/?tab=Description   '?' Matches any single chara ...

  10. 记录一次OOM排查经历(一)

    一.经历概要 程序里有个跑数据的job,这个job的主要功能是往数据库写假数据. 既需要跑历史数据(传给job的日期是过去的时间),也需要能够上线后,实时跑(十秒钟触发一次,传入触发时的当前时间). ...