我从SO那里找到了这个例子。现在，我试图了解wait()和notify()/notifyAll()的用法。在哪种情况下，为什么我们需要这个。
class BlockingQueue<T> {
private Queue<T> queue = new LinkedList<T>();
private int capacity;
public BlockingQueue(int capacity) {
this.capacity = capacity;
}
public synchronized void put(T element) throws InterruptedException {
while (queue.size() == capacity) {
System.out.println("Waiting...");
wait();
}
queue.add(element);
notify(); // notifyAll() for multiple producer/consumer threads
}
public synchronized T take() throws InterruptedException {
while (queue.isEmpty()) {
wait();
}
T item = queue.remove();
notify(); // notifyAll() for multiple producer/consumer threads
return item;
}
}
因此，实施了Runnable并覆盖run()方法，如下所示
@Override
public void run() {
// synchronized (this) {
BlockingQueue<Integer> s = new BlockingQueue(10);
for (int i = 0; i < 12; i++) {
try {
s.put(i);
if (i > 9) {
System.out.println(Thread.currentThread().getName() + " : " + s.take());
}
System.out.println(Thread.currentThread().getName() + " ExtendsThread : Counter : " + i);
} //}
//notify();
catch (InterruptedException ex) {
Logger.getLogger(ExtendsThread.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
并且，运行如下的线程
ImplementsRunnable rc = new ImplementsRunnable();
Thread t1 = new Thread(rc, "A");
t1.start();
当我运行它时，它会在counter : 9之后卡住并继续等待。有谁建议我这里有什么问题？
答案 0 :(得分：2)
你的概念有点缺陷。 BlockingQueue可以作为生产者/消费者模式中的桥梁。
也就是说，它允许一个线程向其中写入内容，另一个线程从中读取内容，但它正在这样做，如果：
在这种情况下，wait和notify是BlockingQueue
您可以查看Intrinsic Locks and Synchronization。
所以，不要只使用一个线程，而应该使用（至少）两个，一个产品和一个消费者......
这会获取BlockingQueue的实例，并为其添加int个值。每次停止1秒后再添加下一个
public class Producer implements Runnable {
private BlockingQueue<Integer> queue;
public Producer(BlockingQueue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
for (int index = 0; index < 10; index++) {
try {
System.out.println("Put " + index);
queue.put(index);
Thread.sleep(1000);
} catch (InterruptedException ex) {
}
}
}
}
消费者获取BlockQueue并从中读取int值，这些值会被阻止，直到存在值。
public class Consumer implements Runnable {
private BlockingQueue<Integer> queue;
public Consumer(BlockingQueue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
try {
while (true) {
Integer value = queue.take();
System.out.println("Took " + value);
}
} catch (InterruptedException ex) {
Logger.getLogger(JavaApplication220.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
你可以使用像...这样的东西开始。
BlockingQueue bq = new BlockingQueue(10);
Thread p = new Thread(new Producer(bq));
Thread c = new Thread(new Consumer(bq));
c.setDaemon(true);
c.start();
p.start();
您应该注意put消息之间有一个小延迟，但took消息之间几乎没有延迟。这是队列在起作用。 Consumer阻塞/等待队列有一些东西给它。
您可以使用Producer和Consumer，也许可以改变他们的时间（例如在Consumer之前延迟更长时间），看看这可能会导致不同的影响
当我运行它时，它会在计数器后停留：9并继续等待
这很可能是因为你已经超出了队列的容量而且它的put方法阻塞了，直到你从中取出一些东西（你基本上有一个死锁，队列在等着你拿东西从它，但你不能，因为你被锁定在put）
要记住的事情：
BlockingQueue notify将唤醒一个正在等待监视器锁的wait方法的同一实例的对象。没有办法知道哪一个。如果您有多个使用者，但不关心处理数据的顺序，这可能很有用，例如更新了其他示例
因此，这会从Thread.sleep中取出Producer（并允许生产者生成100个值）并向Thread.sleep添加Consumer。
这样，Producer会在Consumer消耗它之前达到它的容量，迫使它等到Consumer可以从中获取值...
public class Producer implements Runnable {
private BlockingQueue<Integer> queue;
public Producer(BlockingQueue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
for (int index = 0; index < 100; index++) {
try {
System.out.println("Put " + index);
queue.put(index);
} catch (InterruptedException ex) {
}
}
}
}
public class Consumer implements Runnable {
private BlockingQueue<Integer> queue;
public Consumer(BlockingQueue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
try {
while (true) {
Integer value = queue.take();
System.out.println("Took " + value);
Thread.sleep(1000);
}
} catch (InterruptedException ex) {
}
}
}
答案 1 :(得分：1)
在这里添加printlns
public synchronized void put(T element) throws InterruptedException {
while (queue.size() == capacity) {
System.out.println("blocked");
wait();
}
queue.add(element);
notify(); // notifyAll() for multiple producer/consumer threads
System.out.println("put "+ element);
}
public synchronized T take() throws InterruptedException {
while (queue.isEmpty()) {
wait();
}
T item = queue.remove();
notify(); // notifyAll() for multiple producer/consumer threads
System.out.println("removed " + item);
return item;
}
并运行此测试
public static void main(String argv[]) throws Exception {
final BlockingQueue q = new BlockingQueue(2);
new Thread() {
public void run() {
try {
Thread.sleep(5000);
q.take();
} catch (Exception e) {
e.printStackTrace();
}
};
}.start();
q.put(1);
q.put(2); // will block here until tread 2 takes an element and reduces the capacity
q.put(3);
}
它会打印
put 1
put 2
blocked
removed 1
put 3