首页 文章

从urlconnection的输入流读取时减速(即使使用byte []和缓冲区)

提问于
浏览
2

好了,在花了两天时间试图找出问题并阅读了大量文章之后,我终于决定提出建议并要求提供一些建议(我第一次来这里) .

现在谈到手头的问题 - 我正在编写一个程序来解析游戏中的api数据,即战斗日志 . 数据库中将有大量条目(2000万),因此每个战斗日志页面的解析速度非常重要 .

要解析的页面如下所示:http://api.erepublik.com/v1/feeds/battle_logs/10000/0.(如果使用chrome,请参阅源代码,它不会向右显示页面) . 它有1000个命中条目,然后是一个小的战斗信息(最后页面显然<1000) . 平均而言,页面包含175000个字符,UTF-8编码,xml格式(v 1.0) . 程序将在一台优秀的PC上本地运行,内存实际上是无限的(因此创建字节[250000]是相当不错的) .

格式永远不会改变,这非常方便 .

现在,我像往常一样开始:

//global vars,class declaration skipped

    public WebObject(String url_string, int connection_timeout, int read_timeout, boolean redirects_allowed, String user_agent)
                    throws java.net.MalformedURLException, java.io.IOException {
                // Open a URL connection
                java.net.URL url = new java.net.URL(url_string);
                java.net.URLConnection uconn = url.openConnection();
                if (!(uconn instanceof java.net.HttpURLConnection)) {
                    throw new java.lang.IllegalArgumentException("URL protocol must be HTTP");
                }
                conn = (java.net.HttpURLConnection) uconn;
                conn.setConnectTimeout(connection_timeout);   
                conn.setReadTimeout(read_timeout);      
                conn.setInstanceFollowRedirects(redirects_allowed);
                conn.setRequestProperty("User-agent", user_agent);
            }
     public void executeConnection() throws IOException {
            try {
                is = conn.getInputStream(); //global var
                l = conn.getContentLength(); //global var         
            } catch (Exception e) {
            //handling code skipped
            }
    }

//getContentStream and getLength methods which just return'is' and 'l' are skipped

这是有趣的部分开始的地方 . 我运行了一些分析(使用System.currentTimeMillis())来找出需要很长时间的内容,以及什么不需要 . 对此方法的调用平均只需200ms

public InputStream getWebPageAsStream(int battle_id, int page) throws Exception {
    String url = "http://api.erepublik.com/v1/feeds/battle_logs/" + battle_id + "/" + page;
    WebObject wobj = new WebObject(url, 10000, 10000, true, "Mozilla/5.0 "
            + "(Windows; U; Windows NT 5.1; en-US; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 ( .NET CLR 3.5.30729)");
    wobj.executeConnection();
    l = wobj.getContentLength(); // global variable
    return wobj.getContentStream(); //returns 'is' stream
}

从网络操作中可以预期200毫秒,我很好 . 但是当我以任何方式解析inputStream(将其读入字符串/使用java XML解析器/将其读入另一个ByteArrayStream)时,该过程需要超过1000毫秒!

例如,如果我将getContentStream()上面的流('is')直接传递给此方法,则此代码需要1000毫秒 .

public static Document convertToXML(InputStream is) throws ParserConfigurationException, IOException, SAXException {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder db = dbf.newDocumentBuilder();
        Document doc = db.parse(is);
        doc.getDocumentElement().normalize();
        return doc;
    }

如果传入初始的InputStream'是',这个代码也需要大约920ms(不要读入代码本身 - 它只是通过直接计算字符来提取我需要的数据,这可以通过严格的api feed格式来完成) :

public static parsedBattlePage convertBattleToXMLWithoutDOM(InputStream is) throws IOException {
        // Point A
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        LinkedList ll = new LinkedList();
        String str = br.readLine();
        while (str != null) {
            ll.add(str);
            str = br.readLine();
        }           
        if (((String) ll.get(1)).indexOf("error") != -1) {
            return new parsedBattlePage(null, null, true, -1);
        }
        //Point B
        Iterator it = ll.iterator();
        it.next();
        it.next();       
        it.next();
        it.next();
        String[][] hits_arr = new String[1000][4];
        String t_str = (String) it.next();
        String tmp = null;
        int j = 0;
        for (int i = 0; t_str.indexOf("time") != -1; i++) {
            hits_arr[i][0] = t_str.substring(12, t_str.length() - 11);
            tmp = (String) it.next();
            hits_arr[i][1] = tmp.substring(14, tmp.length() - 9);
            tmp = (String) it.next();
            hits_arr[i][2] = tmp.substring(15, tmp.length() - 10);
            tmp = (String) it.next();
            hits_arr[i][3] = tmp.substring(18, tmp.length() - 13);
            it.next();
            it.next();
            t_str = (String) it.next();
            j++;
        }      
        String[] b_info_arr = new String[9];
        int[] space_nums = {13, 10, 13, 11, 11, 12, 5, 10, 13};
        for (int i = 0; i < space_nums.length; i++) {
            tmp = (String) it.next();
            b_info_arr[i] = tmp.substring(space_nums[i] + 4, tmp.length() - space_nums[i] - 1);
        }
        //Point C
        return new parsedBattlePage(hits_arr, b_info_arr, false, j);
    }

我试过替换默认的BufferedReader

BufferedReader br = new BufferedReader(new InputStreamReader(is), 250000);

这没什么变化 . 我的第二次尝试是用以下代码替换A和B之间的代码:Iterator it = IOUtils.lineIterator(is,“UTF-8”);

同样的结果,除了这次A-B是0ms,而B-C是1000ms,所以每次调用it.next()都必须消耗一些重要的时间 . (IOUtils来自apache-commons-io库) .

这是罪魁祸首 - 将流解析为字符串所花费的时间,无论是通过迭代器还是BufferedReader在所有情况下都是大约1000毫秒,而其余的代码花了0毫秒(例如不相关) . 这意味着由于某种原因将流解析为LinkedList或迭代它会占用大量的系统资源 . 问题是 - 为什么?它只是java的制作方式......不......那只是愚蠢的,所以我做了另一个实验 .

在我的main方法中,我在getWebPageAsStream()之后添加:

//Point A
    ba = new byte[l]; // 'l'  comes from wobj.getContentLength above
    bytesRead = is.read(ba); //'is' is our URLConnection original InputStream 
    offset = bytesRead;           
    while (bytesRead != -1) {
        bytesRead = is.read(ba, offset - 1, l - offset);
        offset += bytesRead;
    }
    //Point B
    InputStream is2 = new ByteArrayInputStream(ba);
    //Now just working with 'is2' - the "copied" stream

InputStream-> byte []转换再次花费1000ms - 这是许多ppl建议读取InputStream的方式,而且它很慢 . 猜猜 - 上面的两个解析器方法(convertToXML()和convertBattlePagetoXMLWithoutDOM(),当传递'is2'而不是'is'时,在所有4个案例中,在50ms内完成 .

我读到了一个建议,即在解除阻塞之前,流等待连接关闭,所以我尝试使用HttpComponentsClient 4.0(http://hc.apache.org/httpcomponents-client/index.html)代替,但是初始的InputStream花了同样长的时间进行解析 . 例如这段代码:

public InputStream getWebPageAsStream2(int battle_id, int page) throws Exception {
        String url = "http://api.erepublik.com/v1/feeds/battle_logs/" + battle_id + "/" + page;
        HttpClient httpclient = new DefaultHttpClient();
        HttpGet httpget = new HttpGet(url);      
        HttpParams p = new BasicHttpParams();
        HttpConnectionParams.setSocketBufferSize(p, 250000);
        HttpConnectionParams.setStaleCheckingEnabled(p, false);
        HttpConnectionParams.setConnectionTimeout(p, 5000);
        httpget.setParams(p);           
        HttpResponse response = httpclient.execute(httpget);
        HttpEntity entity = response.getEntity();
        l = (int) entity.getContentLength();
        return entity.getContent();
    }

需要更长的时间才能处理(仅为网络增加50ms),流解析时间保持不变 . 显然它可以实例化,以便不会每次都创建HttpClient和属性(更快的网络时间),但流问题不会受到影响 .

所以我们遇到了中心问题 - 为什么初始URLConnection InputStream(或HttpClient InputStream)需要很长时间来处理,而本地创建的相同大小和内容的任何流都要快几个数量级?我的意思是,初始响应已经在RAM中的某个地方,并且我看不出有什么好处,因为与从byte []创建相同的流相比,它处理得如此之慢 .

考虑到我必须解析数百万条目和数千页这样的页面,总处理时间几乎是1.5秒/页似乎太长了 .

有任何想法吗?

附:请问更多代码是必需的 - 解析之后我做的唯一事情就是制作一个PreparedStatement并将条目放入1000个包中的JavaDB中,并且性能正常〜200ms / 1000条,prb可以用更多缓存进行优化但是我并没有深入研究它 .

1 回答

  • 1

    它需要更长的时间,因为它是从远程服务器读取 . 你的executeConnection()方法只是创建流,它实际上并没有从服务器读取整个响应 . 一旦你开始从流中读取,就完成了 .

相关问题