Question

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

然而，由于该代码中存在很多因素，我还制作了一个玩具示例来比较流式传输与映射。我觉得有些事情可能会因为结果中存在很多随机性。

是测量吗？使用其他类型的打字机会有所作为吗？是不是有一些我不知道的多线程？

目前我正在向NUL文件对象写入相当于dev/null的窗口。我在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个Prouct对象的JSON目录文档。热点显然是产品的序列化（streamToFile() vs objectMapping()）。

Answer 1

好的，有几件事。

最重要的是，您应该只创建一个JsonFactory实例，类似于重用ObjectMapper的方式。重复使用这些物体是杰克逊表现的关键因素之一。有关更多提示，请参阅here。

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

然后一个普遍的方面是，在测量JVM上的性能时，你总是需要记住预热时间：你应该总是将测试预热多秒（最少5或10秒），以及运行实际测试足够的时间（如30秒或更长时间），以获得更稳定的结果。这是测试框架可以提供帮助的地方，因为它们实际上可以统计测量事物，并确定结果何时稳定到足够有意义。

希望这有帮助！

测试代码来比较杰克逊流与地图 - 这是否正常？

1 个答案: