0

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

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

我的想法是创建一个线程池，它允许我通过信号量创建两个并发连接并处理包含我的跟踪事件请求的线程对象。换句话说，我想创建一个函数来创建一个新的线程对象并将其添加到 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;
 }
}
4

1 回答 1

-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). 我可以想象保持原来的方式它不会像你希望的那样工作。

于 2011-04-11T23:26:34.250 回答