common-pool连接池GenericObjectPool源代码

最新推荐文章于 2020-11-04 14:36:45 发布
最新推荐文章于 2020-11-04 14:36:45 发布
阅读量6.7k 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luyee2010/article/details/17580359
版权 
package org.apache.commons.pool.impl;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.TimerTask;
import org.apache.commons.pool.BaseObjectPool;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.PoolUtils;
import org.apache.commons.pool.PoolableObjectFactory;

public class GenericObjectPool extends BaseObjectPool
  implements ObjectPool
{
  public static final byte WHEN_EXHAUSTED_FAIL = 0;
  public static final byte WHEN_EXHAUSTED_BLOCK = 1;
  public static final byte WHEN_EXHAUSTED_GROW = 2;
  public static final int DEFAULT_MAX_IDLE = 8;
  public static final int DEFAULT_MIN_IDLE = 0;
  public static final int DEFAULT_MAX_ACTIVE = 8;
  public static final byte DEFAULT_WHEN_EXHAUSTED_ACTION = 1;
  public static final boolean DEFAULT_LIFO = true;
  public static final long DEFAULT_MAX_WAIT = -1L;
  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 int DEFAULT_NUM_TESTS_PER_EVICTION_RUN = 3;
  public static final long DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS = 1800000L;
  public static final long DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS = -1L;
  private int _maxIdle = 8;

  private int _minIdle = 0;

  private int _maxActive = 8;

  private long _maxWait = -1L;

  private byte _whenExhaustedAction = 1;

  private volatile boolean _testOnBorrow = false;

  private volatile boolean _testOnReturn = false;

  private boolean _testWhileIdle = false;

  private long _timeBetweenEvictionRunsMillis = -1L;

  private int _numTestsPerEvictionRun = 3;

  private long _minEvictableIdleTimeMillis = 1800000L;

  private long _softMinEvictableIdleTimeMillis = -1L;

  private boolean _lifo = true;

  private CursorableLinkedList _pool = null;

  private CursorableLinkedList.Cursor _evictionCursor = null;

  private PoolableObjectFactory _factory = null;

  private int _numActive = 0;

  private Evictor _evictor = null;

  private int _numInternalProcessing = 0;

  private final LinkedList _allocationQueue = new LinkedList();

  public GenericObjectPool()
  {
    this(null, 8, (byte)1, -1L, 8, 0, false, false, -1L, 3, 1800000L, false);
  }

  public GenericObjectPool(PoolableObjectFactory factory)
  {
    this(factory, 8, (byte)1, -1L, 8, 0, false, false, -1L, 3, 1800000L, false);
  }

  public GenericObjectPool(PoolableObjectFactory factory, Config config)
  {
    this(factory, config.maxActive, config.whenExhaustedAction, config.maxWait, config.maxIdle, config.minIdle, config.testOnBorrow, config.testOnReturn, config.timeBetweenEvictionRunsMillis, config.numTestsPerEvictionRun, config.minEvictableIdleTimeMillis, config.testWhileIdle, config.softMinEvictableIdleTimeMillis, config.lifo);
  }

  public GenericObjectPool(PoolableObjectFactory factory, int maxActive)
  {
    this(factory, maxActive, (byte)1, -1L, 8, 0, false, false, -1L, 3, 1800000L, false);
  }

  public GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait)
  {
    this(factory, maxActive, whenExhaustedAction, maxWait, 8, 0, false, false, -1L, 3, 1800000L, false);
  }

  public GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, boolean testOnBorrow, boolean testOnReturn)
  {
    this(factory, maxActive, whenExhaustedAction, maxWait, 8, 0, testOnBorrow, testOnReturn, -1L, 3, 1800000L, false);
  }

  public GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle)
  {
    this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, 0, false, false, -1L, 3, 1800000L, false);
  }

  public GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn)
  {
    this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, 0, testOnBorrow, testOnReturn, -1L, 3, 1800000L, false);
  }

  public GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle)
  {
    this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, 0, testOnBorrow, testOnReturn, timeBetweenEvictionRunsMillis, numTestsPerEvictionRun, minEvictableIdleTimeMillis, testWhileIdle);
  }

  public GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle)
  {
    this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, minIdle, testOnBorrow, testOnReturn, timeBetweenEvictionRunsMillis, numTestsPerEvictionRun, minEvictableIdleTimeMillis, testWhileIdle, -1L);
  }

  public GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle, long softMinEvictableIdleTimeMillis)
  {
    this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, minIdle, testOnBorrow, testOnReturn, timeBetweenEvictionRunsMillis, numTestsPerEvictionRun, minEvictableIdleTimeMillis, testWhileIdle, softMinEvictableIdleTimeMillis, true);
  }

  public GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle, long softMinEvictableIdleTimeMillis, boolean lifo)
  {
    this._factory = factory;
    this._maxActive = maxActive;
    this._lifo = lifo;
    switch (whenExhaustedAction) {
    case 0:
    case 1:
    case 2:
      this._whenExhaustedAction = whenExhaustedAction;
      break;
    default:
      throw new IllegalArgumentException("whenExhaustedAction " + whenExhaustedAction + " not recognized.");
    }
    this._maxWait = maxWait;
    this._maxIdle = maxIdle;
    this._minIdle = minIdle;
    this._testOnBorrow = testOnBorrow;
    this._testOnReturn = testOnReturn;
    this._timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    this._numTestsPerEvictionRun = numTestsPerEvictionRun;
    this._minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    this._softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;
    this._testWhileIdle = testWhileIdle;

    this._pool = new CursorableLinkedList();
    startEvictor(this._timeBetweenEvictionRunsMillis);
  }

  public synchronized int getMaxActive()
  {
    return this._maxActive;
  }

  public synchronized void setMaxActive(int maxActive)
  {
    this._maxActive = maxActive;
    allocate();
  }

  public synchronized byte getWhenExhaustedAction()
  {
    return this._whenExhaustedAction;
  }

  public synchronized void setWhenExhaustedAction(byte whenExhaustedAction)
  {
    switch (whenExhaustedAction) {
    case 0:
    case 1:
    case 2:
      this._whenExhaustedAction = whenExhaustedAction;
      allocate();
      break;
    default:
      throw new IllegalArgumentException("whenExhaustedAction " + whenExhaustedAction + " not recognized.");
    }
  }

  public synchronized long getMaxWait()
  {
    return this._maxWait;
  }

  public synchronized void setMaxWait(long maxWait)
  {
    this._maxWait = maxWait;
    allocate();
  }

  public synchronized int getMaxIdle()
  {
    return this._maxIdle;
  }

  public synchronized void setMaxIdle(int maxIdle)
  {
    this._maxIdle = maxIdle;
    allocate();
  }

  public synchronized void setMinIdle(int minIdle)
  {
    this._minIdle = minIdle;
    allocate();
  }

  public synchronized int getMinIdle()
  {
    return this._minIdle;
  }

  public boolean getTestOnBorrow()
  {
    return this._testOnBorrow;
  }

  public void setTestOnBorrow(boolean testOnBorrow)
  {
    this._testOnBorrow = testOnBorrow;
  }

  public boolean getTestOnReturn()
  {
    return this._testOnReturn;
  }

  public void setTestOnReturn(boolean testOnReturn)
  {
    this._testOnReturn = testOnReturn;
  }

  public synchronized long getTimeBetweenEvictionRunsMillis()
  {
    return this._timeBetweenEvictionRunsMillis;
  }

  public synchronized void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis)
  {
    this._timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    startEvictor(this._timeBetweenEvictionRunsMillis);
  }

  public synchronized int getNumTestsPerEvictionRun()
  {
    return this._numTestsPerEvictionRun;
  }

  public synchronized void setNumTestsPerEvictionRun(int numTestsPerEvictionRun)
  {
    this._numTestsPerEvictionRun = numTestsPerEvictionRun;
  }

  public synchronized long getMinEvictableIdleTimeMillis()
  {
    return this._minEvictableIdleTimeMillis;
  }

  public synchronized void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis)
  {
    this._minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
  }

  public synchronized long getSoftMinEvictableIdleTimeMillis()
  {
    return this._softMinEvictableIdleTimeMillis;
  }

  public synchronized void setSoftMinEvictableIdleTimeMillis(long softMinEvictableIdleTimeMillis)
  {
    this._softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;
  }

  public synchronized boolean getTestWhileIdle()
  {
    return this._testWhileIdle;
  }

  public synchronized void setTestWhileIdle(boolean testWhileIdle)
  {
    this._testWhileIdle = testWhileIdle;
  }

  public synchronized boolean getLifo()
  {
    return this._lifo;
  }

  public synchronized void setLifo(boolean lifo)
  {
    this._lifo = lifo;
  }

  public synchronized void setConfig(Config conf)
  {
    setMaxIdle(conf.maxIdle);
    setMinIdle(conf.minIdle);
    setMaxActive(conf.maxActive);
    setMaxWait(conf.maxWait);
    setWhenExhaustedAction(conf.whenExhaustedAction);
    setTestOnBorrow(conf.testOnBorrow);
    setTestOnReturn(conf.testOnReturn);
    setTestWhileIdle(conf.testWhileIdle);
    setNumTestsPerEvictionRun(conf.numTestsPerEvictionRun);
    setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);
    setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);
    setSoftMinEvictableIdleTimeMillis(conf.softMinEvictableIdleTimeMillis);
    setLifo(conf.lifo);
    allocate();
  }

  public Object borrowObject()
    throws Exception
  {
    long starttime = System.currentTimeMillis();
    Latch latch = new Latch(null);
    byte whenExhaustedAction;
    long maxWait;
    synchronized (this)
    {
      whenExhaustedAction = this._whenExhaustedAction;
      maxWait = this._maxWait;

      this._allocationQueue.add(latch);

      allocate();
    }
    while (true)
    {
      synchronized (this) {
        assertOpen();
      }

      if (latch.getPair() == null)
      {
        if (!latch.mayCreate())
        {
          switch (whenExhaustedAction)
          {
          case 2:
            synchronized (this)
            {
              if ((latch.getPair() == null) && (!latch.mayCreate())) {
                this._allocationQueue.remove(latch);
                this._numInternalProcessing += 1;
              }
            }
            break;
          case 0:
            synchronized (this)
            {
              if ((latch.getPair() == null) && (latch.mayCreate())) {
                break label497;
              }
              this._allocationQueue.remove(latch);
            }
            throw new NoSuchElementException("Pool exhausted");
          case 1:
            try {
              synchronized (latch)
              {
                if ((latch.getPair() == null) && (!latch.mayCreate())) {
                  if (maxWait <= 0L) {
                    latch.wait();
                  }
                  else
                  {
                    long elapsed = System.currentTimeMillis() - starttime;
                    long waitTime = maxWait - elapsed;
                    if (waitTime > 0L)
                    {
                      latch.wait(waitTime);
                    }
                  }
                }
                else break label497; 
              }
            }
            catch (InterruptedException e)
            {
              synchronized (this)
              {
                if ((latch.getPair() == null) && (!latch.mayCreate()))
                {
                  this._allocationQueue.remove(latch);
                }
                else break label497;
              }

              Thread.currentThread().interrupt();
              throw e;
            }
            if ((maxWait <= 0L) || (System.currentTimeMillis() - starttime < maxWait)) continue;
            synchronized (this)
            {
              if ((latch.getPair() == null) && (!latch.mayCreate()))
              {
                this._allocationQueue.remove(latch);
              }
              else break label497;
            }

            throw new NoSuchElementException("Timeout waiting for idle object");
          default:
            throw new IllegalArgumentException("WhenExhaustedAction property " + whenExhaustedAction + " not recognized.");
          }
        }
      }
      else
      {
        label497: boolean newlyCreated = false;
        if (null == latch.getPair()) {
          try {
            Object obj = this._factory.makeObject();
            latch.setPair(new GenericKeyedObjectPool.ObjectTimestampPair(obj));
            newlyCreated = true;
          } finally {
            if (!newlyCreated)
            {
              synchronized (this) {
                this._numInternalProcessing -= 1;

                allocate();
              }
            }
          }
        }
        try
        {
          this._factory.activateObject(latch.getPair().value);
          if ((this._testOnBorrow) && (!this._factory.validateObject(latch.getPair().value)))
          {
            throw new Exception("ValidateObject failed");
          }
          synchronized (this) {
            this._numInternalProcessing -= 1;
            this._numActive += 1;
          }
          return latch.getPair().value;
        }
        catch (Throwable e) {
          PoolUtils.checkRethrow(e);
          try
          {
            this._factory.destroyObject(latch.getPair().value);
          } catch (Throwable e2) {
            PoolUtils.checkRethrow(e2);
          }

          synchronized (this) {
            this._numInternalProcessing -= 1;
            if (!newlyCreated) {
              latch.reset();
              this._allocationQueue.add(0, latch);
            }
            allocate();
          }
          if (newlyCreated)
            throw new NoSuchElementException("Could not create a validated object, cause: " + e.getMessage());
        }
      }
    }
  }

  private synchronized void allocate()
  {
    if (isClosed()) return;

    while ((!this._pool.isEmpty()) && (!this._allocationQueue.isEmpty())) {
      Latch latch = (Latch)this._allocationQueue.removeFirst();
      latch.setPair((GenericKeyedObjectPool.ObjectTimestampPair)this._pool.removeFirst());
      this._numInternalProcessing += 1;
      synchronized (latch) {
        latch.notify();
      }

    }

    while ((!this._allocationQueue.isEmpty()) && ((this._maxActive < 0) || (this._numActive + this._numInternalProcessing < this._maxActive))) {
      Latch latch = (Latch)this._allocationQueue.removeFirst();
      latch.setMayCreate(true);
      this._numInternalProcessing += 1;
      synchronized (latch) {
        latch.notify();
      }
    }
  }

  public void invalidateObject(Object obj)
    throws Exception
  {
    try
    {
      if (this._factory != null)
        this._factory.destroyObject(obj);
    }
    finally {
      synchronized (this) {
        this._numActive -= 1;
        allocate();
      }
    }
  }

  public void clear()
  {
    List toDestroy = new ArrayList();

    synchronized (this) {
      toDestroy.addAll(this._pool);
      this._numInternalProcessing += this._pool._size;
      this._pool.clear();
    }
    destroy(toDestroy, this._factory);
  }

  private void destroy(Collection c, PoolableObjectFactory factory)
  {
    for (Iterator it = c.iterator(); it.hasNext(); )
      try {
        factory.destroyObject(((GenericKeyedObjectPool.ObjectTimestampPair)it.next()).value);
      } catch (Exception e) {
      }
      finally {
        synchronized (this) {
          this._numInternalProcessing -= 1;
          allocate();
        }
      }
  }

  public synchronized int getNumActive()
  {
    return this._numActive;
  }

  public synchronized int getNumIdle()
  {
    return this._pool.size();
  }

  public void returnObject(Object obj)
    throws Exception
  {
    try
    {
      addObjectToPool(obj, true);
    } catch (Exception e) {
      if (this._factory != null) {
        try {
          this._factory.destroyObject(obj);
        }
        catch (Exception e2)
        {
        }

        synchronized (this) {
          this._numActive -= 1;
          allocate();
        }
      }
    }
  }

  private void addObjectToPool(Object obj, boolean decrementNumActive)
    throws Exception
  {
    boolean success = true;
    if ((this._testOnReturn) && (!this._factory.validateObject(obj)))
      success = false;
    else {
      this._factory.passivateObject(obj);
    }

    boolean shouldDestroy = !success;

    synchronized (this) {
      if (isClosed()) {
        shouldDestroy = true;
      }
      else if ((this._maxIdle >= 0) && (this._pool.size() >= this._maxIdle)) {
        shouldDestroy = true;
      } else if (success)
      {
        if (this._lifo)
          this._pool.addFirst(new GenericKeyedObjectPool.ObjectTimestampPair(obj));
        else {
          this._pool.addLast(new GenericKeyedObjectPool.ObjectTimestampPair(obj));
        }
        if (decrementNumActive) {
          this._numActive -= 1;
        }
        allocate();
      }

    }

    if (shouldDestroy) {
      try {
        this._factory.destroyObject(obj);
      }
      catch (Exception e)
      {
      }
      if (decrementNumActive)
        synchronized (this) {
          this._numActive -= 1;
          allocate();
        }
    }
  }

  public void close()
    throws Exception
  {
    super.close();
    synchronized (this) {
      clear();
      startEvictor(-1L);
    }
  }

  /** @deprecated */
  public void setFactory(PoolableObjectFactory factory)
    throws IllegalStateException
  {
    List toDestroy = new ArrayList();
    PoolableObjectFactory oldFactory = this._factory;
    synchronized (this) {
      assertOpen();
      if (0 < getNumActive()) {
        throw new IllegalStateException("Objects are already active");
      }
      toDestroy.addAll(this._pool);
      this._numInternalProcessing += this._pool._size;
      this._pool.clear();

      this._factory = factory;
    }
    destroy(toDestroy, oldFactory);
  }

  public void evict()
    throws Exception
  {
    assertOpen();
    synchronized (this) {
      if (this._pool.isEmpty()) {
        return;
      }
      if (null == this._evictionCursor) {
        this._evictionCursor = this._pool.cursor(this._lifo ? this._pool.size() : 0);
      }
    }

    int i = 0; for (int m = getNumTests(); i < m; i++)
    {
      GenericKeyedObjectPool.ObjectTimestampPair pair;
      synchronized (this) {
        if (((this._lifo) && (!this._evictionCursor.hasPrevious())) || ((!this._lifo) && (!this._evictionCursor.hasNext())))
        {
          this._evictionCursor.close();
          this._evictionCursor = this._pool.cursor(this._lifo ? this._pool.size() : 0);
        }

        pair = this._lifo ? (GenericKeyedObjectPool.ObjectTimestampPair)this._evictionCursor.previous() : (GenericKeyedObjectPool.ObjectTimestampPair)this._evictionCursor.next();

        this._evictionCursor.remove();
        this._numInternalProcessing += 1;
      }

      boolean removeObject = false;
      long idleTimeMilis = System.currentTimeMillis() - pair.tstamp;
      if ((getMinEvictableIdleTimeMillis() > 0L) && (idleTimeMilis > getMinEvictableIdleTimeMillis()))
      {
        removeObject = true;
      } else if ((getSoftMinEvictableIdleTimeMillis() > 0L) && (idleTimeMilis > getSoftMinEvictableIdleTimeMillis()) && (getNumIdle() + 1 > getMinIdle()))
      {
        removeObject = true;
      }
      if ((getTestWhileIdle()) && (!removeObject)) {
        boolean active = false;
        try {
          this._factory.activateObject(pair.value);
          active = true;
        } catch (Exception e) {
          removeObject = true;
        }
        if (active) {
          if (!this._factory.validateObject(pair.value))
            removeObject = true;
          else {
            try {
              this._factory.passivateObject(pair.value);
            } catch (Exception e) {
              removeObject = true;
            }
          }
        }
      }

      if (removeObject)
        try {
          this._factory.destroyObject(pair.value);
        }
        catch (Exception e)
        {
        }
      synchronized (this) {
        if (!removeObject) {
          this._evictionCursor.add(pair);
          if (this._lifo)
          {
            this._evictionCursor.previous();
          }
        }
        this._numInternalProcessing -= 1;
      }
    }
  }

  private void ensureMinIdle()
    throws Exception
  {
    int objectDeficit = calculateDeficit(false);
    for (int j = 0; (j < objectDeficit) && (calculateDeficit(true) > 0); j++)
      try {
        addObject();
      } finally {
        synchronized (this) {
          this._numInternalProcessing -= 1;
          allocate();
        }
      }
  }

  private synchronized int calculateDeficit(boolean incrementInternal)
  {
    int objectDeficit = getMinIdle() - getNumIdle();
    if (this._maxActive > 0) {
      int growLimit = Math.max(0, getMaxActive() - getNumActive() - getNumIdle() - this._numInternalProcessing);

      objectDeficit = Math.min(objectDeficit, growLimit);
    }
    if ((incrementInternal) && (objectDeficit > 0)) {
      this._numInternalProcessing += 1;
    }
    return objectDeficit;
  }

  public void addObject()
    throws Exception
  {
    assertOpen();
    if (this._factory == null) {
      throw new IllegalStateException("Cannot add objects without a factory.");
    }
    Object obj = this._factory.makeObject();
    try {
      assertOpen();
      addObjectToPool(obj, false);
    } catch (IllegalStateException ex) {
      try {
        this._factory.destroyObject(obj);
      }
      catch (Exception ex2) {
      }
      throw ex;
    }
  }

  protected synchronized void startEvictor(long delay)
  {
    if (null != this._evictor) {
      EvictionTimer.cancel(this._evictor);
      this._evictor = null;
    }
    if (delay > 0L) {
      this._evictor = new Evictor(null);
      EvictionTimer.schedule(this._evictor, delay, delay);
    }
  }

  synchronized String debugInfo()
  {
    StringBuffer buf = new StringBuffer();
    buf.append("Active: ").append(getNumActive()).append("\n");
    buf.append("Idle: ").append(getNumIdle()).append("\n");
    buf.append("Idle Objects:\n");
    Iterator it = this._pool.iterator();
    long time = System.currentTimeMillis();
    while (it.hasNext()) {
      GenericKeyedObjectPool.ObjectTimestampPair pair = (GenericKeyedObjectPool.ObjectTimestampPair)it.next();
      buf.append("\t").append(pair.value).append("\t").append(time - pair.tstamp).append("\n");
    }
    return buf.toString();
  }

  private int getNumTests()
  {
    if (this._numTestsPerEvictionRun >= 0) {
      return Math.min(this._numTestsPerEvictionRun, this._pool.size());
    }
    return (int)Math.ceil(this._pool.size() / Math.abs(this._numTestsPerEvictionRun));
  }

  private static final class Latch
  {
    private GenericKeyedObjectPool.ObjectTimestampPair _pair;
    private boolean _mayCreate = false;

    private Latch()
    {
    }

    private synchronized GenericKeyedObjectPool.ObjectTimestampPair getPair() {
      return this._pair;
    }

    private synchronized void setPair(GenericKeyedObjectPool.ObjectTimestampPair pair)
    {
      this._pair = pair;
    }

    private synchronized boolean mayCreate()
    {
      return this._mayCreate;
    }

    private synchronized void setMayCreate(boolean mayCreate)
    {
      this._mayCreate = mayCreate;
    }

    private synchronized void reset()
    {
      this._pair = null;
      this._mayCreate = false;
    }

    Latch(GenericObjectPool.1 x0)
    {
      this();
    }
  }

  public static class Config
  {
    public int maxIdle = 8;

    public int minIdle = 0;

    public int maxActive = 8;

    public long maxWait = -1L;

    public byte whenExhaustedAction = 1;

    public boolean testOnBorrow = false;

    public boolean testOnReturn = false;

    public boolean testWhileIdle = false;

    public long timeBetweenEvictionRunsMillis = -1L;

    public int numTestsPerEvictionRun = 3;

    public long minEvictableIdleTimeMillis = 1800000L;

    public long softMinEvictableIdleTimeMillis = -1L;

    public boolean lifo = true;
  }

  private class Evictor extends TimerTask
  {
    private Evictor()
    {
    }

    public void run()
    {
      try
      {
        GenericObjectPool.this.evict();
      }
      catch (Exception e)
      {
      }
      catch (OutOfMemoryError oome) {
        oome.printStackTrace(System.err);
      }
      try {
        GenericObjectPool.this.ensureMinIdle();
      }
      catch (Exception e)
      {
      }
    }

    Evictor(GenericObjectPool.1 x1)
    {
      this();
    }
  }
}

luyee2010
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
commo-pool, commons-pool commons-pool commons-pool
01-28
Apache Commons Pool 2是该库的最新版本，这里提供的两个压缩文件`commons-pool2-2.11.1-bin.zip`和`commons-pool2-2.11.1-src.zip`分别包含了编译后的二进制库和源代码。`bin.zip`文件通常包含编译好的JAR文件和...
redis3.2+jedis2.8.jar+common-pool2.jar+common-pool2-source.rar
09-22
Common-Pool2-source.rar则包含了Common-Pool2的源代码，开发者可以通过阅读源码来了解其内部工作原理，进行更深入的定制或优化。 在使用Redis3.2+jedis2.8.jar进行Java开发时，首先需要在项目中引入Jedis库，配置...
对象池common-pool源码分析
温水青蛙
07-30 1152
public class GenericObjectPool extends BaseObjectPool implements ObjectPool { public Object borrowObject() throws Exception { //pool会一直borrow直到创建成功  for(;;) { if(latch.getPai
Apache Commons-Pool 源码分析
齐中飞的专栏
11-22 1653
Commons-Pool 首先看下两个重要的类结构：   ObjectPool defines a simple pooling interface. GenericObjectPool: ObjectPool implementation with configurable LIFO/FIFO behavior. The default behavior is for the
java对象池GenericObjectPool
u011649691的博客
11-22 3505
GenericObjectPool是apache提供的对象池，可以方便的对对象进行管理（获取，归还，检查是否活跃，检查是否可用等）。通常我们用它来做连接池，比如socket连接池： GenericObjectPool重点需要关注：PooledObjectFactory和GenericObjectPoolConfig。 PooledObjectFactory中定义了如下接口： //创建对象需要的工作...
GenericObjectPool
wind35的专栏
03-15 291
在我们的项目中往往有这样的需求:我们需要用的一些对象是thread-unsafe的，但是它又承受着高并发的压力，同时往往我们有可能无法去对它改造(或许它是第3方提供的)；抑或他的一次创建和销毁非常的耗时。以上两种场景的解决方案用对象池再适合不过了。 本文将解答一下几个问题: #1什么是对象池 #2怎么使用对象池 #3其实用原理是什么 #4实战中应该注意...
jakata common pools 源码研究
element1999的专栏
03-11 872
    前几天和同事聊天，同事做c＋＋的，聊到c＋＋没有很好的数据库连接池库，同事想自己写一个，但担心自己考虑不全面。我不以为然，数据库连接池而已，又不是没写过，没有open source之前，还不是自己写。同事却认为定我考虑的不全面。所以，才找来jakata common pools的源码看看。 jakata common pools中主要就以下三个接口   ObjectPool   连接池
commons-pool2-2.4.2.jar
07-14
Apache Commons Pool2是一个Java对象池库，用于管理资源对象，如数据库连接或网络套接字。这个库的主要目的是提高性能和资源效率，通过重用已创建的对象而不是每次需要时都创建新的。在给定的场景中，`commons-pool2...
commons-dbcp.jar、commons-pool.jar
01-28
标题中的"commons-dbcp.jar"和"commons-pool.jar"是两个重要的Java库，它们主要用于数据库连接池管理。Apache Commons DBCP（Database Connection Pool）是Apache组织开发的一个开源数据库连接池组件，而Apache ...
commons-pool2-2.8.1.jar
07-06
Apache Commons Pool 2 提供了两种主要的对象池实现：`GenericObjectPool`和`GenericKeyedObjectPool`。前者用于管理单类型对象的池，后者则适用于管理键值对形式的对象。这两种池都提供了丰富的配置选项，包括最大...
GenericObjectPool源码分析
xiaolegeaizy的博客
11-04 931
说实话对这个了解甚少，在拜读大佬的代码时看到的，觉得应该为我所用，就百度了一下相关知识。说实话直接看这个有点抽象，后面会慢慢补充相关使用实践。 apache提供了三种对象池：GenericKeyedObjectPool，SoftReferenceObjectPool和GenericObjectPool，其中GenericObjectPool是我们最常用的对象池，内部实现也最复杂，本文讲解其实现原理。 GenericObjectPool实现了ObjectPool<T>接口，而ObjectPoo
DBCP连接池耗尽问题
lyly630的博客
10-24 2151
问题描述 使用DBCP连接池。每当访问数据库超时，永久占用数据库连接池的一个连接数。多次超时发生后，数据库连接池耗尽，后续的数据库请求拿不到数据库连接，全部hang住。 代码分析 1 数据库访问获取连接 DBCP连接池构建了GenericObjectPool，通过GenericObjectPool来管理数据库连接。当数据库访问发生时，通过GenericObjectPool.borrowOb...
对象池（连接池）：commons-pool2源码解析：GenericObjectPool的addObject、create方法解析
老艮头的后知后觉
08-02 1280
为什么会有对象池 在实际的应用工程当中，存在一些被频繁使用的、创建或者销毁比较耗时、持有的资源也比较昂贵的一些对象。比如：数据库连接对象、线程对象。所以如果能够通过一种方式，把这类对象统一管理，让这类对象可以被循环利用的话，就可以减少很多系统开销（内存、CPU、IO等），极大的提升应用性能。 Apache Commons Pool Apache Commons Pool就是一个对象池的框架，他提供了一整套用于实现对象池化的API，以及若干种各具特色的对象池实现。Apache Commons Pool是很多连
commons.pool2 对象池的使用
weixin_34034670的博客
03-25 227
2019独角兽企业重金招聘Python工程师标准>>> ...
连接池频繁访问数据库导致 Timeout waiting for idle object
信徒博客
10-18 2万+
解决方案：
利用commons-pool2自定义对象池
lan墨的博客
05-12 1万+
利用commons-pool2自定义资源池 commons-pool2是Apache下一个开源的公共资源池。我们可以根据它来快速的建立一个自己的资源池。 1. 相关概念: 此处连接池并不单指链接对象的池子，泛指某一对象的对象池.通常打开或者关闭一个链接是十分耗时的事情,如果能将链接缓存起来重复使用就能节省很多时间. 链接池/对象池(ObjectPool):用于存放链接对象的一个池子(集合
Apache commons-pool2-2.4.2源码学习笔记
猿类崛起
11-16 849
1.背景 最近查看了下Apache commons-pool2的源代码commons-pool2-2.4.2，代码不多，大概50个java类左右，阅读源代码的初衷是为了通过不断的学习和总结，升华自己的技术能力，写此博客是为了给自己留下一点笔记，日后能够温故知新。 Apache commons-pool2类库是对象池技术的一种具体实现，它的出现是为了解决频繁...
commons-pool2中GenericKeyedObjectPool对象池
niyuelin1990的博客
05-15 4986
commons-pool 对象池 commons-pool 中实现了多个对象池类，对象池类可以用于数据库连接池，tcp客户端池。 maven依赖： &lt;dependency&gt; &lt;groupId&gt;org.apache.commons&lt;/groupId&gt; &lt;artifactId&gt;commons-pool2&lt;/artifactId...
org/apache/commons/pool/impl/GenericObjectPool 的解决方法
热门推荐
丁辉-blog
10-31 4万+
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).log4j:WARN Please initialize the log4j system properly.Exception in threa
commons-pool2加入ftp链接池
最新发布
12-07
commons-pool2是一个用于对象池化的开源库，可以帮助用户管理和维护对象池，提高对象的重用率和性能。要加入ftp链接池，可以通过以下步骤完成： 1. 导入commons-pool2库：在项目中导入commons-pool2库的jar包，可以通过maven或者gradle等工具进行依赖管理。 2. 创建ftp链接工厂：使用commons-pool2提供的对象池工厂类GenericObjectPool，创建一个ftp链接对象池工厂。可以根据需要设置链接对象的最大数量、最小空闲数量、最大空闲数量等参数。 3. 实现ftp链接池对象：创建一个类来实现ftp链接对象池，该类需要实现org.apache.commons.pool2.PooledObjectFactory接口，在其中实现创建、销毁、激活和钝化ftp链接对象的方法。 4. 使用ftp链接池：在需要使用ftp链接的地方，通过ftp链接池工厂获取ftp链接对象，使用完毕后将对象归还给ftp链接池。 通过以上步骤，我们就可以将commons-pool2集成到ftp链接池中，实现ftp链接的对象池化管理。这样可以减少创建和销毁ftp链接的开销，提高系统对ftp链接的利用率，同时可以有效地控制ftp链接的数量，防止链接泄露和资源浪费。最终能够提升系统的性能和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值