当前位置：自学咖网 > 技术教程 > 编程最新 > Json 序列化框架导致 CPU 使用率过高
wenwen 编程最新

Json 序列化框架导致 CPU 使用率过高

Json 序列化框架导致 CPU 使用率过高

问题现象：CPU 负载过高

我们线上的 jenkins 系统，时不时会发生 CPU 负载过高的现象。

CPU 负载过高后，SRE 同学会收到电话告警。

在我们的监控系统中，可以看到，某些时候，CPU 的负载确实会很高，如下图：
file

问题排查

Jenkins 系统本身是一个 Java 程序，应对 Java 程序导致的 CPU 使用率过高这一问题，GitHub 上有现成的解决方案：show-busy-java-threads。

下载链接如下：

  • GitHub：show-busy-java-threads
  • Gitee：show-busiest-java-threads

登录上机器，在 CPU 使用率高时候，执行 show-busy-java-threads 脚本：./show-busy-java-threads。

摘选其中的一些输出如下：

The stack of busy(25.0%) thread(20239/0x4f0f) of java process(248927) of user(jenkins):
"Handling GET /job/jenkins-test-job/api/json from 172.168.1.1 : qtp1641808846-3127" #3127 prio=5 os_prio=0 tid=0x00007f7380014000 nid=0x4f0f runnable [0x00007f722c392000]
   java.lang.Thread.State: RUNNABLE
        at java.util.Arrays.copyOfRange(Arrays.java:3664)
        at java.lang.String.<init>(String.java:207)
        at java.lang.String.substring(String.java:1933)
        at net.sf.json.util.JSONTokener.matches(JSONTokener.java:110)
        at net.sf.json.JSONObject._fromJSONTokener(JSONObject.java:912)
        at net.sf.json.JSONObject.fromObject(JSONObject.java:156)
        at net.sf.json.util.JSONTokener.nextValue(JSONTokener.java:348)
        at net.sf.json.JSONArray._fromJSONTokener(JSONArray.java:1131)
        at net.sf.json.JSONArray.fromObject(JSONArray.java:125)
        at net.sf.json.util.JSONTokener.nextValue(JSONTokener.java:351)
        at net.sf.json.JSONObject._fromJSONTokener(JSONObject.java:955)
        at net.sf.json.JSONObject.fromObject(JSONObject.java:156)
        at net.sf.json.util.JSONTokener.nextValue(JSONTokener.java:348)
        at net.sf.json.JSONObject._fromJSONTokener(JSONObject.java:955)
        at net.sf.json.JSONObject.fromObject(JSONObject.java:156)
        at net.sf.json.util.JSONTokener.nextValue(JSONTokener.java:348)
        at net.sf.json.JSONObject._fromJSONTokener(JSONObject.java:955)
        at net.sf.json.JSONObject.fromObject(JSONObject.java:156)
        at net.sf.json.util.JSONTokener.nextValue(JSONTokener.java:348)
        at net.sf.json.JSONObject._fromJSONTokener(JSONObject.java:955)
        at net.sf.json.JSONObject._fromString(JSONObject.java:1145)
        at net.sf.json.JSONObject.fromObject(JSONObject.java:162)
        at net.sf.json.JSONObject.fromObject(JSONObject.java:132)
        at sam.Sam.sendRequestReturnJson(Sam.java:517)
        at sam.Sam.getPermissionByUser(Sam.java:225)
        at sam.Sam.checkUserPermissionLocal(Sam.java:243)
        at com.michelin.cio.hudson.plugins.rolestrategy.PermissionCache.getPermissionSam(RoleMap.java:155)
        at com.michelin.cio.hudson.plugins.rolestrategy.PermissionCache.getPermission(RoleMap.java:106)
        at com.michelin.cio.hudson.plugins.rolestrategy.RoleMap.hasPermission(RoleMap.java:220)
        at com.michelin.cio.hudson.plugins.rolestrategy.RoleMap.access$000(RoleMap.java:166)
        at com.michelin.cio.hudson.plugins.rolestrategy.RoleMap$AclImpl.hasPermission(RoleMap.java:569)
        at hudson.security.SidACL._hasPermission(SidACL.java:70)

从上面的输出可以看到，25.0% 的 CPU 资源在处理 Handling GET /job/jenkins-test-job/api/json from 172.168.1.1 这个请求。

运维同学根据这个 ip ，定位到发起请求的是某同学 A。这个同学在跑一些定时任务，定时拉取 job 的执行结果。

问题是当我直接访问这个接口：/job/jenkins-test-job/api/json 时，返回并不慢，几乎很快就可以返回。问题应该不是这个接口的问题。

我们接着从 ./show-busy-java-threads 输出往下看：看到其中有问题的调用栈：

at net.sf.json.JSONObject.fromObject(JSONObject.java:132)
at sam.Sam.sendRequestReturnJson(Sam.java:517)
at sam.Sam.getPermissionByUser(Sam.java:225)
at sam.Sam.checkUserPermissionLocal(Sam.java:243)

看起来是这个 Sam 校验用户权限导致的 CPU 使用率过高，而接着看上面的代码 net.sf.json.JSONObject.fromObject，这个是在做 json 的反序列化。

通常来说，json 的序列化、反序列化都是比较费 CPU 的，更糟糕的是，这里用到的 json 序列化框架是 net.sf.json，而不是 Java 常用的 jackson 和 gson 等。

直觉告诉我，肯定是这个 net.sf.json 反序列化引起的 CPU 使用率过高问题。

备注：

通过跟之前维护 jenkins 的同学了解到，他们基于 role-strategy 插件，重写了 jenkins 权限验证逻辑，用的就是 Sam 权限。翻看 sam 权限插件的代码，确实有用 net.sf.json 做 json 反序列化。

到这里，定位到大概率是 Sam 权限插件的 net.sf.json 反序列化引起的问题。

问题复现

为了验证这个问题，我们拿到 Sam 权限插件的代码。找到出问题的关键代码：

public void getPermissionByUser(String email) {
    JSONObject params = new JSONObject();
    params.put("user_email", email);
    params.put("subsystem_id", SAM_JENKINS_SUM_SYSTEM_ID);

    JSONObject res = sendRequestReturnJson(URL, "GET", params);
    if (res.get("success").equals(true)) {
        cacheUserPermission(params.getString("user_email"), res.getJSONObject("permission").getJSONObject(email).getJSONObject("SERVICE"));
    }
}

public static JSONObject sendRequestReturnJson(String endpoint, String method, JSONObject params) {
    if (method.equals("POST")) {
        return JSONObject.fromObject(sendPostRequest(endpoint, params));
    } else if (method.equals("GET")) {
        return JSONObject.fromObject(sendGetRequest(endpoint, params));
    }
    return new JSONObject();
}

可以看到，这段代码会根据用户邮箱，发送 http 请求调用 Sam 系统，获取用户的权限数据，然后将数据反序列化成 JSONObject，即：
JSONObject.fromObject(sendGetRequest(endpoint, params, token))

在本地，通过复现 A 同学的请求，发现这个请求确实比较慢，而且费 CPU。通过 debug 得知，这个用户返回的 json 数据有 1M 左右，json 反序列化 CPU 打满。

而通过其他用户请求，发现处理很快，返回的 json 数据也比较小。

到这里，确认就是 net.sf.json 框架的反序列化性能问题，引起的 CPU 使用率过高。我们需要替换成其他高性能的 json 序列化框架。

备选有：gson、jackson、fastjson等。fastjson 因为经常出安全漏洞，暂不考虑，我们考虑从 gson、jackson 选择一个。

在选定之前，先对 gson、jackson， 的性能做个基准测试，并与 net.sf.json 做对比。

JMH 基准测试 json 框架性能

Json 框架的性能测试，我们选用 JMH 框架。

JMH 框架是 JDK 官方提供的性能基准测试套件，参考：https://github.com/openjdk/jmh

代码如下：

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import net.sf.json.JSONObject;
import org.apache.commons.io.FileUtils;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.springframework.util.ResourceUtils;

import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
public class JsonBenchmark {

    @Param({"10", "100", "500"})
    private int length;

    private String json;

    private String email = "a@123.com";
    private String path = "classpath:sam.json";

    @Benchmark
    public void testGson() throws IOException {
        Gson gson = new Gson();
        JsonObject root = gson.fromJson(json, JsonObject.class);

        if (root.getAsJsonObject("success").getAsBoolean()) {
            JsonObject services = root.get("permission").getAsJsonObject()
                    .get(email).getAsJsonObject()
                    .get("SERVICE").getAsJsonObject();
            System.out.println(services.size());
        }
    }

    @Benchmark
    public void testJackson() throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode root = objectMapper.readTree(json);

        if (root.get("success").asBoolean()) {
            JsonNode services = root.get("permission").get(email).get("SERVICE");
            System.out.println(services.size());
        }
    }

    @Benchmark
    public void testJsonObject() throws IOException {
        JSONObject root = JSONObject.fromObject(json);
        if (root.get("success").equals(true)) {
            JSONObject services = root.getJSONObject("permission").getJSONObject(email).getJSONObject("SERVICE");
            System.out.println(services.size());
        }
    }

    @Setup
    public void prepare() throws IOException {
        File file = ResourceUtils.getFile(path);
        json = FileUtils.readFileToString(file);
    }

    public static void main(String[] args) throws RunnerException {
        Options options = new OptionsBuilder()
                .include(JsonBenchmark.class.getSimpleName())
                .forks(1)
                .warmupIterations(5)
                .measurementIterations(2)
//                .output("/Users/wxweven/Benchmark.log")
                .result("result.json")
                .resultFormat(ResultFormatType.JSON)
                .build();
        new Runner(options).run();
    }
}

测试的结果如下：

Benchmark                     (length)  Mode  Cnt     Score   Error  Units
JsonBenchmark.testGson              10  avgt    2     7.979          ms/op
JsonBenchmark.testGson             100  avgt    2     8.958          ms/op
JsonBenchmark.testGson             500  avgt    2     9.975          ms/op
JsonBenchmark.testJackson           10  avgt    2    10.393          ms/op
JsonBenchmark.testJackson          100  avgt    2    12.214          ms/op
JsonBenchmark.testJackson          500  avgt    2    10.548          ms/op
JsonBenchmark.testJsonObject        10  avgt    2  1350.788          ms/op
JsonBenchmark.testJsonObject       100  avgt    2  1350.583          ms/op
JsonBenchmark.testJsonObject       500  avgt    2  1381.046          ms/op

可以看到，gson 和 jackson 性能接近，但是 jsonlib 性能就很差，比另外两个慢 100 多倍。
综合考虑性能、api 易用性等，选定 gson 作为替代方案。

替换成 gson

将之前的代码替换成 gson，代码如下：

public void getPermissionByUser(String email) {
    JSONObject params = new JSONObject();
    params.put("user_email", email);
    params.put("subsystem_id", SAM_JENKINS_SUM_SYSTEM_ID);

    JsonObject res = sendRequestReturnJsonV2(URL, "GET", params);
    if (res.get("success").getAsBoolean()) {
        cacheUserPermission(params.getString("user_email"), res.getAsJsonObject("permission").getAsJsonObject(email).getAsJsonObject("SERVICE"));
    }
        
}

public static JsonObject sendRequestReturnJsonV2(String endpoint, String method, JSONObject params) throws IOException {
    if (method.equals("POST")) {
        return GSON.fromJson(sendPostRequest(endpoint, params, token), JsonObject.class);
    } else if (method.equals("GET")) {
        return GSON.fromJson(sendGetRequest(endpoint, params, token), JsonObject.class);
    }

    return new JsonObject();
}

重新编译权限插件后上线，再次查看 CPU 负载监控，发现 CPU 负载确实降下来了（05/13晚上 0 点左右上线的）。
file

再次重新编译，问题得到解决。

结束语

这个问题，前前后后花费了不少时间，也困扰了 DevOps 团队比较久，经过大家的齐心协力，总算是把问题给解决了。

这篇文章也是对之前排查、解决问题的一个总结。
同时，也提醒大家，在使用第三方 jar 包的时候，一定要注意该 jar 包有没有性能、安全等问题。如果不确定的话，可以用 JMH 等手段自己测试以下。

我是梅小西，最近在某东南亚电商公司做 DevOps 的相关事情。从本期开始，将陆续分享基于 Jenkins 的 CI/CD 工作流，包括 Jenkins On k8s 等。
如果你对 Java 或者 Jenkins 等感兴趣，欢迎与我联系，微信：wxweven（备注 DevOps）

本文由博客群发一文多发等运营工具平台 OpenWrite 发布

hmoban主题是根据ripro二开的主题，极致后台体验，无插件，集成会员系统
自学咖网 » Json 序列化框架导致 CPU 使用率过高

wen 普通

分享到：

相关推荐

Go语言之指针

注意 程序在内存中存储它的值，每个内存块都 有一个地址，而存储这个地址的变量被称为指针变量，指针。 通常用十六进制数表示，如：0x6b0820 或 0xf84001d7f0 一个指针变量可以指向任何一个值的内存地址 它指...

面试题目:手写一个LRU算法实现

一、常见的内存淘汰算法 FIFO  先进先出 在这种淘汰算法中，先进⼊缓存的会先被淘汰 命中率很低 LRU Least recently used，最近最少使⽤get 根据数据的历史访问记录来进⾏淘汰数据，其核...

php异步调用方法是什么

php异步调用的方法：1、在返回给客户端的HTML代码中，嵌入AJAX调用，或者嵌入一个img标签，src指向要执行的耗时脚本；2、使用popen函数打开一个指向进程的管道，该进程由派生给定的command命令执行而产生...