Java 包装ExecutorService以提供自定义执行

我想编写一段可重用的代码，以便在将任务提交给executor服务时允许等待条件。如果队列中有太多的任务，有很多实现方法可以实现整洁的阻塞，例如

我需要一个执行器，它在每次任务完成时评估所有等待的线程。为了决定是否允许在atm上提交任务，必须考虑所有活动任务的当前状态。我提出了以下解决方案，它不必为多个提交者或高级别的同时执行的任务进行扩展

问题：以下代码是否可以安全使用，或者是否存在我遗漏的某些缺陷？实现

ConditionEvaluator

的

aquireAccess

方法的人必须确保所查询线程的状态是线程安全的，但实现者不需要保护activeTasks集合上的迭代。代码如下：

public class BlockingExecutor<T extends Runnable> {

    private final Executor executor;

    private final ConditionEvaluator<T> evaluator;

    final ReentrantLock lock = new ReentrantLock();

    final Condition condition = this.lock.newCondition();

    final LinkedList<T> active = new LinkedList<T>();

    private final long reevaluateTime;

    private final TimeUnit reevaluateTimeUnit;

    public BlockingExecutor(Executor executor, ConditionEvaluator<T> evaluator) {
        this.evaluator = evaluator;
        this.executor = executor;
        this.reevaluateTimeUnit = null;
        this.reevaluateTime = 0;
    }

    public BlockingExecutor(Executor executor, ConditionEvaluator<T> evaluator, long reevaluateTime, TimeUnit reevaluateTimeUnit) {
        this.evaluator = evaluator;
        this.executor = executor;
        this.reevaluateTime = reevaluateTime;
        this.reevaluateTimeUnit = reevaluateTimeUnit;
    }

    public void submitTask(final T task) throws InterruptedException {
        this.lock.lock();
        try {
            do{
            if (this.reevaluateTimeUnit == null) {
                this.condition.await(this.reevaluateTime, this.reevaluateTimeUnit);
            } else {
                this.condition.await();
            }
            }while(!this.evaluator.aquireAccess(this.active, task));
                this.active.add(task);
                this.executor.execute(new Runnable() {

                    @Override
                    public void run() {
                        try {
                            task.run();
                        } finally {
                            BlockingExecutor.this.lock.lock();
                            try{
                                BlockingExecutor.this.active.remove(task);
                                BlockingExecutor.this.condition.signalAll();
                            }finally{
                                BlockingExecutor.this.lock.unlock();
                            }

                        }
                    }
                });
        } finally {
            this.lock.unlock();
        }
    }
}

public interface ConditionEvaluator<T extends Runnable> {
    public boolean aquireAccess(Collection<T> activeList,T task);   
}

公共类阻止执行器{
私人最终执行人；
私人最终条件评估师；
最终ReentrantLock=新的ReentrantLock（）；
最终条件=this.lock.newCondition（）；
final LinkedList active=新LinkedList（）；
私人最终长期重新评估时间；
私人最终计时单位重新评估时间单位；
公共封锁执行者（执行者执行者，条件评估者评估者）{
this.evaluator=评估者；
this.executor=执行人；
this.reevaluateTimeUnit=null；
此项。重新评估时间=0；
}
公共封锁执行器（执行器执行器、条件评估器评估器、长重新评估时间、时间单位重新评估时间单位）{
this.evaluator=评估者；
this.executor=执行人；
this.reevaluateTime=重新评估时间；
this.reevaluateTimeUnit=reevaluateTimeUnit；
}
public void submitTask（最终T任务）抛出InterruptedException{
this.lock.lock（）；
试一试{
做{
if（this.reevaluateTimeUnit==null）{
this.condition.await（this.reevaluateTime，this.reevaluateTimeUnit）；
}否则{
this.condition.await（）；
}
}而（！this.evaluator.aquireAccess（this.active，task））；
this.active.add（任务）；
this.executor.execute（new Runnable（））{
@凌驾
公开募捐{
试一试{
task.run（）；
}最后{
阻塞executor.this.lock.lock（）；
试一试{
BlockingExecutor.this.active.remove（任务）；
BlockingExecutor.this.condition.signalAll（）；
}最后{
BlockingExecutor.this.lock.unlock（）；
}
}
}
});
}最后{
这个.lock.unlock（）；
}
}
}
公共接口条件计算器{
公共布尔获取访问（集合活动列表，T任务）；
}

---

问题：代码可以改进吗？

一个小改进是从第一个构造函数调用第二个构造函数，而不是重写赋值。为什么不自己实现

Executor

？