Java POJO：处理服务器请求对象队列的策略

Question

现在，我正在决定处理发送到服务器的请求对象的最佳方式。换句话说，我在我的应用程序中具有跟踪请求对象，例如印象和点击跟踪。负载非常低的简单请求。在我的应用程序中的某些地方，需要跟踪的所述对象同时出现在彼此旁边（我必须跟踪最多三个并发对象），因此每次所述对象可见时，我都必须创建一个跟踪请求他们每个人的对象。

现在我已经知道我可以轻松创建一个单例队列线程，它将这些对象添加到向量中，并且我的线程要么在主循环中处理它们，要么在队列上调用等待，直到我们有对象要处理。虽然这听起来像是一个明确的解决方案，但队列可能会累积到数十个，这有时会很麻烦，因为它为每个请求建立一个连接，因此它不会同时运行。

我的想法是创建一个线程池，它允许我通过信号量创建两个并发连接，并处理包含跟踪事件请求的线程对象。换句话说，我想创建一个函数来创建一个新的线程对象并将其添加到 Vector 中，其中线程池将迭代线程集并一次处理两个线程。我知道我可以创建一个函数来添加对象，如下所示：

public boolean addThread(Runnable r){
synchronized(_queue){
    while(!dead){
       _queue.addElement(r);
       //TODO: How would I notify my thread pool object to iterate through the list to process the queue? Do I call notify on the queue object, but that would only work on a thread right??
       return true
    }
    return false;
}

我想知道线程本身将如何执行。如何编写一个在将线程添加到列表后执行线程池的函数？另外，由于信号量将在第二次连接后阻塞，因此会锁定我的应用程序直到有一个开放插槽，还是会在循环列表时锁定在线程池对象中？

与往常一样，由于我的目标是 J2ME/Blackberry 环境，因此仅接受 1.5 之前的答案，因此 Concurrent 包中没有泛型或任何类。

编辑：所以我认为这或多或少应该是这样的：

class MyThreadPool extends Thread{

  private final Vector _queue = new Vector();
  private CappedSemaphore _sem;
  public MyWaitingThread (){
      _sem = new CappedSemaphore(2);
      this.start();
  }
  public void run(){
     while(!dead){
        Runnable r = null;
        synchronized(_queue){
          if(_queue.isEmpty()){
            _queue.wait();
          } else {
            r = _queue.elementAt(0);
            _queue.removeElement(0);
          }
       }
       if(r != null){
          _sem.take();
          r.run();
          _sem.release();
       }
    }
 }
 public boolean addThread(Runnable r){
   synchronized(_queue){
   if(!dead){
     _queue.addElement(r);
     _queue.notifyAll();
     return true
   }
   return false;
 }
}

Answer 1

您想要做的，是在线程侧让每个线程在队列中等待。例如

class MyWaitingThread extends Thread{

   private final Queue _queue;
   public MyWaitingThread (Queue _queue){
      this._queue = _queue;
   }
   public void run(){
      while(true){
       Runnable r = null;
       synchronized(_queue){
            if(_queue.isEmpty())
                _queue.wait();
            else
               r = queue.pop();
        }
      if(r != null) r.run();
      }
   }
}

，在您的其他逻辑中，它看起来像：

public void addThread(Runnable r){
     if(!dead){
       synchronized(_queue){
         _queue.addElement(r);
         _queue.notifyAll();
       }
     }
}

_queue.notifyAll 将唤醒在 _queue 实例上等待的所有线程。另外，请注意，我将 while(!dead) 移到了同步块之外，并将其更改为 if(!dead)。我可以想象保持它原来的方式它不会像你希望的那样工作。