java - 执行者在单例类中永远等待

Question

我已经实现了一个单例(管理器)来管理一些相关任务，在这个管理器中我使用一个执行器同时处理10个任务，我使用了无限制的linkedBlockingQueue，到目前为止效果很好，但是现在我需要对我的执行程序队列设置限制，因为我有很多任务(数十万个任务)，并且我不想将它们全部放入队列中，这会导致性能问题，所以我做了什么:

这是我的执行者:

public class MyThreadPoolExecutor extends ThreadPoolExecutor {

public MyThreadPoolExecutor(int corePoolSize, BlockingQueue<Runnable> workQueue) {
    super(corePoolSize, corePoolSize + 5, 500, TimeUnit.MILLISECONDS, workQueue);
}


@Override
protected void beforeExecute(Thread t, Runnable r) {
    super.beforeExecute(t, r);
    //Do something to my task
}

@Override
protected void afterExecute(Runnable r, Throwable t) {
    super.afterExecute(r, t);
    if(t != null) {
        // 
    } else {
        //Do something to my task
    }
}
}

这是我的经理:

public final class MyManager {

private static MyManager manager = new MyManager();
public static final int queueMaxSize = 100;
private BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(queueMaxSize);
private ExecutorService executor = new MyThreadPoolExecutor(10, workQueue);


/**
 * constructor
 */
private MyManager() {}

public static MyManager getInstance(){

    if (manager == null){
        synchronized(MyManager.class){
            if (manager == null){
                manager = new MyManager();
            }
        }
    }
    return manager;
}

/**
 */
public void executeTask(Integer key){
    executeTask(key, Locale.getDefault());
}

/**
 */
public void executeTask(Integer key, Locale locale) {
    Tasker task = new Tasker(key, locale);
    executor.execute(task);
}
}

这里是要求执行任务的类:

public class MyClass {

public void doTasks() {
    //geting my tasks in array of list, its holding more than 900 000 tasks,
    //sometimes its holding up to 10 million task like :
    MyManager.getInstance().isFull() {\\wait, then ask again}

    ArrayList<Integer> myTasks = getAllTasksIds();

    for(Integer id : myTasks) {
        //if i perform a waiting here it will be waiting for ever.
        MyManaget.getInstance().executeTask(id);
    }
}

}

我想要等待执行者完成他的队列任务，然后重新填充它。

但问题是，当我尝试根据队列大小进行等待时，执行器将无法工作，并且它会永远等待，因为队列仍然已满。

Answer 1

为什么不直接使用有界阻塞队列(即指定 BlockingQueue 的边界)？如果您使用有界阻塞队列(您可以自己选择大小)，则生产者将在队列已满时阻塞，并在队列中消耗任务时恢复发布任务。这样，您可以避免过快地将太多内容放入队列中，同时也避免将太少内容放入队列中。这就是阻塞队列的意义所在......