JedisPool源码解析

最新推荐文章于 2025-01-06 21:03:24 发布
最新推荐文章于 2025-01-06 21:03:24 发布
阅读量941 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangyang1354/article/details/76168041
版权

JedisPoolConfig的继承结构

这个BaseObjectPoolConfig中无非是一部分常量和私有的变量。

 

public abstract class BaseObjectPoolConfig implements Cloneable {
    public static final boolean DEFAULT_LIFO = true;
    public static final boolean DEFAULT_FAIRNESS = false;
    public static final long DEFAULT_MAX_WAIT_MILLIS = -1L;
    public static final long DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS = 1800000L;
    public static final long DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS = -1L;
    public static final int DEFAULT_NUM_TESTS_PER_EVICTION_RUN = 3;
    public static final boolean DEFAULT_TEST_ON_CREATE = false;
    public static final boolean DEFAULT_TEST_ON_BORROW = false;
    public static final boolean DEFAULT_TEST_ON_RETURN = false;
    public static final boolean DEFAULT_TEST_WHILE_IDLE = false;
    public static final long DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS = -1L;
    public static final boolean DEFAULT_BLOCK_WHEN_EXHAUSTED = true;
    public static final boolean DEFAULT_JMX_ENABLE = true;
    public static final String DEFAULT_JMX_NAME_PREFIX = "pool";
    public static final String DEFAULT_JMX_NAME_BASE = null;
    public static final String DEFAULT_EVICTION_POLICY_CLASS_NAME = "org.apache.commons.pool2.impl.DefaultEvictionPolicy";
    private boolean lifo = true;
    private boolean fairness = false;
    private long maxWaitMillis = -1L;
    private long minEvictableIdleTimeMillis = 1800000L;
    private long softMinEvictableIdleTimeMillis = 1800000L;
    private int numTestsPerEvictionRun = 3;
    private String evictionPolicyClassName = "org.apache.commons.pool2.impl.DefaultEvictionPolicy";
    private boolean testOnCreate = false;
    private boolean testOnBorrow = false;
    private boolean testOnReturn = false;
    private boolean testWhileIdle = false;
    private long timeBetweenEvictionRunsMillis = -1L;
    private boolean blockWhenExhausted = true;
    private boolean jmxEnabled = true;
    private String jmxNamePrefix = "pool";
    private String jmxNameBase = "pool";


然后它的子类补充了部分的常量和变量。

 

 

public class GenericObjectPoolConfig extends BaseObjectPoolConfig {
    public static final int DEFAULT_MAX_TOTAL = 8;
    public static final int DEFAULT_MAX_IDLE = 8;
    public static final int DEFAULT_MIN_IDLE = 0;
    private int maxTotal = 8;
    private int maxIdle = 8;
    private int minIdle = 0;

然后实际初始化的是其构造方法。都是写死的。

 

 

public JedisPoolConfig() {
        this.setTestWhileIdle(true);
        this.setMinEvictableIdleTimeMillis(60000L);
        this.setTimeBetweenEvictionRunsMillis(30000L);
        this.setNumTestsPerEvictionRun(-1);
    }

 

例子

 JedisPoolConfig config = new JedisPoolConfig();
        config.setTestOnBorrow(true);
        pool = new JedisPool(config, "", 2181, 2000, "foobared");
        jedis = pool.getResource();
        jedis.set("foo", "bar");
        jedis.close();

 

Config部分创建了一个配置项实例。

 

设置部分参数可以。

然后这个地方创建了一个JedisPool的实例，这个实例，

    public JedisPool(GenericObjectPoolConfig poolConfig, String host, int port, int timeout, String password, int database) {
        this(poolConfig, host, port, timeout, password, database, (String)null);
    }

    public JedisPool(GenericObjectPoolConfig poolConfig, String host, int port, int timeout, String password, int database, String clientName) {
        super(poolConfig, new JedisFactory(host, port, timeout, password, database, clientName));
    }

JedisPool调用了父类的方法、

集成体系，JedisPool继承自Pool这个类，

 

    public Pool(GenericObjectPoolConfig poolConfig, PooledObjectFactory<T> factory) {
        this.initPool(poolConfig, factory);
    }

    public void initPool(GenericObjectPoolConfig poolConfig, PooledObjectFactory<T> factory) {
        if (this.internalPool != null) {
            try {
                this.closeInternalPool();
            } catch (Exception var4) {
                ;
            }
        }
        this.internalPool = new GenericObjectPool(factory, poolConfig);
    }

调用Pool中的初始化pool方法。

 

这个方法中是调用了

 
GenericObjectPool
 
/** * Create a new <code>GenericObjectPool</code> using a specific * configuration. */ public GenericObjectPool(PooledObjectFactory<T> factory, GenericObjectPoolConfig config) { super(config, ONAME_BASE, config.getJmxNamePrefix()); if (factory == null) { jmxUnregister(); // tidy up throw new IllegalArgumentException("factory may not be null"); } this.factory = factory; idleObjects = new LinkedBlockingDeque<PooledObject<T>>(config.getFairness()); setConfig(config); startEvictor(getTimeBetweenEvictionRunsMillis());// 延迟一定的时间后设置逐出者。 }

初始化的GenericObjectPool

注意这里的重点是使用了LinkedBlockingDeque了，也就是双向链表实现的双端队列。空闲的连接放在这里面。
 
 
JedisPool中的方法。
getResource部分
获取空闲的连接、
 
public Jedis getResource() { Jedis jedis = (Jedis)super.getResource(); jedis.setDataSource(this); return jedis; } 
 

调用了Pool中的方法。

    public T getResource() {
        try {
            return this.internalPool.borrowObject();
        } catch (Exception var2) {
            throw new JedisConnectionException("Could not get a resource from the pool", var2);
        }
    }

调用GenericObjectPool中的方法

 
@Override public T borrowObject() throws Exception { return borrowObject(getMaxWaitMillis()); }

 

 

    public T borrowObject(long borrowMaxWaitMillis) throws Exception {
        assertOpen();

        AbandonedConfig ac = this.abandonedConfig;
        if (ac != null && ac.getRemoveAbandonedOnBorrow() &&
                (getNumIdle() < 2) &&
                (getNumActive() > getMaxTotal() - 3) ) {
            removeAbandoned(ac);
        }

        PooledObject<T> p = null;

        // Get local copy of current config so it is consistent for entire
        // method execution
        boolean blockWhenExhausted = getBlockWhenExhausted();

        boolean create;
        long waitTime = System.currentTimeMillis();

        while (p == null) {
            create = false;
            if (blockWhenExhausted) {
                p = idleObjects.pollFirst();
                if (p == null) {
                    p = create();
                    if (p != null) {
                        create = true;
                    }
                }
                if (p == null) {
                    if (borrowMaxWaitMillis < 0) {
                        p = idleObjects.takeFirst();
                    } else {
                        p = idleObjects.pollFirst(borrowMaxWaitMillis,
                                TimeUnit.MILLISECONDS);
                    }
                }
                if (p == null) {
                    throw new NoSuchElementException(
                            "Timeout waiting for idle object");
                }
                if (!p.allocate()) {
                    p = null;
                }
            } else {
                p = idleObjects.pollFirst();
                if (p == null) {
                    p = create();
                    if (p != null) {
                        create = true;
                    }
                }
                if (p == null) {
                    throw new NoSuchElementException("Pool exhausted");
                }
                if (!p.allocate()) {
                    p = null;
                }
            }

            if (p != null) {
                try {
                    factory.activateObject(p);
                } catch (Exception e) {
                    try {
                        destroy(p);
                    } catch (Exception e1) {
                        // Ignore - activation failure is more important
                    }
                    p = null;
                    if (create) {
                        NoSuchElementException nsee = new NoSuchElementException(
                                "Unable to activate object");
                        nsee.initCause(e);
                        throw nsee;
                    }
                }
                if (p != null && (getTestOnBorrow() || create && getTestOnCreate())) {
                    boolean validate = false;
                    Throwable validationThrowable = null;
                    try {
                        validate = factory.validateObject(p);
                    } catch (Throwable t) {
                        PoolUtils.checkRethrow(t);
                        validationThrowable = t;
                    }
                    if (!validate) {
                        try {
                            destroy(p);
                            destroyedByBorrowValidationCount.incrementAndGet();
                        } catch (Exception e) {
                            // Ignore - validation failure is more important
                        }
                        p = null;
                        if (create) {
                            NoSuchElementException nsee = new NoSuchElementException(
                                    "Unable to validate object");
                            nsee.initCause(validationThrowable);
                            throw nsee;
                        }
                    }
                }
            }
        }

        updateStatsBorrow(p, System.currentTimeMillis() - waitTime);// 这里还带了延时的功能

        return p.getObject();
    }pollFirst(borrowMaxWaitMillis,
                                TimeUnit.MILLISECONDS);
                    }
                }
                if (p == null) {
                    throw new NoSuchElementException(
                            "Timeout waiting for idle object");
                }
                if (!p.allocate()) {
                    p = null;
                }
            } else {
                p = idleObjects.pollFirst();
                if (p == null) {
                    p = create();
                    if (p != null) {
                        create = true;
                    }
                }
                if (p == null) {
                    throw new NoSuchElementException("Pool exhausted");
                }
                if (!p.allocate()) {
                    p = null;
                }
            }

            if (p != null) {
                try {
                    factory.activateObject(p);
                } catch (Exception e) {
                    try {
                        destroy(p);
                    } catch (Exception e1) {
                        // Ignore - activation failure is more important
                    }
                    p = null;
                    if (create) {
                        NoSuchElementException nsee = new NoSuchElementException(
                                "Unable to activate object");
                        nsee.initCause(e);
                        throw nsee;
                    }
                }
                if (p != null && (getTestOnBorrow() || create && getTestOnCreate())) {
                    boolean validate = false;
                    Throwable validationThrowable = null;
                    try {
                        validate = factory.validateObject(p);
                    } catch (Throwable t) {
                        PoolUtils.checkRethrow(t);
                        validationThrowable = t;
                    }
                    if (!validate) {
                        try {
                            destroy(p);
                            destroyedByBorrowValidationCount.incrementAndGet();
                        } catch (Exception e) {
                            // Ignore - validation failure is more important
                        }
                        p = null;
                        if (create) {
                            NoSuchElementException nsee = new NoSuchElementException(
                                    "Unable to validate object");
                            nsee.initCause(validationThrowable);
                            throw nsee;
                        }
                    }
                }
            }
        }

        updateStatsBorrow(p, System.currentTimeMillis() - waitTime);// 这里还带了延时的功能

        return p.getObject();
    }


然后剩下的就是jedis本身的操作了。

 

 

 
最后理清思路，首先是创建一个JedisPool的实例，这个实例会调用父类Pool中的方法来创建Pool，然后这个Pool中有一个internalPool，使得其等于一个GenericJedisPool，然后这个pool实际上空闲的会存储在LinkedBlockingDeque中去，然后在getResource的时候，会调jedisPool的方法然后调用父类的方法然后调用GenericPool的方法，然后就可以直接获取到空闲线程了。
 
@Override public E pollFirst() { lock.lock(); try { return unlinkFirst(); } finally { lock.unlock(); } }

 

private E unlinkFirst() {
        // assert lock.isHeldByCurrentThread();
        Node<E> f = first;
        if (f == null) {
            return null;
        }
        Node<E> n = f.next;
        E item = f.item;
        f.item = null;
        f.next = f; // help GC
        first = n;
        if (n == null) {
            last = null;
        } else {
            n.prev = null;
        }
        --count;
        notFull.signal();
        return item;
    }

直接用的condition类的方法来实现的。

 
 

 

 

 

 

 

19_JedisPool连接池使用
2301_82300081的博客
01-11 40
这一节主要是围绕 JedisPool 的基本使用展开介绍的。首先介绍它是 Jedis 用于管理 Redis 连接的池化机制，因 Jedis 实例非线程安全，为避免多线程并发访问时创建过多连接消耗资源，引入 JedisPool 进行高效管理复用。
Jedis连接池：JedisPool及连接池工具类搭建
流楚丶格念的博客
09-14 3212
JedisPool的配置参数大部分是由JedisPoolConfig的对应项来赋值的，所以首先我们要设置JedisPoolConfig参数。设置完配置之后我们就可以去创建jedis的连接池了，使用的是JedisPoo构造函数。在resources创建jedis.properties配置文件。之后我们就可以通过getJedis获取连接池了。
JedisPool源码解析以及Jedis从缓冲池获取-释放资源
Isonion的博客
08-30 664
最后理清思路，首先是创建一个JedisPool的实例，这个实例会调用父类Pool中的方法来创建Pool，然后这个Pool中有一个internalPool，使得其等于一个GenericJedisPool，然后这个pool实际上空闲的会存储在LinkedBlockingDeque中去。然后在getResource的时候，会调jedisPool的方法然后调用父类（Pool）的方法然后调用GenericPool的方法，然后就可以直接获取到空闲线程了。然后这个地方创建了一个JedisPool的实例，这个实例，
jedis 2.9 jar包括源代码及common-pool
08-18
jedis 2.9jar包括源代码及common-pool 下面是官方地址，不用积分： https://github.com/xetorthio/jedis http://mvnrepository.com/artifact/redis.clients/jedis/2.9.0
源码解析：探究JedisPool与CommonRedis的性能差异
过客别墅
12-10 539
实习的第一个项目是实现一个秒杀系统，一开始没用工程中已分装好的CommonRedis，直接手撸了一个原生jedis实现，后期优化时改成了通过CommonRedis实现，结果QPS反而下降了，遂进行源码分析探究性能下降原因 测试结果 利用ab进行并发测试，均为10w请求，分为1000并发场景和100并发场景，每个场景测试两次取平均值，涉及四个redis操作，hget，lpop，lpush，hsetn...
jedis源码分析——JedisPool
11-28 236
jedis是Redis官网推荐的java客户端实现。下面分析一下JedisPool的实现   JedisPool源码如下： package redis.clients.jedis; import org.apache.commons.pool.impl.GenericObjectPool.Config; import redis.clients.util.Pool; pu...
jedisPool实现原理及源码分析(1)----对象池的说明
weixin_30696427的博客
03-09 179
redis的并发竞争问题如何解决? 　　Redis为单进程单线程模式，采用队列模式将并发访问变为串行访问。Redis本身没有锁的概念，Redis对于多个客户端连接并不存在竞争，但是在Jedis客户端对Redis进行并发访问时会发生连接超时、数据转换错误、阻塞、客户端关闭连接等问题，这些问题均是由于客户端连接混乱造成。对此有2种解决方法：1.客户端角度，为保证每个客户端间正常有序与Redis进行通...
jedis 源码阅读二——jedisPool
张硕的博客
01-17 2708
我们从这段代码分析jedisPool:JedisPool @Test public void checkJedisIsReusedWhenReturned() { JedisPool pool = new JedisPool(new JedisPoolConfig(), hnp.getHost(), hnp.getPort()); Jedis jedis = pool.getRe
Jedis源码深度解析：连接池与命令操作
5. **JedisPool源码分析**： - JedisPool基于Apache的`GenericObjectPool`，它是一个通用的对象池实现，用于管理Jedis实例。 - `LinkedBlockingDeque`是内部用于存储和管理连接的队列，它提供高效的并发访问，支持...
Jedis2.1.0源码与Jar包
10-30
`配置连接池参数，然后`JedisPool pool = new JedisPool(config, "localhost", 6379);`创建连接池，`Jedis jedis = pool.getResource();`获取连接，操作完成后使用`jedis.close();`归还连接。 ### Jedis与Redis其他...
jedis 2.1源码
08-19
1. **连接管理**：Jedis提供了连接池功能，通过`JedisPool`和`JedisPoolConfig`类来管理和配置连接池。连接池可以有效地复用连接，减少创建和销毁连接的开销，提高系统性能。 2. **命令执行**：Jedis封装了大量的...
jedis-3.0.0源码
12-27
《Jedis 3.0.0源码解析：探索Redis数据结构服务器的底层奥秘》 Redis，一个高性能、开源的内存数据结构服务器，凭借其丰富的数据类型、强大的性能以及灵活的应用场景，深受广大开发者喜爱。Jedis是Java社区中广泛...
jedis源码分析（二）-JedisPool连接池实现
fxdfxq的博客
06-14 2077
上一章节我们通过jedis学习了实现存放机制，本章节我们通过jedisPool的操作理解连接池的应用，jedisPool的源码实现。jedisPool连接池示例import java.text.SimpleDateFormat;import java.util.Date;import java.util.Random;import redis.clients.jedis.Jedis;import ...
Jedis和JedisPool
hh_include的博客
10-11 221
【代码】Jedis和JedisPool。
Java 客户端 Jedis和JedisPool 连接池
众人皆醉，唯我独醒
11-09 1530
Jedis客户端 jedis是java客户端 jedis.set("helloword"); &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artifactId&gt;jedis&lt;/artifactId&gt; &lt;version&gt;2.9.0&lt;/version&
JedisPool分析
烤鸭火锅的专栏
07-15 1367
jedis是Redis官网推荐的java客户端实现。下面分析一下JedisPool的实现   JedisPool源码如下： Java代码   package redis.clients.jedis;      import org.apache.commons.pool.impl.GenericObjectPool.Config;   import
JedisPool、JedisPooled傻傻分不清楚
最新发布
谷美的互联网练摊记
01-06 111
记一次测试中发现的 bug
java jedispool实例_redis学习及实践3---Jedis、JedisPool、Jedis分布式实例介绍
weixin_31925495的博客
02-24 378
一、相关jar包主要用到的是jedis的核心包，笔者用到的是2.1.0版；另根据“池”的应用等还需要用到相关jar包。下图是笔者建立的简单的jedis测试project图：jar包的文档可参考：二、简单的Jedis实例在引入相关jar包后，只要new一个Jedis对象，就能做redis相关操作了。以下是一个简单的jedis实例：三、JedisPool应用Jedis使用commons-pool完成池...
Redis学习笔记14、 JedisPool连接池学习
promiseful的博客
06-21 1313
一、介绍 1、Jedis开源库提供了一个负责管理Jedis连接对象的池，名为JedisPool类，位于redis.clients.jedis包中。为了防止数据库连接的频繁创建、销毁带来的性能损耗。 二、JedisPool的配置 JedisPoolConfig配置类，位于redis.clients.jedis包中。这个连接池的配置类负责配置JedisPool的参数。JedisPoolConfig配置类涉及到很多与连接管理和使用有关的参数。 1、maxTotal：资源池中最大的连接数 默认：8 2、maxIdl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值