C比Java慢：为什么？

Question

我很快写了一个C程序，提取了一组gzip压缩文件的第i行 （包含大约500,000行）。 这是我的C程序：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <zlib.h>

/* compilation:
gcc  -o linesbyindex -Wall -O3 linesbyindex.c -lz
*/
#define MY_BUFFER_SIZE 10000000
static void extract(long int index,const char* filename)
   {
   char buffer[MY_BUFFER_SIZE];
   long int curr=1;
   gzFile in=gzopen (filename, "rb");
   if(in==NULL)
       {
       fprintf(stderr,"Cannot open \"%s\" %s.\n",filename,strerror(errno));
       exit(EXIT_FAILURE);              }
   while(gzread(in,buffer,MY_BUFFER_SIZE)!=-1 && curr<=index)
       {
       char* p=buffer;
       while(*p!=0)
           {
           if(curr==index)
               {
               fputc(*p,stdout);
               }
           if(*p=='\n')
               {
               ++curr;
               if(curr>index) break;
               }
           p++;
           }
       }
   gzclose(in);
   if(curr<index)
       {
       fprintf(stderr,"Not enough lines in %s (%ld)\n",filename,curr);
       }
   }

int main(int argc,char** argv)
   {
   int optind=2;
   char* p2;
   long int count=0;
   if(argc<3)
       {
       fprintf(stderr,"Usage: %s (count) files...\n",argv[0]);
       return EXIT_FAILURE;
       }
   count=strtol(argv[1],&p2,10);
   if(count<1 || *p2!=0)
       {
       fprintf(stderr,"bad number %s\n",argv[1]);
       return EXIT_SUCCESS;
       }
   while(optind< argc)
       {
       extract(count,argv[optind]);
       ++optind;
       }
   return EXIT_SUCCESS;
   } 

作为测试，我在java中编写了以下等效代码：

import java.io.*;
import java.util.zip.GZIPInputStream;

public class GetLineByIndex{
   private int index;

   public GetLineByIndex(int count){
       this.index=count;
   }

   private String extract(File file) throws IOException
       {
       long curr=1;
       byte buffer[]=new byte[2048];
       StringBuilder line=null;
       InputStream in=null;
       if(file.getName().toLowerCase().endsWith(".gz")){
           in= (new GZIPInputStream(new FileInputStream(file)));
       }else{
           in= (new FileInputStream(file));
       }
             int nRead=0;
       while((nRead=in.read(buffer))!=-1)
           {
           int i=0;
           while(i<nRead)
               {
               if(buffer[i]=='\n')
                   {
                   ++curr;
                   if(curr>this.index) break;
                                     }
               else if(curr==this.index)
                   {
                   if(line==null) line=new StringBuilder(500);
                   line.append((char)buffer[i]);
                   }
               i++;
               }
           if(curr>this.index) break;
           }
       in.close();
       return (line==null?null:line.toString());
       }

   public static void main(String args[]) throws Exception{
       int optind=1;
       if(args.length<2){
           System.err.println("Usage: program (count) files...\n");
           return;
       }
       GetLineByIndex app=new GetLineByIndex(Integer.parseInt(args[0]));

       while(optind < args.length)
           {
           String line=app.extract(new File(args[optind]));
           if(line==null)
               {
               System.err.println("Not enough lines in "+args[optind]);
               }
           else
               {
               System.out.println(line);
               }
           ++optind;
           }
       return;
   }
} 

碰巧java程序在同一台机器上获取大于C程序（~2'15''）的索引要快得多（~1'45''）（我多次运行该测试）。

我该如何解释这种差异？

Answer 1

Java版本比C版本更快的最可能的解释是C版本不正确。

修复C版本后，我获得了以下结果（与您声称Java比C更快的说法相矛盾）：

Java 1.7 -client: 65 milliseconds (after JVM warmed up)
Java 1.7 -server: 82 milliseconds (after JVM warmed up)
gcc -O3:          37 milliseconds

任务是从文件words.gz打印第200000行。 文件words.gz是由words.gz /usr/share/dict/words 。

---

...
static char buffer[MY_BUFFER_SIZE];
...
ssize_t len;
while((len=gzread(in,buffer,MY_BUFFER_SIZE)) > 0  &&  curr<=index)
    {
    char* p=buffer;
    char* endp=buffer+len;
    while(p < endp)
       {
...

Answer 2

因为fputc（）不是很快，你在输出文件中添加了stuf char-by-char。

调用fputc_unlocked或者更确切地说要分隔你要添加的东西并调用fwrite（）应该更快。

Answer 3

那么你的程序正在做不同的事情。 我没有描述你的程序，但从查看你的代码我怀疑这个区别：

要构建该行，可以在Java中使用它：

if(curr==this.index)
{
    if(line==null) line=new StringBuilder(500);
    line.append((char)buffer[i]);
}

而这在C：

if(curr==index)
{
    fputc(*p,stdout);
}

即你一次打印一个角色到stdout。 默认情况下，这是buffere，但我怀疑它仍然比你在Java中使用的500字符缓冲区慢。

Answer 4

我对编译器执行的优化没有更深入的了解，但我想这就是你的程序之间的区别。 这样的微观标记非常非常非常难以正确和有意义。 这是Brian Goetz撰写的一篇文章，详细阐述了这篇文章： http ： //www.ibm.com/developerworks/java/library/j-jtp02225/index.html

Answer 5

非常大的缓冲区可能会更慢。 我建议你让缓冲区大小相同。 即2或8 KB