问题描述
Servlet-3.0 API 允许分离请求/响应上下文并在稍后回复它。
但是，如果我尝试编写大量数据，例如：
AsyncContext ac = getWaitingContext() ;
ServletOutputStream out = ac.getResponse().getOutputStream();
out.print(some_big_data);
out.flush()
对于 Tomcat 7 和 Jetty 8，它实际上可能会阻塞——而且它确实会阻塞在琐碎的测试用例中。教程建议创建一个可以处理这种设置的线程池——这通常与传统的 10K 架构相反。
但是，如果我有 10,000 个打开的连接和一个线程池，比如说 10 个线程，那么即使 1% 的客户端具有低速连接或只是阻塞连接，也足以阻塞线程池并完全阻塞彗星响应或减慢它显著地。
预期的做法是获得“写就绪”通知或 I/O 完成通知，然后继续推送数据。
如何使用 Servlet-3.0 API 来完成，即我如何获得：
- I/O 操作的异步完成通知。
- 通过写就绪通知获取非阻塞 I/O。
如果 Servlet-3.0 API 不支持，是否有任何 Web 服务器特定的 API（如 Jetty Continuation 或 Tomcat CometEvent）允许真正异步处理此类事件，而无需使用线程池伪造异步 I/O。
有人知道吗？
如果这不可能，您可以参考文档来确认吗？
示例代码中的问题演示
我附上了下面模拟事件流的代码。
笔记：
- 它使用
ServletOutputStream该 throwsIOException来检测断开连接的客户端 - 它发送
keep-alive消息以确保客户端仍然存在 - 我创建了一个线程池来“模拟”异步操作。
在这样的示例中，我明确定义了大小为 1 的线程池来显示问题：
- 启动应用程序
- 从两个终端运行
curl http://localhost:8080/path/to/app（两次） - 现在发送数据
curd -d m=message http://localhost:8080/path/to/app - 两个客户端都收到了数据
- 现在暂停其中一个客户端 (Ctrl+Z) 并再次发送消息
curd -d m=message http://localhost:8080/path/to/app - 观察到另一个未挂起的客户端要么什么也没收到，要么在传输消息后停止接收保持活动的请求，因为其他线程被阻塞了。
我想在不使用线程池的情况下解决这样的问题，因为使用 1000-5000 个打开的连接我可以非常快地耗尽线程池。
下面的示例代码。
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.LinkedBlockingQueue;
import javax.servlet.AsyncContext;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletOutputStream;
@WebServlet(urlPatterns = "", asyncSupported = true)
public class HugeStreamWithThreads extends HttpServlet {
private long id = 0;
private String message = "";
private final ThreadPoolExecutor pool =
new ThreadPoolExecutor(1, 1, 50000L,TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
// it is explicitly small for demonstration purpose
private final Thread timer = new Thread(new Runnable() {
public void run()
{
try {
while(true) {
Thread.sleep(1000);
sendKeepAlive();
}
}
catch(InterruptedException e) {
// exit
}
}
});
class RunJob implements Runnable {
volatile long lastUpdate = System.nanoTime();
long id = 0;
AsyncContext ac;
RunJob(AsyncContext ac)
{
this.ac = ac;
}
public void keepAlive()
{
if(System.nanoTime() - lastUpdate > 1000000000L)
pool.submit(this);
}
String formatMessage(String msg)
{
StringBuilder sb = new StringBuilder();
sb.append("id");
sb.append(id);
for(int i=0;i<100000;i++) {
sb.append("data:");
sb.append(msg);
sb.append("\n");
}
sb.append("\n");
return sb.toString();
}
public void run()
{
String message = null;
synchronized(HugeStreamWithThreads.this) {
if(this.id != HugeStreamWithThreads.this.id) {
this.id = HugeStreamWithThreads.this.id;
message = HugeStreamWithThreads.this.message;
}
}
if(message == null)
message = ":keep-alive\n\n";
else
message = formatMessage(message);
if(!sendMessage(message))
return;
boolean once_again = false;
synchronized(HugeStreamWithThreads.this) {
if(this.id != HugeStreamWithThreads.this.id)
once_again = true;
}
if(once_again)
pool.submit(this);
}
boolean sendMessage(String message)
{
try {
ServletOutputStream out = ac.getResponse().getOutputStream();
out.print(message);
out.flush();
lastUpdate = System.nanoTime();
return true;
}
catch(IOException e) {
ac.complete();
removeContext(this);
return false;
}
}
};
private HashSet<RunJob> asyncContexts = new HashSet<RunJob>();
@Override
public void init(ServletConfig config) throws ServletException
{
super.init(config);
timer.start();
}
@Override
public void destroy()
{
for(;;){
try {
timer.interrupt();
timer.join();
break;
}
catch(InterruptedException e) {
continue;
}
}
pool.shutdown();
super.destroy();
}
protected synchronized void removeContext(RunJob ac)
{
asyncContexts.remove(ac);
}
// GET method is used to establish a stream connection
@Override
protected synchronized void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Content-Type header
response.setContentType("text/event-stream");
response.setCharacterEncoding("utf-8");
// Access-Control-Allow-Origin header
response.setHeader("Access-Control-Allow-Origin", "*");
final AsyncContext ac = request.startAsync();
ac.setTimeout(0);
RunJob job = new RunJob(ac);
asyncContexts.add(job);
if(id!=0) {
pool.submit(job);
}
}
private synchronized void sendKeepAlive()
{
for(RunJob job : asyncContexts) {
job.keepAlive();
}
}
// POST method is used to communicate with the server
@Override
protected synchronized void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
request.setCharacterEncoding("utf-8");
id++;
message = request.getParameter("m");
for(RunJob job : asyncContexts) {
pool.submit(job);
}
}
}
上面的示例使用线程来防止阻塞......但是，如果阻塞客户端的数量大于线程池的大小，它将阻塞。
如何在没有阻塞的情况下实现它？