java - 用于比较 jackson Stream 与 Map 的测试代码 - 这工作正常吗？

Question

我有一个服务器端应用程序，我正在使用使用流 API 的 VisualVM 进行分析。

但是，由于该代码中有很多因素，我还制作了一个玩具示例来比较流式传输与映射。我有一种感觉，结果可能有很多随机性。

是测量吗？使用其他类型的打字机会有什么不同吗？是不是有什么我不知道的多线程？

目前，我正在向 NUL 文件对象写入与 dev/null 等效的 Windows。我以 high 优先级运行它，以防操作系统可能影响它。

玩具示例代码:

import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.TreeMap;

import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;


public class TestStreamingMapping {

    public final static int NUM_SIMULATED_CATALOGS = 10000;
    public final static int CATALOG_SIZE = 1000;                //1000 Items in CATALOG, 500 requests per second
    public final static boolean WRITE_TO_FILE = false;          //Write to file, or write to string
    public final static boolean DEBUG_PRINT_100_CHAR = false;   //Print out part of string to see all ok
    public static final String mappingFile = "mapping.txt";     //If writing to file, where?
    public static final String streamingFile = "streaming.txt"; //If streaming to file, where?
    public static final boolean PRINT_INTERMEDIATE_RESULTS = false;

    public static TreeMap<Long,Double> iterationPercentages = new TreeMap<Long,Double>();

    ObjectMapper  mapper= new ObjectMapper();
    JsonFactory f = new JsonFactory();
    JsonGenerator g;

    public static long totalCountStream = 0, totalCountMap = 0;

    public static void main(String args[])
    {       

        System.out.println("Press enter when profiler is connected...");
        new Scanner(System.in).nextLine(); 
        System.out.println("Starting iterations of JSON generation.");
        double percentage;

        for(long i=0; i<NUM_SIMULATED_CATALOGS; i++)
        {
            performTest();  
            percentage = (totalCountStream*100.0d / totalCountMap);
            iterationPercentages.put(i, percentage);

            if(!PRINT_INTERMEDIATE_RESULTS && i%100 == 0)System.out.print(i+"-");
        }

        System.out.println("Total Streaming API:        " + totalCountStream + "    ns.");
        System.out.println("Total Mapping API:      " + totalCountMap + "   ns.");
        System.out.println("Total Stream(as % of map):  " +  totalCountStream*100.0d / totalCountMap  + "   %\r\n" );

        System.out.println("Iteration\tStreamPercent");
        for(Entry<Long, Double> entry : iterationPercentages.entrySet())
            if(entry.getKey() % 20 ==0)
                System.out.println(entry.getKey() + "\t\t" + Math.round(entry.getValue())  + "%" );

    }

    public static void performTest()
    {
        TestStreamingMapping test = new TestStreamingMapping(); 
        long time1, time2;
        double percentage = 0;

        try {       
            long starttime1 = System.nanoTime();
            test.streamingToFile();
            totalCountStream+=time1=System.nanoTime() - starttime1;

            long starttime2 = System.nanoTime();
            test.objectMapping();
            totalCountMap+=time2=System.nanoTime() - starttime2;

            percentage = (time1*100.0d / time2);

            if(PRINT_INTERMEDIATE_RESULTS)
            {
                System.out.println("Streaming API:      " + time1 + "   ns.");
                System.out.println("Mapping API:        " + time2 + "   ns.");
                System.out.println("Stream(as % of map):    " + percentage  + " %" );
                System.out.println("----------------------------------------------\r\n");       

            }           

        } catch (IOException e) {
            e.printStackTrace();
        }               
    }

    public String[] numbers;
    public ArrayList<String> arrayList = new ArrayList<String>();

    public TestStreamingMapping()
    {
        numbers=new String[62];
        for(int i=0; i<60; i++) numbers[i] = String.valueOf(Math.random()*i);

        for(int i=0; i<60; i++) arrayList.add(String.valueOf(Math.random()*i));
    }


    public void initializeGenerator(StringWriter writer) throws IOException
    {
        if(WRITE_TO_FILE)
            g = f.createGenerator(new File(mappingFile), JsonEncoding.UTF8);
        else
            g = f. createGenerator(writer);
    }


    public void objectMapping() throws IOException
    {       
        StringWriter writer = new StringWriter();
        initializeGenerator(writer);

        for(int j=0; j<CATALOG_SIZE; j++)
            mapper.writeValue(g, this); 

        g.close();
        writer.close();     

        if(DEBUG_PRINT_100_CHAR)
        System.out.println(writer.toString().substring(0,100));
    }




    public void streamingToFile() throws IOException
    {

        StringWriter writer = new StringWriter();
        initializeGenerator(writer);

        for(int j=0; j<CATALOG_SIZE; j++)
        {
             g.writeStartObject();  
             g.writeFieldName("numbers_streaming");  
             g.writeStartArray(); 
             for(int i=0; i<numbers.length; i++) g.writeString(numbers[i]); 
             g.writeEndArray();

             g.writeFieldName("arrayList");  g.writeStartArray(); 
             for(String num: arrayList) g.writeString(num); 
             g.writeEndArray();

             g.writeEndObject(); 
        }

        g.close();
        writer.close();     

        if(DEBUG_PRINT_100_CHAR)
        System.out.println(writer.toString().substring(0,100));

    }

}

下面的代码模拟了一个服务，该服务将生成一个包含 1000 个产品对象的 JSON 目录文档。热点显然是产品的序列化(streamToFile() vs objectMapping())。

Answer 1

好的，有几件事。

最重要的是，您应该只创建一个 JsonFactory 实例，类似于重用 ObjectMapper 的方式。重复使用这些元素是 jackson 表演的关键之一。参见 here了解更多想法。

要考虑的另一件事是使用 File 会增加 I/O 开销，这两种方法应该大致相同，并减少实际处理时间的差异。您可能希望将其分开以查看在文件访问上花费了多少时间。我意识到这可能是虚假文件(根据关于操作系统如何处理该文件的说明)，但即使没有物理开销，操作系统通常也会产生一些系统调用开销。

还有一个普遍的方面是，在 JVM 上测量性能时，您始终需要牢记预热时间:您应该始终预热测试多秒(最少 5 或 10 秒)，以及运行实际测试足够的时间(例如 30 秒或更长时间)以获得更稳定的结果。这就是测试框架可以提供帮助的地方，因为它们实际上可以统计地衡量事物并确定结果何时稳定到足以有意义。

希望这对您有所帮助!