Java 如何使向量同步，使两个线程中只有一个线程可以访问它

在我的程序中有两个类A和B，它们都扩展了线程，现在B有一个名为CommandQueue的队列。现在，线程B访问它，直到它变为空，并且每当发现要插入的新命令时，类A线程就会访问它。如何使此队列同步，使两个线程都无法访问它，并且当一个线程使用了此队列时，可以让另一个线程自由使用它。另外，如果我不使其同步，请建议是否不会有任何问题。

不清楚代码是使用向量还是队列。如果它的向量总是同步的，那么这个问题与生产者-消费者问题非常相似。如果您仔细研究代码是否使用向量或队列，可能会有所帮助。如果它的向量总是同步的，那么这个问题与生产者-消费者问题非常相似。如果你研究一下，

似乎你需要一个向量而不是普通向量，这可能会有所帮助

public void synchronized Producer(Object whatever) {
    // Insert into the Queue here
     Queue.add(whatever);
}

public Object synchronized Consumer() {
    // Get Values out of the Queue here
    Queue.remove(whatever);
}

BlockingQueue.put（E）：将指定的元素插入该队列，如果需要，等待空间变为可用

BlockingQueue.take（）：检索并删除此队列的头，如有必要，等待元素可用

似乎您需要一个而不是纯向量

BlockingQueue.put（E）：将指定的元素插入该队列，如果需要，等待空间变为可用

---

BlockingQueue.take（）：检索并删除此队列的头，如有必要，等待元素可用

您可以使用：ConcurrentLinkedQueue或具有等待/通知功能的其他集合

I.ConcurrentLinkedQueue

  ConcurrentLinkedQueue<Object> myQueue = new ConcurrentLinkedQueue<Object>();

  ...
  // first thread
  myQueue.add(someObject);

  ...
  // seconds thread
  Object someObject = myQueue.poll()

ConcurrentLinkedQueue myQueue=新建ConcurrentLinkedQueue（）；
...
//第一根线
添加（someObject）；
...
//秒线程
Object someObject=myQueue.poll（）

二,。等待/通知

代码只是一个例子。您需要处理异常并阅读有关线程唤醒问题的信息

  ArrayList<Object> objects = new ArrayList<Object>();

  ...    
  // first thread
  synchronized(objects) {
      objects.add(someObject);
      objects.notifyAll();
  }

  ...
  // second thread
  synchronized(objects) {
      objects.wait();
      for (Object someObject: objects) {
          // do something with someObject
      }
  }

ArrayList objects=new ArrayList（）；
...    
//第一根线
已同步（对象）{
对象。添加（someObject）；
notifyAll（）；
}
...
//第二线
已同步（对象）{
对象。wait（）；
对于（对象someObject:对象）{
//用某物做某事
}
}

您可以使用：ConcurrentLinkedQueue或具有等待/通知功能的其他集合

I.ConcurrentLinkedQueue

  ConcurrentLinkedQueue<Object> myQueue = new ConcurrentLinkedQueue<Object>();

  ...
  // first thread
  myQueue.add(someObject);

  ...
  // seconds thread
  Object someObject = myQueue.poll()

ConcurrentLinkedQueue myQueue=新建ConcurrentLinkedQueue（）；
...
//第一根线
添加（someObject）；
...
//秒线程
Object someObject=myQueue.poll（）

二,。等待/通知

代码只是一个例子。您需要处理异常并阅读有关线程唤醒问题的信息

  ArrayList<Object> objects = new ArrayList<Object>();

  ...    
  // first thread
  synchronized(objects) {
      objects.add(someObject);
      objects.notifyAll();
  }

  ...
  // second thread
  synchronized(objects) {
      objects.wait();
      for (Object someObject: objects) {
          // do something with someObject
      }
  }

ArrayList objects=new ArrayList（）；
...    
//第一根线
已同步（对象）{
对象。添加（someObject）；
notifyAll（）；
}
...
//第二线
已同步（对象）{
对象。wait（）；
对于（对象someObject:对象）{
//用某物做某事
}
}

只需通过添加“synchronized”来同步线程即可

---

只要在需要的地方调用函数，一切都会正常运行并“完全同步”：）

只要通过添加“已同步”来同步线程即可

---

只要在需要的地方调用函数，一切都会正常运行并“完全同步”：

每当您想同时使用线程和队列执行工作时，ExecutorService很可能是最佳选择。这是因为它们被设计来概括这两个概念

ExecutorService es = Executors.new (pick a thread pool of your choice)

// in thread A
es.execute(new Runnable() {
   public void run() {
      // task to run on Thread B
   }
});

// in thread A
Future<Type> future = es.submit(new Callable<Type>() {
   public Type call() {
      // task to run on Thread B and ...
      return type;
   }
});

// later get the result
Type t = future.get();

Executors-service=Executors.new（选择一个线程池）
//在线程A中
执行（新的Runnable（）{
公开募捐{
//要在线程B上运行的任务
}
});
//在线程A中
Future=es.submit（new Callable（））{
公共类型调用（）{
//要在线程B上运行的任务，并且。。。
返回类型；
}
});
//以后得到结果
类型t=future.get（）；

---

注意：您不必直接引用队列或线程池，只需说明您希望它做什么。

每当您希望同时使用线程和队列来执行工作时，ExecutorService很可能是最佳选择。这是因为它们被设计来概括这两个概念

ExecutorService es = Executors.new (pick a thread pool of your choice)

// in thread A
es.execute(new Runnable() {
   public void run() {
      // task to run on Thread B
   }
});

// in thread A
Future<Type> future = es.submit(new Callable<Type>() {
   public Type call() {
      // task to run on Thread B and ...
      return type;
   }
});

// later get the result
Type t = future.get();

Executors-service=Executors.new（选择一个线程池）
//在线程A中
执行（新的Runnable（）{
公开募捐{
//要在线程B上运行的任务
}
});
//在线程A中
Future=es.submit（new Callable（））{
公共类型调用（）{
//要在线程B上运行的任务，并且。。。
返回类型；
}
});
//以后得到结果
类型t=future.get（）；

---

注意：您不必直接引用队列或线程池，只需说出您希望它做什么。

您在问题标题中提到了Vector。向量已经同步了。实际上，我希望按照顺序，线程A在数据结构中插入命令（向量或任何其他），线程B也应该按照该顺序访问它，并像队列一样删除它。直接扩展线程通常被认为是不好的做法。您应该实现Runnable并用线程包装它。您在问题标题中提到了Vector。向量已经同步了。实际上，我希望按照顺序，线程A在数据结构中插入命令（向量或任何其他），线程B也应该按照该顺序访问它，并像队列一样删除它。直接扩展线程通常被认为是不好的做法。你应该实现Runnable并用一个线程包装它。那么这是否意味着如果两个不同类的不同线程将访问同一个向量对象，那么因为向量是同步的，所以它不会产生问题？那么这是否意味着如果两个不同类的不同线程将访问同一个向量对象呢