关于ArrayBlockingQueue队列的一些问题

背景：最近接手一个新的应用－商机快递，主要是给用户发送营销邮件，由于不定期会有漏发的情况，所以在里面加了一些逻辑来修复这个问题，由于系统采用了多线程的方式，改之前考虑的不周全，最后会导致重发的现象。

 // 创建一个阻塞队列，容量为maxThread*2
            ArrayBlockingQueue blockQueue = new ArrayBlockingQueue(maxThread * 2);
            exec = new BizExpressThreadPoolExecutor(maxThread, maxThread, 60, TimeUnit.SECONDS, blockQueue,
                                                    maxThread * 2);
            exec.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

            // 该方法可以给当前的进程注册一个清理线程，当进程退出的时候，会执行线程中的代码。
            Runtime.getRuntime().addShutdownHook(new Thread(new ShutdownHook()));
            while (!isShutDown) {
                exec.execute(new BizExpressMailRun());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
            }

 /**
     * @param corePoolSize 线程池维护线程的最少数量
     * @param maximumPoolSize 线程池维护线程的最大数量
     * @param keepAliveTime 线程池维护线程所允许的空闲时间
     * @param unit 线程池维护线程所允许的空闲时间的单位
     * @param workQueue 线程池所使用的缓冲队列
     * @param semaphore
     */
    public BizExpressThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue, int semaphore){
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        available = new Semaphore(semaphore, true);
    }

系统初始时会实例一个ThreadPoolExecutor对象（exec）。ThreadPoolExecutor是并发包中一个提供线程池的服务，可以很容易将一个实现了Runnable接口的任务放入线程池中执行。具体的execute(Runnable)方法执行过程为：

首先判断传入的Runnable对象是否为null,如果为null直接抛出NullPointException异常。如果不为空执行下面步骤

如果当前的线程数小于配置的corePoolSize，则调用addIfUnderCorePoolSize方法进而会调用mainLock锁。

如果当前的线程数小于配置的corePoolSize并且线程处于RUNNING状态，调用addThread增加线程，

addThread方法首先创建Worker对象，然后调用threadFactory（ Thread newThread(Runnable r); ）创建新的线程，如果创建新的线程不为null时，将Worker对象的thread属性指向此创建出来的线程，并将此Worker对象放入到workers中，最后增加当前线程池中的线程数。

用代码描述为：

    private List workers;
 private int count;//当前线程池中的线程数
 public void addThread(Runnable r){
 Worker worker=new Worker();
 Thread tt=threadFactory.newThread(r);
 if(rr!=null){
 worker.setThread(tt);
 }
 workers.add(worker);
 count++;
 }

－－－－－－－－－－－－－－－－－－－－－－－－－－

 while (!isShutDown) {
     exec.execute(new BizExpressMailRun());
       try {
             Thread.sleep(2000);
        } catch (InterruptedException e) {
      }
 }

这是阻塞队列的执行入口，是一个循环过程，中间会休眠2秒，队列的长度是初始化时的corePoolSize，消费和生产无序进行。

原来的做方法是

public void doPerform() {
        List<BizExpressDailyDO> bizexpresses = bizExpressDailyDAO.fetchSomeBizExpressDaily(
                                                                                           BizExpressConfig.getServerIp(),
                                                                                           BizExpressConfig.getBuildEachFetchNum());
        // 如果没有取到数据，则休眠5秒，避免反复读取数据库。
        if (bizexpresses == null || bizexpresses.size() == 0) {
            try {
                Thread.currentThread().sleep(5000);
                // 补发发送失败邮件
                doContinue();
            } catch (InterruptedException e) {
            }
            return;
        }
        takeCareOf(bizexpresses);
    }

一个线程执行doPerform方法，会改biz_express_daily表中的记录的ip,然后再执行takeCareOf方法来发邮件，发送成功后会将记录的status字段值改掉，但是关键的是在完成status改掉之前会有一段时间。

另外的线程调用doPerform方法，此时bizexpresses 为空，进入到if分支，调用doContinue方法。

public void doContinue() {
        // 获取当日被选出，但未被处理过的纪录，最多取100条
        List<BizExpressDailyDO> bizexpresses = bizExpressDailyDAO.fetchLastUnbuiltBizExpressDaily(
                                                                                                  BizExpressConfig.getServerIp(),
                                                                                                  BizExpressConfig.getBuildEachFetchNum());
        if (bizexpresses.size() > 0) {
            takeCareOf(bizexpresses);
        } else {
            return;
        }

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
        }

        doContinue();
    }

此时的bizexpresses 是有值的，而且取出来的正好是刚才第一个线程里面的值，然后同样执行takeCareOf方法发送邮件。

这样就会造成邮件的重发，当然根据线程抢占的激烈程度，会导致重发邮件的数量也不一致。