blocks|key|3586981|text|你应该在一个单独的Thread中处理输入流--让它block等待输入。它在阻塞时不会使用任何资源。如果你在做这类事情时看到过多的资源使用，那你就做错了。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3586982|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html|1|http://docs.oracle.com/javase/1.4.2/docs/api/java/io/InputStream.html#read%2528%2529^0|9|6|0|P|5|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

You should be dealing with the input stream in a separate <a href="http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html" rel="nofollow">Thread</a> - and let it <a href="http://docs.oracle.com/javase/1.4.2/docs/api/java/io/InputStream.html#read%28%29" rel="nofollow">block</a> waiting for input. It will not use any resources while it blocks. If you're seeing excessive resource usage while doing this sort of thing, you're doing it wrong.

blocks|key|5088|text|我认为你可以把你的循环放在不同的线程中，让它休眠一段时间(也许半秒？)迭代之间。它仍然是一个无限循环，但它不会消耗几乎那么多的资源。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5089|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think you can just put your loop in a different thread and have it sleep a bit (maybe for half a second?) between iterations. It would still be an infinite loop, but it would not consume nearly as many resources.

blocks|key|3587047|text|有两种方法可以避免繁忙的循环/休眠。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3587048|3587049|为每个客户端连接使用一个线程，并简单地让每个线程调用read。这会阻塞线程，直到客户端发送一些数据，但这没有问题，因为它不会阻塞处理其他客户端的线程。|unordered-list-item|offset|length|style|CODE|3587050|使用Java+NIO通道选择器。它们允许线程等待，直到一组通道(在本例中为套接字)中的一个通道具有要读取的数据。Oracle+Java+Tutorials中有一节是关于这一点的。|3587051|3587052|在这两种方法中，第二种方法在总体资源使用方面是最有效的。(每客户端线程方法在线程堆栈上使用大量内存，在线程切换开销上使用CPU。)|3587053|3587054|重复调用(比方说)+InputStream.available()来查看是否有任何输入的繁忙循环效率非常低。您可以通过使用Thread.sleep(...)调用减慢轮询速度来降低它们的效率，但这也会降低服务的响应性。例如，如果在每组轮询之间添加1秒的休眠，则每个客户端将看到的效果是，服务器通常会在处理每个请求之前延迟1秒。假设这些请求是击键，并且响应响应它们，那么最终的结果是一个可怕的滞后服务。|3587055|entityMap|0|LINK|mutability|MUTABLE|url|http://www.java2s.com/Tutorial/Java/0320__Network/Channelselector.htm^0|0|0|Q|4|0|1K|L|0|0|0|0|0|A|N|1P|H|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|11|8|@$F|12|G|13|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|14|8|@]|9|@$F|15|G|16|1|17]]|A|$]]|$1|L|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1B|8|@$F|1C|G|1D|H|I]|$F|1E|G|1F|H|I]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]]]

There are two approaches that avoid busy loops / sleeps.

<ul>
<li>Use a thread for each client connection, and simply have each thread call <code>read</code>. This blocks the thread until the client sends some data, but that's no problem because it doesn't block the threads handling other clients.</li>
<li>Use Java NIO channel selectors. These allow a thread to wait until one of set of channels (in this case sockets) has data to be read. There is a section of the <a href="http://www.java2s.com/Tutorial/Java/0320__Network/Channelselector.htm" rel="nofollow">Oracle Java Tutorials</a> on this. </li>
</ul>

Of these two approaches, the second one is most efficient in terms of overall resource usage. (The thread-per-client approach uses a lot of memory on thread stacks, and CPU on thread switching overheads.)

<hr>

Busy loops that repeatedly call (say) <code>InputStream.available()</code> to see if there is any input are horribly inefficient. You can make them less inefficient by slowing down the polling with <code>Thread.sleep(...)</code> calls, but this has the side effect of making the service less responsive. For instance, if you add a 1 second sleep between each set of polls, the effect that each client will see is that the server typically delays 1 second before processing each request. Assuming that those requests are keystrokes and the responses echo them, the net result is a horribly laggy service.

blocks|key|5200563|text|您不需要稍微更改您的体系结构以适应WebSockets。查看Socket.IO。它是一个跨浏览器的WebSockets启用码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5200564|您必须编写控制器(例如，java中的servlet)来将数据推送到客户端。这不遵循请求-响应体系结构。|5200565|您还可以构建它，以便"push+servlet“触发来自客户端的”请求“以获得”响应“。|5200566|由于您的问题涉及到Java，如果您对WebSockets感兴趣，请查看此link。|5200567|entityMap|0|LINK|mutability|MUTABLE|url|http://socket.io/|1|http://jwebsocket.org/^0|H|A|U|9|0|0|0|0|10|4|1|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|12|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|13|8|@]|D|@$9|14|A|15|1|16]]|E|$]]|$1|L|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]|T|$5|O|P|Q|E|$R|U]]]]

You don't you change your architecture a little bit to accommodate <code>WebSockets</code>. check out <a href="http://socket.io/" rel="nofollow">Socket.IO</a> . It is a cross browser WebSockets enabler. 

You will have to write controllers (servlets for example in java) that push data to the client. This does not follow the request-response architecture. 

You can also architect it so that a "push servlet" triggers a "request" from the client to obtain the "response".

Since your question talks about Java, and if you are interested in WebSockets, check this <a href="http://jwebsocket.org/" rel="nofollow">link</a> out.

blocks|key|5200614|text|如果你正在使用Sockets，你应该在任何网络中使用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5200615|然后，您可以使用套接字的DataInputStream，它可以通过socket.getInputStream()获得(我认为这是正确的方法)，并执行以下操作：|5200616|public+DataInputStream+streamIn;
public+Socket+soc;

//+initialize+socket,+etc...
++++streamIn+=+soc.getInputStream();

public+String+getInput()+{
++++return+(String)+streamIn.readUTF();+//+Do+some+other+casting+if+this+doesn't+work
}|code-block|syntax|javascript|5200617|streamIn.readUTF()阻塞直到数据可用，这意味着您不必循环，线程将允许您在等待数据时执行其他处理。|5200618|有关DataInputStream的更多信息以及您可以使用它做什么，请查看此处：http://docs.oracle.com/javase/6/docs/api/java/io/DataInputStream.html|5200619|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/6/docs/api/java/io/DataInputStream.html^0|7|7|0|C|F|X|N|0|0|0|I|0|2|F|14|1X|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|Q|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

If you're using <code>Sockets</code>, which you should be for any networking.

Then you can use the socket's <code>DataInputStream</code> which you can get using <code>socket.getInputStream()</code> (i think that's the right method) and do the following:

<pre><code>public DataInputStream streamIn;
public Socket soc;

// initialize socket, etc...
 streamIn = soc.getInputStream();

public String getInput() {
 return (String) streamIn.readUTF(); // Do some other casting if this doesn't work
}
</code></pre>

<code>streamIn.readUTF()</code> blocks until data is available, meaning you don't have to loop, and threading will let you do other processing while you wait for data.

Look here for more information on <code>DataInputStream</code> and what you can do with it: <a href="http://docs.oracle.com/javase/6/docs/api/java/io/DataInputStream.html" rel="nofollow">http://docs.oracle.com/javase/6/docs/api/java/io/DataInputStream.html</a>

blocks|key|3587218|text|不需要线程的方法将涉及输入流的子类化和添加notify类型的方法。当被调用时，此方法将警告任何感兴趣的对象(即，由于添加到流中而必须更改状态的对象)已经进行了更改。然后，这些感兴趣的对象可以以所需的任何方式进行响应。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3587219|写入缓冲区的对象将执行其正常写入，然后将调用输入流上的notify()方法，将更改通知所有感兴趣的对象。|3587220|编辑:这可能需要创建多个类的子类化，因此可能涉及大量代码更改。如果不了解更多关于您的设计，您将不得不决定实现是否值得付出努力。|3587221|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

A method that does not require threads would involve subclassing the input stream and adding a notify type method. When called this method would alert any interested objects (i.e. objects that would have to change state due to the additions to the stream) that changes have been made. These interested objects could then respond in anyway that is desired. 

Objects writing to the buffer would do their normal writing, and afterward would call the notify() method on the input stream, informing all interested objects of the change.

Edit: This might require subclassing more than a couple of classes and so could involve a lot of code changes. Without knowing more about your design you would have to decide if the implementation is worth the effort.

Is there a way to immediately print the message received from the client without using an infinite loop to check whether the input stream is empty or not?
Because I found that using infinite loop consumes a lot of system resources, which makes the program running so slow. And we also have to do the same (infinite loop) on the client side to print the message on the screen in real time.
I'm using Java.

Chat system in Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

有没有一种方法可以立即打印从客户端接收到的消息，而不使用无限循环来检查输入流是否为空？因为我发现使用无限循环消耗了大量的系统资源，这使得程序运行起来非常慢。我们还必须在客户端执行相同的操作(无限循环)，以便在屏幕上实时打印消息。我使用的是Java。

问基于Java的聊天系统
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问基于Java的聊天系统EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问基于Java的聊天系统
EN