Java 比较jackson Stream和Map的测试代码-这是否正常？

我有一个服务器端应用程序，我正在使用利用流式API的VisualVM分析它

然而，由于代码中有很多因素，我还制作了一个玩具示例来比较流媒体和映射。 我有一种感觉，由于结果中有很多随机性，所以可能有问题

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

目前，我正在向

NUL

文件对象写入与

dev/null

相当的windows对象。我以

高
优先级运行此程序，以防操作系统影响它

玩具示例代码：

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));

    }

}

导入java.io.File；
导入java.io.IOException；
导入java.io.StringWriter；
导入java.util.ArrayList；
导入java.util.Map.Entry；
导入java.util.Scanner；
导入java.util.TreeMap；
导入com.fasterxml.jackson.core.jsonencodeding；
导入com.fasterxml.jackson.core.JsonFactory；
导入com.fasterxml.jackson.core.JsonGenerator；
导入com.fasterxml.jackson.databind.ObjectMapper；
公共类TestStreamingMapping{
公共最终静态整数模拟目录=10000；
public final static int CATALOG_SIZE=1000；//目录中的1000项，每秒500个请求
public final静态布尔WRITE_TO_FILE=false；//写入文件或写入字符串
public final static boolean DEBUG\u PRINT\u 100\u CHAR=false；//打印出字符串的一部分以查看所有ok
public static final String mappingFile=“mapping.txt”//如果写入文件，则在何处？
public static final String streamingFile=“streaming.txt”//如果流到文件，在哪里？
公共静态最终布尔打印\中间\结果=false；
公共静态树映射迭代百分比=新树映射（）；
ObjectMapper mapper=新的ObjectMapper（）；
JsonFactory f=新的JsonFactory（）；
JSONG发生器g；
公共静态长totalCountStream=0，totalCountMap=0；
公共静态void main（字符串参数[]）
{       
System.out.println（“连接探查器时按enter键…”）；
新扫描仪（System.in）.nextLine（）；
System.out.println（“开始JSON生成的迭代”）；
双倍百分比；
对于（长i=0；i好的，两件事

最重要的是，您应该只创建一个
JsonFactory
实例，类似于重用
ObjectMapper
的方式。重用这些对象是提高Jackson性能的关键因素之一。有关更多想法，请参阅

另一个要考虑的是使用<代码>文件< /> >添加I/O开销，这两种方法都应该是相同的，并且减少实际处理时间的差异。您可能想分离这个文件，看看有多少时间花在文件访问上。我意识到这可能是伪造文件（按OS处理的注释）。，但即使没有物理开销，操作系统通常也会产生一些系统调用开销
然后一个普遍的方面是，在测量JVM上的性能时，您始终需要记住预热时间：您应该始终将测试预热多秒（至少5秒或10秒），以及运行实际测试足够的时间（如30秒或更长），以获得更稳定的结果。
这就是测试框架可以提供帮助的地方，因为它们实际上可以在统计上度量事物，并找出结果何时稳定到有意义

希望这能有所帮助！
根据您的评论，我更新了代码。如果您有时间，可以看一看，以防出现问题吗？谢谢！看起来好多了！我想最后一个建议是打电话给
performTest（）
在进行任何测量之前进行几次：理想情况下，基于时间，比如运行5秒，然后开始测量。前两次调用的数字将是任意的，结果会有很大的偏差（因为它们可能比稳态时间长10-100倍）。