Java 如何暂停线程直到处理数据？发送信号灯？

此方法的功能与预期相同，因为它一次只能从服务器获取一个对象，处理该对象，然后获取另一个对象。然而，我似乎需要，似乎，把它翻过来，可能与生产者消费者：

    public void inputOutput() throws IOException, ClassNotFoundException {
        Socket socket = new Socket(server, portNumber);
        boolean eof = false;
        Title title = null;
        State state = State.undefined;
        try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream())) {
            do {
                try {
                    title = (Title) objectInputStream.readObject();
                    log.info(title.toString());
                    do {
                        state = State.undefined;
                        try {
                            c.printf("enter the state for record:");
                            state = State.valueOf(c.readLine());
                        } catch (java.lang.IllegalArgumentException iae) {
                            log.warning(Arrays.deepToString(State.values()));
                        }
                    } while (state == State.undefined);
                    title.setState(state);
                    title.setTitle("modified from client");
                    objectOutputStream.writeObject(title);
                } catch (java.io.EOFException eofe) {
                    eof = true;
                }
            } while (!eof);
        }
    }

处理一个对象，然后将其发送回，然后请求另一个对象的“流”正是我想要复制的：

package net.bounceme.dur.client;

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {

    private final BlockingQueue<Message> queue;

    public Producer(BlockingQueue<Message> q) {
        this.queue = q;
    }

    @Override
    public void run() {
        //produce messages
        for (int i = 0; i < 100; i++) {
            Message msg = new Message("" + i);
            try {
                Thread.sleep(i);
                queue.put(msg);
                System.out.println("Produced " + msg.getMsg());
            } catch (InterruptedException e) {
            }
        }
        //adding exit message
        Message msg = new Message("exit");
        try {
            queue.put(msg);
        } catch (InterruptedException e) {
        }
    }

}

package net.bounceme.dur.client；
导入java.util.concurrent.BlockingQueue；
公共类生产者实现Runnable{
私有最终阻塞队列；
公共制作人（封锁队列q）{
这个.queue=q；
}
@凌驾
公开募捐{
//产生信息
对于（int i=0；i<100；i++）{
消息消息消息=新消息（“+i”）；
试一试{
睡眠（i）；
queue.put（msg）；
System.out.println（“producted”+msg.getMsg（））；
}捕捉（中断异常e）{
}
}
//添加退出消息
消息消息消息=新消息（“退出”）；
试一试{
queue.put（msg）；
}捕捉（中断异常e）{
}
}
}

Producer

是否只处理通过

objectInputStream.readObject（）从套接字连接获取对象的问题

如果是这样，我如何减慢生产者（从某个角度来看，生产者也是消费者）的速度，使其一次只“生产”一个对象，等待通知，然后仅在收到通知后，返回流以获取另一个对象

从客户的上下文来看，这是一个生产者，但从更广泛的角度来看，我认为它也是一个消费者

生产者如何接收信号量或其他通知，然后“产生”另一个对象

因为Producer实现了Runnable，所以我无法将参数传递到run。ProducerConsumerService驱动程序是否可以暂停线程？至少，这似乎容易出错

代码借用自：


不需要明确的答案——我可能只是误解了如何使用带套接字的BlockingQueue。目前，我希望保持服务器不变，以便其发送对象然后等待响应的响应/请求“流”保持不变。
一个解决方案是使用大小为1的
ArrayBlockingQueue
。生产者一次只能将一个对象放入其中，并等待消费者将其移除

所以伪代码应该是

// Producer thread (produces serverside data)
obj = readObjFromServer();
sharedQueue.put(obj);  // Blocks if there is already an object waiting

// Consumer thread
obj = sharedQueue.take(); // Blocks until data available
handleData(obj);

我喜欢这样。那么，在消费者移除对象之前，生产者（上图）只是“挂起”？听起来不错！：）是的，如果队列已满（用于插入）或为空（用于检索），则操作块将被阻塞。