Objectmapper, stop being new like a second product

Since the domestic light fastjson Frequent thunderstorms ,jackson json Is more and more widely used . In especial spring The family made it the default JSON Processing packages ,jackson The use of is developing explosively .

Many students found that ,jackson There is no parallel fastjson Of JSON.parseObjec In this way , It does look like a quick way . To parse json, You have to new One ObjectMapper, To handle the real parsing action .

It looks like this .

public String getCarString(Car car){
    ObjectMapper objectMapper = new ObjectMapper();
    String str = objectMapper.writeValueAsString(car);
    return str;
}

This code is in CV The engineer's hands were full of flowers .

magical .

Is there a problem with this code ？

You have to say it has a problem , It does perform correctly . You have to say it's okay , In the eyes of students pursuing performance , This must be a heinous piece of code .

General tools , It's all singletons , At the same time, it is thread safe .ObjectMapper No exception , It's also thread safe , You can execute it concurrently , There won't be any problems .

This code ,ObjectMapper Every time a method is called , Will generate a . In addition to causing a certain waste of memory of the younger generation , Is there any hard injury in the execution time ？

new And don't new, Is it really that different ？

There is a ,xjjdog Implicitly point out the problem of a piece of frequently called code , I was yelled by my little partner and took out the evidence .

evidence ？ This has to be moved out Java Benchmarking tools in JMH, To find out .

JMH(the Java Microbenchmark Harness) It is such a tool that can do benchmarking . If you pass through our series of tools , Locate the hotspot code , To test its performance data , Evaluate improvements , You can give it to JMH. Its measurement accuracy is very high , Up to nanosecond level .

JMH It's a jar package , It is similar to the unit test framework JUnit It's very much like , You can make some basic configuration through annotations . Many of these configurations can be configured through main Methodical OptionsBuilder Set up .

The picture above is a typical one JMH Content of program execution . By starting multiple processes , Multiple threads , First perform warm-up , And then perform iterations , Finally, summarize all the test data for analysis . Before and after execution , Some pre and post operations can also be processed according to granularity .

JMH test result

To test the above scenario , We created the following benchmark classes . It is divided into three test scenarios ：

1. Directly in the method new ObjectMapper

2. Share one globally ObjectMapper

3. Use ThreadLocal, One per thread ObjectMapper

Such a test belongs to cpu intensive . my cpu Yes 10 nucleus , It's directly distributed 10 Concurrency of threads ,cpu Run full during the test .

@BenchmarkMode({Mode.Throughput})
@OutputTimeUnit(TimeUnit.SECONDS)
@State(Scope.Thread)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
@Threads(10)
public class ObjectMapperTest {
    String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";

    @State(Scope.Benchmark)
    public static class BenchmarkState {
        ObjectMapper GLOBAL_MAP = new ObjectMapper();
        ThreadLocal<ObjectMapper> GLOBAL_MAP_THREAD = new ThreadLocal<>();
    }

    @Benchmark
    public Map globalTest(BenchmarkState state) throws Exception{
        Map map = state.GLOBAL_MAP.readValue(json, Map.class);
        return map;
    }


    @Benchmark
    public Map globalTestThreadLocal(BenchmarkState state) throws Exception{
        if(null == state.GLOBAL_MAP_THREAD.get()){
            state.GLOBAL_MAP_THREAD.set(new ObjectMapper());
        }
        Map map = state.GLOBAL_MAP_THREAD.get().readValue(json, Map.class);
        return map;
    }

    @Benchmark
    public Map localTest() throws Exception{
        ObjectMapper objectMapper = new ObjectMapper();
        Map map = objectMapper.readValue(json, Map.class);
        return map;
    }

    public static void main(String[] args) throws Exception {
        Options opts = new OptionsBuilder()
                .include(ObjectMapperTest.class.getSimpleName())
                .resultFormat(ResultFormatType.CSV)
                .build();

        new Runner(opts).run();
    }
}

The test results are as follows .

Benchmark                                Mode  Cnt         Score         Error  Units
ObjectMapperTest.globalTest             thrpt    5  25125094.559 ± 1754308.010  ops/s
ObjectMapperTest.globalTestThreadLocal  thrpt    5  31780573.549 ± 7779240.155  ops/s
ObjectMapperTest.localTest              thrpt    5   2131394.345 ±  216974.682  ops/s

As can be seen from the test results , If we call each time new One ObjectMapper, Can execute... Per second 200 Ten thousand times JSON analysis ; If the global uses one ObjectMapper, Then... Can be executed per second 2000 More than ten thousand times , It's fast enough 10 times .

If you use ThreadLocal The way , Each thread assigns it a parser , Then the performance will increase a little , But not to the point of exaggeration .

So when writing code in a project , We just need to ensure that there is a global ObjectMapper That's all right. .

Of course , because ObjectMapper There are many features to configure , You may be assigned a different scenario ObjectMapper. All in all , Its quantity doesn't need to be too much , Because it's thread safe .

So the conclusion is relatively clear , We only need to use one in the whole project ObjectMapper That's all right. , There's no need to be silly every time new One , After all, the performance is poor 10 times . If your JSON There are many custom configurations , Using global variables can highlight its advantages .

Don't think it's unnecessary , It's always good to keep good coding habits . High performance code is accumulated bit by bit . Short step , A thousand miles . Don't product the little stream , Beyond into the sea , That's the reason .