OkHttp 工具包 创建了太多 ConnectionPool 对象导致内存爆炸

已于 2023-10-16 15:35:58 修改
阅读量6.8k 收藏 6
点赞数 1
分类专栏： 生产问题记录 文章标签： java
于 2022-03-04 03:10:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrathena/article/details/123267897
版权
本文详细介绍了由于OkHttp使用不当导致的内存溢出和内存泄漏问题，分析了问题原因，并提供了一个重新封装的OkHttpKit工具类，旨在解决这些问题，同时保证在高并发场景下的性能和效率。通过设置单例的OkHttpClient对象，避免频繁创建导致的内存浪费，以及确保Response和ResponseBody的正确关闭，防止内存泄漏。此外，还展示了如何实现Cookie的管理和异步请求的处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

博文目录

文章目录

问题说明

在这里插入图片描述
OkHttp ConnectionPool 对象居然有近2000个, 占用了太多的内存, 导致宕机

内存溢出

本次问题的原因是, OkHttp 使用不规范, 封装的工具类不科学

原工具类中提供的 post 方法, 每次调用都会创建一个新的 OkHttpClient 对象, 调用请求后该对象就会被抛弃, 但是该对象内部持有一个 ConnectionPool 连接池对象, 其中的连接对象, 默认会保持存活5分钟, 导致 OkHttpClient 对象(及 ConnectionPool) 不能及时被回收释放, 对象数量越来越多, 占用内存越来越大, 最终内存溢出

内存泄漏

Response 或 ResponseBody 没有正确且及时关闭, 可能会导致下面的内存泄漏警告

WARN okhttp3.OkHttpClient - A connection to http://host:port was leaked. Did you forget to close a response body? To see where this was allocated, set the OkHttpClient logger level to FINE: Logger.getLogger(OkHttpClient.class.getName()).setLevel(Level.FINE);

重新封装 OkHttpKit

确保解决 内存溢出 和 内存泄漏 两种问题, 兼顾方便好用的需求

以下是基于 com.squareup.okhttp3:okhttp:4.11.0 的 OkHttpKit 工具包, OkHttp 从版本4起使用了 Kotlin 编写, 使用和之前的版本稍有不同

package com.mrathena.toolkit;

import lombok.Setter;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;
import okhttp3.ConnectionPool;
import okhttp3.Cookie;
import okhttp3.CookieJar;
import okhttp3.FormBody;
import okhttp3.HttpUrl;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;
import org.jetbrains.annotations.NotNull;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.LongAdder;
import java.util.function.Consumer;

/**
 * 在高并发场景下, 一定要确保使用同一个 OkHttpClient 对象, 否则容易造成内存溢出
 * 因为每个 OkHttpClient 对象都有一个 connectionPool 属性, 其中的连接在使用后默认会继续存活5分钟, 即该对象只有到期后才会被释放
 * 而且每个池中有一个线程池对象, 会创建一个清理连接的死循环线程, 当有大量连接池对象时, 也会有大量该线程, 造成无谓的资源浪费
 * 在高并发场景下, 如果每次请求都创建一个新的 OkHttpClient 对象(及 ConnectionPool), 这些对象会随着时间推移(默认5分钟内)占用越来越多的内存, 最终导致内存爆炸
 * 参考: https://blog.csdn.net/mrathena/article/details/123267897
 * <p>
 * 不正确的封装与使用可能会报如下内存泄漏异常, 原因是 Response / ResponseBody 没有正确且及时关闭, 响应关闭应封装到公共方法中而不能靠方法调用者的自觉关闭(非常不靠谱)
 * WARN okhttp3.OkHttpClient - A connection to http://host:port was leaked. Did you forget to close a response body? To see where this was allocated, set the OkHttpClient logger level to FINE: Logger.getLogger(OkHttpClient.class.getName()).setLevel(Level.FINE);
 * <p>
 * 使用异步 enqueue 时, 最终会调用到 OkHttpClient 内 Dispatcher 对象内部维护的一个线程池, 该线程池中的线程默认有60秒的存活时间(导致之行结束不能及时停止), 这里可更换自定义的线程池. 不使用异步 enqueue 没有该问题
 * new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue<>(), Util.threadFactory("OkHttp Dispatcher", false));
 * new OkHttpClient.Builder().dispatcher(new Dispatcher(executor)).build();
 * <p>
 * 通过 response.body().byteStream() 可以拿到 InputStream, 可依此实现下载功能, buffer=8196, 可依此实现下载进度功能
 */
@Slf4j
@Setter
@Accessors(chain = true, fluent = true)
public final class OkHttpKit {

    /**
     * 媒体类型
     */
    private static final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/json; charset=utf-8");
    private static final MediaType MEDIA_TYPE_FILE = MediaType.parse("application/octet-stream");

    /**
     * 单例 OkHttpClient 对象 (默认 连接超时/读超时/写超时 都是1秒)
     */
    private static volatile OkHttpClient SINGLETON;

    /**
     * 获取多例 OkHttpClient 对象
     */
    public static OkHttpClient generateOkHttpClient(int connect, int write, int read) {
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.connectTimeout(connect, TimeUnit.SECONDS);
        builder.writeTimeout(write, TimeUnit.SECONDS);
        builder.readTimeout(read, TimeUnit.SECONDS);
        builder.setCookieJar$okhttp(new CookieJar() {

            // https://www.rfc-editor.org/rfc/rfc6265#section-5.1.3, Domain Matching
            // https://www.rfc-editor.org/rfc/rfc6265#section-5.3, 如何处理 Cookie
            // https://www.rfc-editor.org/rfc/rfc6265#section-5.3, 6. 如何处理 Cookie 的 Domain
            // 结构应该是 Map<Domain, Map<CookieName, CookieValue>>, 而不是用 host 做 key
            private final Map<String, Map<String, Cookie>> cookies = new ConcurrentHashMap<>();

            @Override
            public void saveFromResponse(@NotNull HttpUrl url, @NotNull List<Cookie> list) {
                // 入参的 cookies 里存在多个 cookie 有相同 name, 不同 domain 的情况, 所以不能直接弄转成 map
                for (Cookie cookie : list) {
                    if (!cookie.value().isEmpty() && cookie.matches(url)) {
                        String domain = cookie.domain();
                        this.cookies.putIfAbsent(domain, new HashMap<>());
                        this.cookies.get(domain).put(cookie.name(), cookie);
                    }
                }
                log.debug("========== ========== ========== ========== ========== ========== ========== ========== ========== ==========");
                this.cookies.forEach((domain, value) -> {
                    value.forEach((name, cookie) -> log.debug("Save [{}].[{} = {}]", domain, name, cookie.value()));
                });
                log.debug("========== ========== ========== ========== ========== ========== ========== ========== ========== ==========");
            }

            @NotNull
            @Override
            public List<Cookie> loadForRequest(@NotNull HttpUrl url) {
                String host = url.host();
                log.debug("Host: [{}], Url: {}", host, url);
                List<Cookie> cookieList = new LinkedList<>();
                this.cookies.forEach((domain, map) -> {
                    for (Cookie cookie : map.values()) {
                        // 这里的匹配逻辑不是我们自己瞎比猜的, 看上面的参考文档, 另外 OkHttp3.Cookie 已经按国际标准实现了 cookie 是否匹配 url 的验证方法
                        if (cookie.matches(url)) {
                            cookieList.add(cookie);
                            log.debug("Load [{}].[{} = {}]", domain, cookie.name(), cookie.value());
                        }
                    }
                });
                return cookieList;
            }
        });

        return builder.build();
    }

    /**
     * 获取多例 OkHttpClient 对象
     */
    public static OkHttpClient generateOkHttpClient() {
        return generateOkHttpClient(1, 1, 1);
    }

    /**
     * 获取单例 OkHttpClient 对象
     */
    public static OkHttpClient getOkHttpClient() {
        if (null == SINGLETON) {
            synchronized (OkHttpClient.class) {
                if (null == SINGLETON) {
                    SINGLETON = generateOkHttpClient();
                }
            }
        }
        return SINGLETON;
    }

    /**
     * 请求参数
     */
    private String url;
    private Map<String, String> headers;
    private Map<String, Object> parameters;
    private String json;
    private Map<String, File> files;

    private OkHttpKit() {}

    public static OkHttpKit create() {
        return new OkHttpKit();
    }

    public OkHttpKit headers(Map<String, String> headers) {
        if (null == this.headers) {
            this.headers = new HashMap<>();
        }
        this.headers.putAll(headers);
        return this;
    }

    public OkHttpKit header(String key, String value) {
        if (null == this.headers) {
            this.headers = new HashMap<>();
        }
        this.headers.put(key, value);
        return this;
    }

    public OkHttpKit cookie(String value) {
        return header("cookie", value);
    }

    public OkHttpKit userAgent(String userAgent) {
        return header("user-agent", userAgent);
    }

    public OkHttpKit ua(String userAgent) {
        return header("user-agent", userAgent);
    }
    public OkHttpKit referer(String userAgent) {
        return header("referer", userAgent);
    }

    public OkHttpKit parameters(Map<String, Object> parameters) {
        if (null == this.parameters) {
            this.parameters = new HashMap<>();
        }
        this.parameters.putAll(parameters);
        return this;
    }

    public OkHttpKit parameter(String key, Object value) {
        if (null == this.parameters) {
            this.parameters = new HashMap<>();
        }
        this.parameters.put(key, value);
        return this;
    }

    public OkHttpKit file(String key, File file) {
        if (null == this.files) {
            this.files = new HashMap<>();
        }
        this.files.put(key, file);
        return this;
    }

    public OkHttpKit files(Map<String, File> files) {
        if (null == this.files) {
            this.files = new HashMap<>();
        }
        this.files.putAll(files);
        return this;
    }

    public void get(OkHttpClient client, Consumer<Response> consumer) throws IOException {
        if (null != this.parameters) {
            StringBuilder sb = new StringBuilder();
            this.parameters.forEach((key, value) -> {
                if (null != key && null != value) {
                    sb.append("&").append(key).append("=").append(value);
                }
            });
            if (!this.url.contains("?")) {
                sb.deleteCharAt(0).insert(0, "?");
            }
            this.url += sb.toString();
        }
        Request.Builder requestBuilder = new Request.Builder().url(this.url);
        if (null != this.headers) {
            this.headers.forEach(requestBuilder::addHeader);
        }
        Request request = requestBuilder.build();
        try (Response response = client.newCall(request).execute()) {
            consumer.accept(response); // 消耗掉该响应
        }
    }

    public void get(Consumer<Response> consumer) throws IOException {
        get(getOkHttpClient(), consumer);
    }

    public void post(OkHttpClient client, Consumer<Response> consumer) throws IOException {
        Request.Builder requestBuilder = new Request.Builder().url(this.url);
        if (null != this.headers) {
            this.headers.forEach(requestBuilder::addHeader);
        }
        if (null != this.files) {
            MultipartBody.Builder multipartBodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
            for (Map.Entry<String, File> entry : this.files.entrySet()) {
                String name = entry.getKey();
                File file = entry.getValue();
                RequestBody fileBody = RequestBody.create(file, MEDIA_TYPE_FILE);
                multipartBodyBuilder.addFormDataPart(name, file.getName(), fileBody);
            }
            requestBuilder.post(multipartBodyBuilder.build());
        } else if (null != this.json) {
            requestBuilder.post(FormBody.create(this.json, MEDIA_TYPE_JSON));
        } else {
            FormBody.Builder formBodyBuilder = new FormBody.Builder();
            if (null != this.parameters) {
                for (Map.Entry<String, Object> entry : this.parameters.entrySet()) {
                    formBodyBuilder.add(entry.getKey(), entry.getValue().toString());
                }
            }
            requestBuilder.post(formBodyBuilder.build());
        }
        Request request = requestBuilder.build();
        try (Response response = client.newCall(request).execute()) {
            consumer.accept(response); // 消耗掉该响应
        }
    }

    public void post(Consumer<Response> consumer) throws IOException {
        post(getOkHttpClient(), consumer);
    }

    public static void main(String[] args) {
        try {
            OkHttpKit.create().url("https://www.baidu.com").get(response -> {
                try {
                    if (response.isSuccessful()) {
                        ResponseBody body = response.body();
                        if (null == body) {
                            log.info("Response Body is null");
                            return;
                        }
                        System.out.println(body.string());
                    } else {
                        System.out.println(response.protocol());
                        System.out.println(response.code());
                        System.out.println(response.message());
                    }
                } catch (Throwable cause) {
                    log.error("", cause);
                }
            });
        } catch (Throwable cause) {
            log.error("", cause);
        }
    }

}
Android开发问题集锦五--OkHttp资源释放与内存泄露
hnjzfwy的博客
10-20 1390
如果我们需要OkHttp高并发操作的时候，就会瞬间积累大量的句柄和链接，来不及释放掉，从而产生泄露。想想，除非你断线重连要一分钟后做，否则就会有挤压，就会泄露。本文针对OkHttp资源释放与内存泄露提出相应的解决方案，希望能够帮助到需要的小伙伴。
okhttp3连接池清理
zhekecong的博客
10-02 2659
okhttp3连接池清理okhttp3连接池RealConnectionPool清理在什么时候触发cleanUp方法cleanUp方法的下半部分cleanUp方法的上半部份pruneAndGetAllocationCount使用okhttp注意点 okhttp3连接池RealConnectionPool 连接池是用来存储连接实例对象RealConnection。存储RealConnection是为了实现连接复用，提高网络连接工作效率，减少内存开支。 class RealConnectionPool( t
应用服务OkHttpClient创建大量对外连接时内存溢出
樱木天亥
10-17 3694
文章目录1 背景2 排查​2.1 原因2.2 验证过程2.2.1 修改前2.2.2 修改后3 解决 1 背景 最近工作中碰到一个生产问题，就是应用服务在使用 OkHttpClient 时，在创建大量对外连接时线程堆积导致内存溢出。 主要表现是在流量极低的情况下，即平均 qps 在 1～4 左右的情况下，各主要线程都很低，但是系统活跃线程却很高，超过了限制的阈值，如果持续下去，线程堆积过高则会导致应用程序直接挂掉。 2 排查 ​2.1 原因 在对应用服务的其中一个 pod 的线程栈 du
OkHttp 连接池模块原理深度剖析
最新发布
Android开发领域创作者
03-08 947
OkHttp 的连接池模块负责管理 HTTP 连接的复用。它会维护一个连接池，将空闲的连接存储在池中。当有新的请求需要建立连接时，连接池会首先检查池中是否有可用的空闲连接。如果有，则直接复用该连接；如果没有，则创建一个新的连接。同时，连接池还会定期清理过期的空闲连接，以释放系统资源。此外，连接池支持对连接的最大空闲时间和最大连接数进行配置，以满足不同应用场景的需求。
okhttp导致的内存溢出(OOM)sun.security.ssl.SSLSocketImpl
江哈哈的博客
12-01 3314
okhttp导致的内存溢出(OOM)sun.security.ssl.SSLSocketImpl。原因是每次请求都new一个OkHttpClient对象，每个OkHttpClient会维护一个连接池(线程池)，线程池中的keepAliveTime参数为1分钟。
OkHttp 内存溢出问题 A connection to xxxxxx was leaked.
java_cn_的博客
05-15 6047
java ，内存溢出问题
解决retrofit OKhttp创建大量对外连接时内存溢出
tianyaleixiaowu的专栏
12-15 2万+
这个问题是这样发生的，我的表中有一批数据，量级较大，数百万个，它们有个地址Address字段，标明了地理位置。我需要对这一批数据根据地址去百度或者高德地图去查询经纬度，并且保存下来。 原本是直接分页读取该表，每次读取几百条，然后一条一条去获取经纬度并且保存。后来发现实在太慢，一秒也就能处理个三五条。所以开启了多线程，大约30个线程，每个线程处理不同id范围的数据。 此时问题出现了，每个线程中都有
Java学习（中）
Lzdnydppx的博客
08-11 1286
正则表达式、加密与安全、多线程、Maven基础、网络编程、XML与JSON、JDBC编程、函数式编程、设计模式
Android性能优化之常见的内存泄漏
热门推荐
【博客地址迁移到】：https://zhengxiaoyong.com
11-23 3万+
前言对于内存泄漏，我想大家在开发中肯定都遇到过，只不过内存泄漏对我们来说并不是可见的，因为它是在堆中活动，而要想检测程序中是否有内存泄漏的产生，通常我们可以借助LeakCanary、MAT等工具来检测应用程序是否存在内存泄漏，MAT是一款强大的内存分析工具，功能繁多而复杂，而LeakCanary则是由Square开源的一款轻量第三方内存泄漏检测工具，当它检测到程序中有内存泄漏的产生时，它将以最直观的
OkHttp资源泄露问题
weixin_59390140的博客
04-13 644
OkHttp的返回值是Response, Response.body().string()会自动关闭流, 如果没有调用该方法, 需要手动关闭流: Response.body().close()
OkHttp3使用连接池情况下大量占用端口TIME_WAIT
听雨小筑
11-23 2632
OkHttp3压测Client大量占用端口TIME_WAIT
mvp防泄漏（OKHttp）.rar
05-25
Android MVP+OKHttp+防内存泄漏Demo(结构清晰),如果有问题请留言，谢谢
listview加载更多，并图片异步加载，处理内存溢出
11-07
1：listview加载分页图片 2：实现下拉刷新更多 3：处理图片加载和异步缓冲 4：处理内存溢出的可能
记一次Java内存泄漏最终导致内存溢出的事故分析
itloser.info的傻傻博客
11-17 1173
当然 该系统还有待优化的地方 但这都是后话了。对于一个做Android的 初入后端 这次事故排查让我学到了很多这次从 线程池 内存泄漏 内存溢出 高并发 等 收获颇丰我这篇文章 仅仅是展示解决思路 公司代码也不能贴出 所以多多包涵大家如果遇到类似的问题 可以先看 我上面贴出的参考资料这些资料帮了我很多（虽然在大量的复制粘贴文章里感觉就像是 屎里淘金）可以先看看这些参考文章 再看看我的解题思路 应该有所帮助！
OkHttp3——连接池
如若、然的专栏
10-15 4867
ConnectionPool --> RealConnectionPool(里面包含List<Realconnection>) 连接池具有以下特点： 连接池管理所有Socket连接，当有新的请求时从池中分配一个链路。 默认支持5个并发keepalive，链路生命为5分钟（链路数据传输完成，保持5分钟的存活时间）。 自动清除线程，将超过5分钟的链路关闭socket。 OkHttp真正的连接是在ConnectInterceptor中通过 Transmitter（realC...
Okhttp的连接池ConnectionPool(三)
qq_37321098的博客
11-02 4339
目录 1.get()方法 2.put() Okhttp3使用及解析:https://mp.csdn.net/postedit/83339916 okhttp系统拦截器:https://mp.csdn.net/postedit/83536609 Okhttp的连接池ConnectionPool:https://mp.csdn.net/postedit/83650740   Okhttp...
OkHttp3源码详解之 okhttp连接池复用机制（一）
2401_84132272的博客
04-09 909
excutor : 线程池，用来检测闲置socket并对其进行清理。connections : connection缓存池。Deque是一个双端列表，支持在头尾插入元素，这里用作LIFO（后进先出）堆栈，多用于缓存数据。routeDatabase ：用来记录连接失败router。
AndroidStudio_A connection was leaked. Did you forget to close a response body?---Android原生开发工作笔记241
添柴程序猿的专栏
05-19 4193
下面是报错内容,使用okhttp,的时候报错的.这个不关闭,好像时间久了会报内存溢出错误. W/OkHttp: A connection to http://172.19.128.64:8061/ was leaked. Did you forget to close a response body? 比如,下面这样解决: //4.同步人脸库操作 private void faceAsync() { //1.这里去同步照片到人脸库 //String ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值