ArrayBlockingQueue的使用案例:

ArrayBlockingQueue的介绍:

ArrayBlockingQueue，顾名思义：基于数组的阻塞队列。数组是要指定长度的，所以使用ArrayBlockingQueue时必须指定长度，也就是它是一个有界队列。

它实现了BlockingQueue接口，有着队列、集合以及阻塞队列的所有方法，

他有三个构造方法:

并没有无参构造,所以必须要初始化长度,不让他变成一个无边界的数据队列,可能会存在内存过大的问题

内部实现了ReentrantLock锁,所以线程是安全的,

使用场景,异步队列发送邮件:

首先封装mail对象进queue队列:

public class Email implements Serializable {

    private static final long serialVersionUID = 1L;

    //必填参数

    private String[] email;//接收方邮件

    private String subject;//主题

    private String content;//邮件内容

    //选填

    private String template;//模板

    private HashMap<String, String> kvMap;// 自定义参数

    public Email() {

        super();

    }

    public Email(String[] email, String subject, String content, String template,

            HashMap<String, String> kvMap) {

        super();

        this.email = email;

        this.subject = subject;

        this.content = content;

        this.template = template;

        this.kvMap = kvMap;

    }

    public String[] getEmail() {

        return email;

    }

    public void setEmail(String[] email) {

        this.email = email;

    }

    public String getSubject() {

        return subject;

    }

    public void setSubject(String subject) {

        this.subject = subject;

    }

    public String getContent() {

        return content;

    }

    public void setContent(String content) {

        this.content = content;

    }

    public String getTemplate() {

        return template;

    }

    public void setTemplate(String template) {

        this.template = template;

    }

    public HashMap<String, String> getKvMap() {

        return kvMap;

    }

    public void setKvMap(HashMap<String, String> kvMap) {

        this.kvMap = kvMap;

    }

}

然后写一个MailQueue:

package com.itstyle.mail.common.queue;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

import com.itstyle.mail.common.model.Email;

/**

public class MailQueue {

     //队列大小

    static final int QUEUE_MAX_SIZE   = ;

    //static BlockingQueue<Email> blockingQueue = new LinkedBlockingQueue<Email>(QUEUE_MAX_SIZE);

    static ArrayBlockingQueue<Email> blockingQueue=new ArrayBlockingQueue<Email>();

    /**

     * 私有的默认构造子，保证外界无法直接实例化

     */

    private MailQueue(){};

    /**

     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例

     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载

     */

    private static class SingletonHolder{

        /**

         * 静态初始化器，由JVM来保证线程安全

         */

        private  static MailQueue queue = new MailQueue();

    }

    //单例队列

    public static MailQueue getMailQueue(){

        return SingletonHolder.queue;

    }

    //生产入队

    public  void  produce(Email mail) throws InterruptedException {

        blockingQueue.put(mail);

    }

    //消费出队

    public  Email consume() throws InterruptedException {

        return blockingQueue.take();

    }

    // 获取队列大小

    public int size() {

        return blockingQueue.size();

    }

}

里面包括了消费和创建的方法:

 //生产入队

    public  void  produce(Email mail) throws InterruptedException {

        blockingQueue.put(mail);

    }

    //消费出队

    public  Email consume() throws InterruptedException {

        return blockingQueue.take();

    }

使用静态内部类的方法,保证单利模式

消费队列:

package com.itstyle.mail.common.queue;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import com.itstyle.mail.common.model.Email;

import com.itstyle.mail.service.IMailService;

@Component

public class ConsumeMailQueue {

    private static final Logger logger = LoggerFactory.getLogger(ConsumeMailQueue.class);

    @Autowired

    IMailService mailService;

    @PostConstruct

    public void startThread() {

        ExecutorService e = Executors.newFixedThreadPool();// 两个大小的固定线程池

        e.submit(new PollMail(mailService));

        e.submit(new PollMail(mailService));

    }

    class PollMail implements Runnable {

        IMailService mailService;

        public PollMail(IMailService mailService) {

            this.mailService = mailService;

        }

        @Override

        public void run() {

            while (true) {

                try {

                    Email mail = MailQueue.getMailQueue().consume();

                    if (mail != null) {

                        logger.info("剩余邮件总数:{}",MailQueue.getMailQueue().size());

                        mailService.send(mail);

                    }

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

        }

    }

    @PreDestroy

    public void stopThread() {

        logger.info("destroy");

    }

}

这种从线程池获取消费线程来执行,这个里面是一个多线程环境,为什么可以保证线程安全呢,是由于ArrayBlokcingQueue实现了reentranlock来实现的,

在这里将需要发送邮件的信息添加到队列中去.

如果需要判断是否满了,就需要使用offer方法,不是使用reminingkey方法:

可以参看下面文字:https://www.xttblog.com/?p=3686,这个大佬写的博客园

巴特西

ArrayBlockingQueue的使用案例:

最新文章

热门文章