Question

我正在使用tomcat来提供我的应用程序，并使用 ab 来测试响应时间。

这是servlet中的核心逻辑：

    long st = System.currentTimeMillis();
    data = server.getData(req);  //
    System.out.println("get data cost:" + (System.currentTimeMillis() - st));

    st = System.currentTimeMillis();
    if (data != null) {
        try {
            OutputStream out = resp.getOutputStream();
            data.save(out);
            out.flush();
            System.out.println("save data cost:" + (System.currentTimeMillis() - st));
        } catch (IOException e) {
            status = 500;
        }
    }

@Override
public IData getData(HttpServletRequest req) {
    String layers = req.getParameter("layers");
    String id = req.getParameter("id");
    ArrayList<BufferedImage> result = new ArrayList<BufferedImage>();
    for (String layer : layers) {
        String lkey = layer+"-"+id;
        BufferedImage cachedImage = null;
        if (cacher.contains(lkey)) {
            cachedImage = (BufferedImage) cacher.get(lkey);
        } else {
            cachedImage =...  // heavy operation which will cost 1s for a single request
        }

        if (cachedImage != null) {
            result.add(cachedImage);
        }

    }
    return new Data(result);
}

class Data implements IData {
    private BufferedImage imageResult;

    public Data(ArrayList<BufferedImage> data) {
        imageResult = new BufferedImage(500 ,500 , BufferedImage.TYPE_INT_ARGB);
        Graphics2D g = imageResult.createGraphics();
        for (BufferedImage img : data) {
            g.drawImage(img, 0, 0, null);
        }
        g.dispose();
    }

    @Override
    public void save(OutputStream out, String format) throws IOException {
        PngEncoder encoder = new PngEncoder(PngEncoder.COLOR_TRUECOLOR_ALPHA);
        encoder.encode(imageResult, out);
        imageResult = null;
    }
}

如图所示，

测试用例（我使用缓存来处理请求的数据，我在测试之前运行了一次url，因此我确信在以下测试用例期间从缓存中检索了所有数据）：

与ab：ab -n 1 -c 1 ...

响应时间：80毫秒

并记录：

get data cost:11
save data cost:68

使用：ab -n 10 -c 10 ...

  50%    206
  66%    212
  75%    225
  80%    228
  90%    244
  95%    244
  98%    244
  99%    244
 100%    244 (longest request)

并记录：

http://paste.ubuntu.com/7758426/

with：ab -n 100 -c 100 ..

  50%   2412
  66%   2414
  75%   2415
  80%   2415
  90%   2418
  95%   2418
  98%   2426
  99%   2433
 100%   2433 (longest request)

并记录：

http://paste.ubuntu.com/7758421/

IMO，保存数据所需的时间应取决于所做的事情。在该示例中，保存操作仅需要70毫秒。为什么在处理100个并发用户时增长如此之快？

这是正常的吗？

如果是，是否有办法缩短响应时间？

如果不是，我可能会遗漏一些东西，我该如何解决？

更新（整个逻辑）：

我正在提供谷歌地图等地图图块，图块位于（x，y和缩放）坐标。同时地图可能包含多个图层，例如道路，水，土地等。我们在应用程序中提供50多个图层。

例如，用户可以通过简单的请求从我们的服务器获取切片：

http://localhost/tile/z/x/y.png?layer=road,water

这将返回仅包含road和water图层的图块（图片）。

或

http://localhost/tile/z/x/y.png?layer=road,water,landuse,poi

这将返回包含road，water，landuse和poi图层的图块（图片）。

如图所示，我们总共有50多个图层，所以有很多＆＃34;排列和组合＆＃34;，所以我们必须动态生成图块。

但创建一个tile是一个时间cousuming工作，所以我们在这里使用缓存。以请求http://localhost/tile/z/x/y.png?layer=road,water为例，我们将检查给定层的给定（x，y，缩放）处的tile（BufferedImage）是否存在，如果不存在，则创建它并将其放入缓存中。

ArrayList<BufferedImage> combined=new ArrayList<BufferedImage>();
for(String layer : requset.getParameter("layer")){
    String cacheKey = x+"-"+y+"-"+"+zoom+"-"+layer;
    BufferedImage image = cache.get(cacheKey);
    if(image ==nul){
        //generate it dynamically

        //put it to cache
        cache.add(cacheKey,image)
    }   
    combined.add(image)
}

然后我们将合并后的图像写入客户端（Data.save做什么）。

这就是整个逻辑，如果不清楚，请告诉我。

Answer 1

答案取决于您的线程是阻塞还是非阻塞，以及您在计算机上可以实现的并行度。

但是，您在问题中报告的时间似乎表明您的请求只是一个接一个地排队，而不是完全并行提供。

这可能发生，因为您有10个内核，因此您只能真正同时处理10个请求。除非你分发更多的机器或获得更强大的CPU，否则你无法做到这一点。

也可能发生这种情况，因为您的data.save()是一个需要锁定共享资源的操作，因此锁定会导致您的工作被序列化。如果是这种情况，您可以尝试通过使每个线程状态仅偶尔同步（比如每10000个请求）来减少同步。

在任何一种情况下，您的响应时间（延迟）完全取决于您的吞吐量，而不是处理一个请求所需的时间，正如您在无负载时所期望的那样。

Answer 2

将VisualVM附加到Tomcat。您将能够看到问题是它是使用CPU还是线程外。现在，看到PNG代码，我的猜测是图形操作花费时间，但这只是一个猜测。分析将给你一个真正的答案。

在不同的并发请求下，相同逻辑的响应时间快速增长

2 个答案: