使用多个对象列表对同一对象进程进行线程处理

Question

我的问题是：什么是“最佳”方法来控制多个“RunnableObject s”的列表？

我有一种方法可以处理多线程，但我不认为它是最优的。在很多情况下，我有一个对象列表，都需要做同样的事情，但我不希望他们一次只做一个，所以我会把它们放在一个列表中，并将它们中的一部分一旦。完成后，它会在控制器上调用updateList()方法，该方法将删除完成的项目并调用新项目。我认为这不是一个很好的解决方法。我想使用.notify()之类的东西，但我不确定它在这种情况下是如何工作的（指引我去一个很好的学习网站可能会有用）。

我有我的控制器类下面的基本轮廓。 我试图让javadoc有用，所以如果你正在浏览，请继续阅读。谢谢。

只是一些示例代码让你知道我在说什么。

package controller; 

import java.util.ArrayList; 
import java.util.List; 
import model.RunnableObject; 

public class RunnableObjectController { 

    private static RunnableObjectController instance; 
    private List<RunnableObject> runnableObjects = new ArrayList<>(); 
    private List<RunnableObject> queuedRunnableObjects = new ArrayList<>(); 
    private List<RunnableObject> currentRunnableObjects = new ArrayList<>(); 
    private int limit = 10; 

    private RunnableObjectController() { 
    } 

    public static RunnableObjectController getInstance() { 
    if (instance == null) { 
     instance = new RunnableObjectController(); 
    } 
    return instance; 
    } 

    /** 
    * Updates the list. 
    */ 
    public void begin() { 
    updateList(); 
    } 

    /** 
    * Called by a runnableObject when it's finished with its process 
    */ 
    public synchronized void updateList() { 
    removeFinishedRunnableObjects(); 
    addNewRunnableObjects(); 
    if (isFinished()) { 
     MainController.getInstance().finish(); 
    } 
    } 

    /** 
    * Searches the currentRunnableObjects for runnableObjects which are not in progress and removes them from the currentRunnableObjects. 
    * It will add them to the queuedRunnableObjects if they are of status WAITING. 
    */ 
    private void removeFinishedRunnableObjects() { 
    int i = 0; 
    while (i < currentRunnableObjects.size()) { 
     RunnableObject runnableObject = currentRunnableObjects.get(i); 
     if (runnableObject.getStatus() != RunnableObject.IN_PROGRESS) { 
     currentRunnableObjects.remove(runnableObject); 
     if (runnableObject.getStatus() == RunnableObject.WAITING) { 
      queuedRunnableObjects.add(runnableObject); 
     } 
     } else { 
     i++; 
     } 
    } 
    } 

    /** 
    * Searches the queuedRunnableObjects and adds them to the currentRunnableObjects while the size of the currentRunnableObjects is less than the limit. 
    * Begins the runnableObject in a new thread and sets its status to IN_PROGRESS 
    */ 
    private void addNewRunnableObjects() { 
    while (!queuedRunnableObjects.isEmpty() && currentRunnableObjects.size() < limit) { 
     RunnableObject runnableObject = queuedRunnableObjects.get(0); 
     if (runnableObject.getStatus() == RunnableObject.WAITING) { 
     addCurrentRemoveQueued(runnableObject); 
     new Thread(runnableObject).start(); 
     runnableObject.setStatus(RunnableObject.IN_PROGRESS); 
     } 
    } 
    } 

    /** 
    * Adds the runnableObject to the currentThreadsObjects and removes it from the queuedRunnableObjects 
    */ 
    private synchronized void addCurrentRemoveQueued(RunnableObject runnableObject) { 
    currentRunnableObjects.add(runnableObject); 
    queuedRunnableObjects.remove(runnableObject); 
    } 

    /** 
    * Checks whether the current and queued notification lists are empty. Returns true if they both are. 
    * 
    * @return 
    */ 
    private boolean isFinished() { 
    if (queuedRunnableObjects.isEmpty() && currentRunnableObjects.isEmpty()) { 
     return true; 
    } 
    return false; 
    } 
} 

Answer 1

您刚刚重塑了ThreadPoolExecutor！

由于您使用的是Java 7，所以使用新的fork join API会很诱人，但我非常确定，在您的情况下，ThreadPoolExecutor就是您所需要的。