mzhj
mzhj

使用Jakarta Commons Pool处理对象池化

简介： 恰当地使用对象池化技术，可以有效地减少对象生成和初始化时的消耗，提高系统的运行效率。Jakarta Commons Pool组件提供了一整套用于实现对象池化的框架，以及若干种各具特色的对象池实现，可以有效地减少处理对象池化时的工作量，为其它重要的工作留下更多的精力和时间。

<!-- <p class="ibm-no-print"> <div id="dw-tag-this" class="ibm-no-print"></div> <div id="interestShow" class="ibm-no-print"></div> </p> -->

 

标记本文！

 

发布日期： 2003 年 12 月 12 日
级别： 初级
访问情况 2644 次浏览
建议： 0 (添加评论) <!-- Rating_Area_Begin --><!-- Ensure that div id is based on input id and ends with -widget -->

1 star 2 stars 3 stars 4 stars 5 stars 平均分 （共 4 个评分 ）
<script type="text/javascript"></script><!-- Rating_Area_End -->

 

<!-- dW_Summary_Area_END --><!-- CONTENT_BODY -->
<!-- MAIN_COLUMN_BEGIN -->
<!-- Related_Searches_Area_And_Overlays_Begin --><!-- MAIN_COLUMN_CONTAINER_BEGIN -->
<!-- MAIN_COLUMN_CONTENT_BEGIN -->

创建新的对象并初始化的操作，可能会消耗很多的时间。在这种对象的初始化工作包含了一些费时的操作（例如，从一台位于20,000千米以外的主机上读出一些数据）的时候，尤其是这样。在需要大量生成这样的对象的时候，就可能会对性能造成一些不可忽略的影响。要缓解这个问题，除了选用更好的硬件和更棒的虚拟机以外，适当地采用一些能够减少对象创建次数的编码技巧，也是一种有效的对策。对象池化技术（Object Pooling）就是这方面的著名技巧，而Jakarta Commons Pool组件则是处理对象池化的得力外援。

对象池化技术

对象池化的基本思路是：将用过的对象保存起来，等下一次需要这种对象的时候，再拿出来重复使用，从而在一定程度上减少频繁创建对象所造成的开销。用于充当保存对象的“容器”的对象，被称为“对象池”（Object Pool，或简称Pool）。

对于没有状态的对象（例如String），在重复使用之前，无需进行任何处理；对于有状态的对象（例如StringBuffer），在重复使用之前，就需要把它们恢复到等同于刚刚生成时的状态。由于条件的限制，恢复某个对象的状态的操作不可能实现了的话，就得把这个对象抛弃，改用新创建的实例了。

并非所有对象都适合拿来池化――因为维护对象池也要造成一定开销。对生成时开销不大的对象进行池化，反而可能会出现“维护对象池的开销”大于“生成新对象的开销”，从而使性能降低的情况。但是对于生成时开销可观的对象，池化技术就是提高性能的有效策略了。

When to use sidebars

说明：英语中的Pool除了“池”之外，还有“供多方共享的资源”意思。作者十分怀疑第二种才是“Object Pool”中的Pool的实际含义，但是“对象池”的说法已经广为流传，而一时又没有足以替代的贴切译法，因此这里仍然沿用这种译名。

回页首

Jakarta Commons Pool组件

Jakarta Commons Pool是一个用于在Java程序中实现对象池化的组件。它的基本情况是：

  • 主要作者：Morgan Delagrange、Geir Magnusson、Craig McClanahan、Rodney Waldhoff、David Weinrich和Dirk Verbeeck
  • 最新版本：1.1
  • 所含包数：2个（org.apache.commons.pool和org.apache.commons.pool.impl）
  • 所含类数：21个（其中有4个抽象类和6个接口）
  • 适用平台：Java 2, Standard Edition.
  • 单纯地使用Pool组件不需要太多的Java 2的知识和经验，对语法和基本概念（对象、异常、类、接口、实例、继承和实现等）有一般了解即可。

回页首

下载和安装

为了顺利的按照本文中提到的方法使用Pool组件，除去Java 2 SDK外，还需要先准备下列一些东西：

以上两种软件均有已编译包和源代码包两种形式可供选择。一般情况下，使用已编译包即可。不过建议同时也下载源代码包，作为参考资料使用。

如果打算使用源代码包自行编译，那么还需要准备以下一些东西：

具体的编译方法，可以参看有关的Ant文档。

将解压或编译后得到的commons-pool.jar和commons-collections.jar放入CLASSPATH，就可以开始使用Pool组件了。

回页首

PoolableObjectFactory、ObjectPool和ObjectPoolFactory

在Pool组件中，对象池化的工作被划分给了三类对象：

  • PoolableObjectFactory用于管理被池化的对象的产生、激活、挂起、校验和销毁；
  • ObjectPool用于管理要被池化的对象的借出和归还，并通知PoolableObjectFactory完成相应的工作；
  • ObjectPoolFactory则用于大量生成相同类型和设置的ObjectPool。

相应地，使用Pool组件的过程，也大体可以划分成“创立PoolableObjectFactory”、“使用ObjectPool”和可选的“利用ObjectPoolFactory”三种动作。

回页首

创立PoolableObjectFactory

Pool组件利用PoolableObjectFactory来照看被池化的对象。ObjectPool的实例在需要处理被池化的对象的产生、激活、挂起、校验和销毁工作时，就会调用跟它关联在一起的PoolableObjectFactory实例的相应方法来操作。

PoolableObjectFactory是在org.apache.commons.pool包中定义的一个接口。实际使用的时候需要利用这个接口的一个具体实现。Pool组件本身没有包含任何一种PoolableObjectFactory实现，需要根据情况自行创立。

创立PoolableObjectFactory的大体步骤是：

  1. 创建一个实现了PoolableObjectFactory接口的类。 

    import org.apache.commons.pool.PoolableObjectFactory;
public class PoolableObjectFactorySample
        implements PoolableObjectFactory {
    private static int counter = 0;
}
  2. 为这个类添加一个Object makeObject()方法。这个方法用于在必要时产生新的对象。 

    public Object makeObject() throws Exception {
    Object obj = String.valueOf(counter++);
    System.err.println("Making Object " + obj);
    return obj;
}
  3. 为这个类添加一个void activateObject(Object obj)方法。这个方法用于将对象“激活”――设置为适合开始使用的状态。 

    public void activateObject(Object obj) throws Exception {
    System.err.println("Activating Object " + obj);
}
  4. 为这个类添加一个void passivateObject(Object obj)方法。这个方法用于将对象“挂起”――设置为适合开始休眠的状态。 

    public void passivateObject(Object obj) throws Exception {
    System.err.println("Passivating Object " + obj);
}
  5. 为这个类添加一个boolean validateObject(Object obj)方法。这个方法用于校验一个具体的对象是否仍然有效，已失效的对象会被自动交给destroyObject方法销毁 

    public boolean validateObject(Object obj) {
    boolean result = (Math.random() > 0.5);
    System.err.println("Validating Object "
            + obj + " : " + result);
    return result;
}
  6. 为这个类添加一个void destroyObject(Object obj)方法。这个方法用于销毁被validateObject判定为已失效的对象。 

    public void destroyObject(Object obj) throws Exception {
    System.err.println("Destroying Object " + obj);
}

最后完成的PoolableObjectFactory类似这个样子： 

								
          PoolableObjectFactorySample.java
							
        

import org.apache.commons.pool.PoolableObjectFactory;
public class PoolableObjectFactorySample
        implements PoolableObjectFactory {
    private static int counter = 0;
    public Object makeObject() throws Exception {
        Object obj = String.valueOf(counter++);
        System.err.println("Making Object " + obj);
        return obj;
    }
    public void activateObject(Object obj) throws Exception {
        System.err.println("Activating Object " + obj);
    }
    public void passivateObject(Object obj) throws Exception {
        System.err.println("Passivating Object " + obj);
    }
    public boolean validateObject(Object obj) {
        /* 以1/2的概率将对象判定为失效 */
        boolean result = (Math.random() > 0.5);
        System.err.println("Validating Object "
                + obj + " : " + result);
        return result;
    }
    public void destroyObject(Object obj) throws Exception {
        System.err.println("Destroying Object " + obj);
    }
}

回页首

使用ObjectPool

有了合适的PoolableObjectFactory之后，便可以开始请出ObjectPool来与之同台演出了。

ObjectPool是在org.apache.commons.pool包中定义的一个接口，实际使用的时候也需要利用这个接口的一个具体实现。Pool组件本身包含了若干种现成的ObjectPool实现，可以直接利用。如果都不合用，也可以根据情况自行创建。具体的创建方法，可以参看Pool组件的文档和源码。

ObjectPool的使用方法类似这样：

  1. 生成一个要用的PoolableObjectFactory类的实例。 

    PoolableObjectFactory factory = new PoolableObjectFactorySample();
  2. 利用这个PoolableObjectFactory实例为参数，生成一个实现了ObjectPool接口的类（例如StackObjectPool）的实例，作为对象池。 

    ObjectPool pool = new StackObjectPool(factory);
  3. 需要从对象池中取出对象时，调用该对象池的Object borrowObject()方法。 

    Object obj = null;
obj = pool.borrowObject();
  4. 需要将对象放回对象池中时，调用该对象池的void returnObject(Object obj)方法。 

    pool.returnObject(obj);
  5. 当不再需要使用一个对象池时，调用该对象池的void close()方法，释放它所占据的资源。 

    pool.close();

这些操作都可能会抛出异常，需要另外处理。

比较完整的使用ObjectPool的全过程，可以参考这段代码： 

								
          ObjectPoolSample.java 
							
        

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.PoolableObjectFactory;
import org.apache.commons.pool.impl.StackObjectPool;
public class ObjectPoolSample {
    public static void main(String[] args) {
        Object obj = null;
        PoolableObjectFactory factory 
                = new PoolableObjectFactorySample();
        ObjectPool pool = new StackObjectPool(factory);
        try {
            for(long i = 0; i < 100 ; i++) {
                System.out.println("== " + i + " ==");
                obj = pool.borrowObject();
                System.out.println(obj);
                pool.returnObject(obj);
            }
            obj = null;//明确地设为null，作为对象已归还的标志
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            try{
                if (obj != null) {//避免将一个对象归还两次
                    pool.returnObject(obj);
                }
                pool.close();
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

另外，ObjectPool接口还定义了几个可以由具体的实现决定要不要支持的操作，包括：

void clear()

清除所有当前在此对象池中休眠的对象。

int getNumActive()

返回已经从此对象池中借出的对象的总数。

int getNumIdle()

返回当前在此对象池中休眠的对象的数目。

void setFactory(PoolableObjectFactory factory)

将当前对象池与参数中给定的PoolableObjectFactory相关联。如果在当前状态下，无法完成这一操作，会有一个IllegalStateException异常抛出。

回页首

利用ObjectPoolFactory

有时候，要在多处生成类型和设置都相同的ObjectPool。如果在每个地方都重写一次调用相应构造方法的代码，不但比较麻烦，而且日后修改起来，也有所不便。这种时候，正是使用ObjectPoolFactory的时机。

ObjectPoolFactory是一个在org.apache.commons.pool中定义的接口，它定义了一个称为ObjectPool createPool()方法，可以用于大量生产类型和设置都相同的ObjectPool。

Pool组件中，对每一个ObjectPool实现，都有一个对应的ObjectPoolFactory实现。它们相互之间，有一一对应的参数相同的构造方法。使用的时候，只要先用想要的参数和想用的ObjectPoolFactory实例，构造出一个ObjectPoolFactory对象，然后在需要生成ObjectPool的地方，调用这个对象的createPool()方法就可以了。日后无论想要调整所用ObjectPool的参数还是类型，只需要修改这一处，就可以大功告成了。

将 《使用ObjectPool》一节中的例子，改为使用ObjectPoolFactory来生成所用的ObjectPool对象之后，基本就是这种形式： 

ObjectPoolFactorySample.java
 

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.ObjectPoolFactory;
import org.apache.commons.pool.PoolableObjectFactory;
import org.apache.commons.pool.impl.StackObjectPoolFactory;
public class ObjectPoolFactorySample {
    public static void main(String[] args) {
        Object obj = null;
        PoolableObjectFactory factory
                = new PoolableObjectFactorySample();
        ObjectPoolFactory poolFactory
                = new StackObjectPoolFactory(factory);
        ObjectPool pool = poolFactory.createPool();
        try {
            for(long i = 0; i < 100 ; i++) {
                System.out.println("== " + i + " ==");
                obj = pool.borrowObject();
                System.out.println(obj);
                pool.returnObject(obj);
            }
            obj = null;
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            try{
                if (obj != null) {
                    pool.returnObject(obj);
                }
                pool.close();
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

回页首

借助BasePoolableObjectFactory

PoolableObjectFactory定义了许多方法，可以适应多种不同的情况。但是，在并没有什么特殊需要的时候，直接实现PoolableObjectFactory接口，就要编写若干的不进行任何操作，或是始终返回true的方法来让编译通过，比较繁琐。这种时候就可以借助BasePoolableObjectFactory的威力，来简化编码的工作。

BasePoolableObjectFactory是org.apache.commons.pool包中的一个抽象类。它实现了PoolableObjectFactory接口，并且为除了makeObject之外的方法提供了一个基本的实现――activateObject、passivateObject和destroyObject不进行任何操作，而validateObject始终返回true。通过继承这个类，而不是直接实现PoolableObjectFactory接口，就可以免去编写一些只起到让编译通过的作用的代码的麻烦了。

这个例子展示了一个从BasePoolableObjectFactory扩展而来的PoolableObjectFactory： 

BasePoolableObjectFactorySample.java 


import org.apache.commons.pool.BasePoolableObjectFactory;
public class BasePoolableObjectFactorySample 
        extends BasePoolableObjectFactory {
    private int counter = 0;
    public Object makeObject() throws Exception {
        return String.valueOf(counter++);
    }
}

回页首

各式各样的ObjectPool

可口可乐公司的软饮料有可口可乐、雪碧和芬达等品种，百事可乐公司的软饮料有百事可乐、七喜和美年达等类型，而Pool组件提供的ObjectPool实现则有StackObjectPool、SoftReferenceObjectPool和GenericObjectPool等种类。

不同类型的软饮料各有各自的特点，分别适应不同消费者的口味；而不同类型的ObjectPool也各有各自的特色，分别适应不同的情况。

回页首

StackObjectPool

StackObjectPool利用一个java.util.Stack对象来保存对象池里的对象。这种对象池的特色是：

  • 可以为对象池指定一个初始的参考大小（当空间不够时会自动增长）。
  • 在对象池已空的时候，调用它的borrowObject方法，会自动返回新创建的实例。
  • 可以为对象池指定一个可保存的对象数目的上限。达到这个上限之后，再向池里送回的对象会被自动送去回收。

StackObjectPool的构造方法共有六个，其中：

  • 最简单的一个是StackObjectPool()，一切采用默认的设置，也不指明要用的PoolableObjectFactory实例。
  • 最复杂的一个则是StackObjectPool(PoolableObjectFactory factory, int max, int init)。其中：
    • 参数factory指明要与之配合使用的PoolableObjectFactory实例；
    • 参数max设定可保存对象数目的上限；
    • 参数init则指明初始的参考大小。
  • 剩余的四个构造方法则是最复杂的构造方法在某方面的简化版本，可以根据需要选用。它们是：
    • StackObjectPool(int max)
    • StackObjectPool(int max, int init)
    • StackObjectPool(PoolableObjectFactory factory)
    • StackObjectPool(PoolableObjectFactory factory, int max)

用不带factory参数的构造方法构造的StackObjectPool实例，必须要在用它的setFactory(PoolableObjectFactory factory)方法与某一PoolableObjectFactory实例关联起来后才能正常使用。

这种对象池可以在没有Jakarta Commmons Collections组件支持的情况下正常运行。

回页首

SoftReferenceObjectPool

SoftReferenceObjectPool利用一个java.util.ArrayList对象来保存对象池里的对象。不过它并不在对象池里直接保存对象本身，而是保存它们的“软引用”（Soft Reference）。这种对象池的特色是：

  • 可以保存任意多个对象，不会有容量已满的情况发生。
  • 在对象池已空的时候，调用它的borrowObject方法，会自动返回新创建的实例。
  • 可以在初始化同时，在池内预先创建一定量的对象。
  • 当内存不足的时候，池中的对象可以被Java虚拟机回收。

SoftReferenceObjectPool的构造方法共有三个，其中：

  • 最简单的是SoftReferenceObjectPool()，不预先在池内创建对象，也不指明要用的PoolableObjectFactory实例。
  • 最复杂的一个则是SoftReferenceObjectPool(PoolableObjectFactory factory, int initSize)。其中：
    • 参数factory指明要与之配合使用的PoolableObjectFactory实例
    • 参数initSize则指明初始化时在池中创建多少个对象。
  • 剩下的一个构造方法，则是最复杂的构造方法在某方面的简化版本，适合在大多数情况下使用。它是：
    • SoftReferenceObjectPool(PoolableObjectFactory factory)

用不带factory参数的构造方法构造的SoftReferenceObjectPool实例，也要在用它的setFactory(PoolableObjectFactory factory)方法与某一PoolableObjectFactory实例关联起来后才能正常使用。

这种对象池也可以在没有Jakarta Commmons Collections组件支持的情况下正常运行。

回页首

GenericObjectPool

GenericObjectPool利用一个org.apache.commons.collections.CursorableLinkedList对象来保存对象池里的对象。这种对象池的特色是：

  • 可以设定最多能从池中借出多少个对象。
  • 可以设定池中最多能保存多少个对象。
  • 可以设定在池中已无对象可借的情况下，调用它的borrowObject方法时的行为，是等待、创建新的实例还是抛出异常。
  • 可以分别设定对象借出和还回时，是否进行有效性检查。
  • 可以设定是否使用一个单独的线程，对池内对象进行后台清理。

GenericObjectPool的构造方法共有七个，其中：

  • 最简单的一个是GenericObjectPool(PoolableObjectFactory factory)。仅仅指明要用的PoolableObjectFactory实例，其它参数则采用默认值。
  • 最复杂的一个是GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle)。其中：
    • 参数factory指明要与之配合使用的PoolableObjectFactory实例。
    • 参数maxActive指明能从池中借出的对象的最大数目。如果这个值不是正数，表示没有限制。
    • 参数whenExhaustedAction指定在池中借出对象的数目已达极限的情况下，调用它的borrowObject方法时的行为。可以选用的值有：
      • GenericObjectPool.WHEN_EXHAUSTED_BLOCK，表示等待；
      • GenericObjectPool.WHEN_EXHAUSTED_GROW，表示创建新的实例（不过这就使maxActive参数失去了意义）；
      • GenericObjectPool.WHEN_EXHAUSTED_FAIL，表示抛出一个java.util.NoSuchElementException异常。
    • 参数maxWait指明若在对象池空时调用borrowObject方法的行为被设定成等待，最多等待多少毫秒。如果等待时间超过了这个数值，则会抛出一个java.util.NoSuchElementException异常。如果这个值不是正数，表示无限期等待。
    • 参数testOnBorrow设定在借出对象时是否进行有效性检查。
    • 参数testOnBorrow设定在还回对象时是否进行有效性检查。
    • 参数timeBetweenEvictionRunsMillis，设定间隔每过多少毫秒进行一次后台对象清理的行动。如果这个值不是正数，则实际上不会进行后台对象清理。
    • 参数numTestsPerEvictionRun，设定在进行后台对象清理时，每次检查几个对象。如果这个值不是正数，则每次检查的对象数是检查时池内对象的总数乘以这个值的负倒数再向上取整的结果――也就是说，如果这个值是-2（-3、-4、-5……）的话，那么每次大约检查当时池内对象总数的1/2（1/3、1/4、1/5……）左右。
    • 参数minEvictableIdleTimeMillis，设定在进行后台对象清理时，视休眠时间超过了多少毫秒的对象为过期。过期的对象将被回收。如果这个值不是正数，那么对休眠时间没有特别的约束。
    • 参数testWhileIdle，则设定在进行后台对象清理时，是否还对没有过期的池内对象进行有效性检查。不能通过有效性检查的对象也将被回收。
    • 另一个比较特别的构造方法是GenericObjectPool(PoolableObjectFactory factory, GenericObjectPool.Config config) 。其中：
      • 参数factory指明要与之配合使用的PoolableObjectFactory实例；
      • 参数config则指明一个包括了各个参数的预设值的对象（详见《GenericObjectPool.Config》一节）。
    • 剩下的五个构造函数则是最复杂的构造方法在某方面的简化版本，可以根据情况选用。它们是：
      • GenericObjectPool(PoolableObjectFactory factory, int maxActive)
      • GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait)
      • GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, boolean testOnBorrow, boolean testOnReturn)
      • GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle)
      • GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn)

这种对象池不可以在没有Jakarta Commmons Collections组件支持的情况下运行。

回页首

GenericObjectPool.Config

调用一个有很多的参数的方法的时候，很可能将参数的位置和个数搞错，导致编译或运行时的错误；阅读包含了有很多参数的方法调用的代码的时候，也很可能因为没有搞对参数的位置和个数，产生错误的理解。因此，人们往往避免给一个方法安排太多的参数的做法（所谓的“Long Parameter List”）。不过，有些方法又确实需要许多参数才能完成工作。于是，就有人想到了一种将大批的参数封装到一个对象（称为参数对象，Parameter Object）里，然后将这个对象作为单一的参数传递的两全其美的对策。

因为生成GenericKeyedObjectPool时可供设置的特性非常之多，所以它的构造方法里也就难免会需要不少的参数。GenericKeyedObjectPool除了提供了几个超长的构造方法之外，同时也定义了一个使用参数对象的构造方法。所用参数对象的类型是GenericKeyedObjectPool.Config。

GenericKeyedObjectPool.Config定义了许多的public字段，每个对应一种可以为GenericKeyedObjectPool设置的特性，包括：

  • int maxActive
  • int maxIdle
  • long maxWait
  • long minEvictableIdleTimeMillis
  • int numTestsPerEvictionRun
  • boolean testOnBorrow
  • boolean testOnReturn
  • boolean testWhileIdle
  • long timeBetweenEvictionRunsMillis
  • byte whenExhaustedAction

这些字段的作用，与在GenericKeyedObjectPool最复杂的构造方法中与它们同名的参数完全相同。

使用的时候，先生成一个GenericKeyedObjectPool.Config对象，然后将个字段设置为想要的值，最后用这个对象作为唯一的参数调用GenericKeyedObjectPool的构造方法即可。

注意：使用有许多public字段、却没有任何方法的类，也是一个人们往往加以避免的行为（所谓的“Data Class”）。不过这次GenericKeyedObjectPool特立独行了一回。

回页首

带键值的对象池

有时候，单用对池内所有对象一视同仁的对象池，并不能解决的问题。例如，对于一组某些参数设置不同的同类对象――比如一堆指向不同地址的java.net.URL对象或者一批代表不同语句的java.sql.PreparedStatement对象，用这样的方法池化，就有可能取出不合用的对象的麻烦。

可以通过为每一组参数相同的同类对象建立一个单独的对象池来解决这个问题。但是，如果使用普通的ObjectPool来实施这个计策的话，因为普通的PoolableObjectFactory只能生产出大批设置完全一致的对象，就需要为每一组参数相同的对象编写一个单独的PoolableObjectFactory，工作量相当可观。这种时候就适合调遣Pool组件中提供的一种“带键值的对象池”来展开工作了。

Pool组件采用实现了KeyedObjectPool接口的类，来充当带键值的对象池。相应的，这种对象池需要配合实现了KeyedPoolableObjectFactory接口的类和实现了KeyedObjectPoolFactory接口的类来使用（这三个接口都在org.apache.commons.pool包中定义）：

  • KeyedPoolableObjectFactory和PoolableObjectFactory形式如出一辙，只是每个方法都增加了一个Object key参数而已：
    • makeObject的参数变为(Object key)
    • activateObject的参数变为(Object key, Object obj)
    • passivateObject的参数变为(Object key, Object obj)
    • validateObject的参数变为Object key, Object obj)
    • destroyObject的参数变为(Object key, Object obj)

    另外Pool组件也提供了BaseKeyedPoolableObjectFactory，用于充当和BasePoolableObjectFactory差不多的角色。

  • KeyedObjectPool和ObjectPool的形式大同小异，只是某些方法的参数类型发生了变化，某些方法分成了两种略有不同的版本：
    • 用Object borrowObject(Object key)和void returnObject(Object key, Object obj)来负责对象出借和归还的动作。
    • 用void close()来关闭不再需要的对象池。
    • 用void clear(Object key)和void clear()来清空池中的对象，前者针对与特定键值相关联的实例，后者针对整个对象池。
    • 用int getNumActive(Object key)和int getNumActive()来查询已借出的对象数，前者针对与特定键值相关联的实例，后者针对整个对象池。
    • 用int getNumIdle(Object key)和int getNumIdle()来查询正在休眠的对象数，前者针对与特定键值相关联的实例，后者针对整个对象池。
    • 用void setFactory(KeyedPoolableObjectFactory factory)来设置要用的KeyedPoolableObjectFactory实例。

    void clear、int getNumActive、int getNumIdle和void setFactory的各种版本都仍然是可以由具体实现自行决定是否要支持的方法。如果所用的KeyedObjectPool实现不支持这些操作，那么调用这些方法的时候，会抛出一个UnsupportedOperationException异常。

  • KeyedObjectPoolFactory和ObjectPoolFactory的形式完全相同，只是所代表的对象不同而已。

这一类对象池的基本使用方法接近于这样： 

								
          KeyedObjectPoolSample.java 
							
        

import org.apache.commons.pool.BaseKeyedPoolableObjectFactory;
import org.apache.commons.pool.KeyedObjectPool;
import org.apache.commons.pool.KeyedObjectPoolFactory;
import org.apache.commons.pool.KeyedPoolableObjectFactory;
import org.apache.commons.pool.impl.StackKeyedObjectPoolFactory;
class KeyedPoolableObjectFactorySample
        extends BaseKeyedPoolableObjectFactory {
    public Object makeObject(Object key) throws Exception {
        return new String("[" + key.hashCode() + "]");
    }
}
public class KeyedObjectPoolSample {
    public static void main(String[] args) {
        Object obj = null;
        KeyedPoolableObjectFactory factory
                = new KeyedPoolableObjectFactorySample();
        KeyedObjectPoolFactory poolFactory 
                = new StackKeyedObjectPoolFactory(factory);
        KeyedObjectPool pool = poolFactory.createPool();
        String key = null;
        try {
            for (long i = 0; i < 100 ; i++) {
                 key = "" + (int) (Math.random() * 10);
                System.out.println("== " + i + " ==");
                System.out.println("Key:" + key);
                obj = pool.borrowObject(key);
                System.out.println("Object:" + obj);
                pool.returnObject(key, obj);
                obj = null;
            }
        }
        catch (Exception e) {
                 e.printStackTrace();
        }
        finally {
            try{
                if (obj != null) {
                    pool.returnObject(key, obj);
                }
                pool.close();
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

Pool组件自带的KeyedObjectPool的实现有StackKeyedObjectPool和GenericKeyedObjectPool两种。它们的使用方法分别与它们各自的近亲KeyedObjectPool和KeyedObjectPool基本一致，只是原来使用GenericObjectPool.Config的地方要使用GenericKeyedObjectPool.Config代替。

回页首

当出借少于归还

Java并未提供一种机制来保证两个方法被调用的次数之间呈现一种特定的关系（相等，相差一个常数，或是其它任何关系）。因此，完全可以做到建立一个ObjectPool对象，然后调用一次borrowObject方法，借出一个对象，之后重复两次returnObject方法调用，进行两次归还。而调用一个从不曾借出对象的ObjectPool的returnObject方法也并不是一个不可完成的任务。

尽管这些使用方法并不合乎returnObject的字面意思，但是Pool组件中的各个ObjectPool/KeyedObjectPool实现都不在乎这一点。它们的returnObject方法都只是单纯地召唤与当前对象池关联的PoolableObjectFactory实例，看这对象能否经受得起validateObject的考验而已。考验的结果决定了这个对象是应该拿去作passivateObject处理，而后留待重用；还是应该拿去作destroyObject处理，以免占用资源。也就是说，当出借少于归还的时候，并不会额外发生什么特别的事情（当然，有可能因为该对象池处于不接受归还对象的请求的状态而抛出异常，不过这是常规现象）。

在实际使用中，可以利用这一特性来向对象池内加入通过其它方法生成的对象。

回页首

线程安全问题

有时候可能要在多线程环境下使用Pool组件，这时候就会遇到和Pool组件的线程安全程度有关的问题。

因为ObjectPool和KeyedObjectPool都是在org.apache.commons.pool中定义的接口，而在接口中无法使用“synchronized”来修饰方法，所以，一个ObjectPool/KeyedObjectPool下的各个方法是否是同步方法，完全要看具体的实现。而且，单纯地使用了同步方法，也并不能使对象就此在多线程环境里高枕无忧。

就Pool组件中自带的几个ObjectPool/KeyedObjectPool的实现而言，它们都在一定程度上考虑了在多线程环境中使用的情况。不过还不能说它们是完全“线程安全”的。

例如，这段代码有些时候就会有一些奇怪的表现，最后输出的结果比预期的要大： 

								
          UnsafeMultiThreadPoolingSample.java
							
        

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.StackObjectPool;
class UnsafePicker extends Thread {
    private ObjectPool pool;
    public UnsafePicker(ObjectPool op) {
        pool = op;
    }
    public void run() {
        Object obj = null;
        try {
        /* 似乎…… */
            if ( pool.getNumActive() < 5 ) {
                sleep((long) (Math.random() * 10));
                obj = pool.borrowObject();
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}
public class UnsafeMultiThreadPoolingSample {
    public static void main(String[] args) {
        ObjectPool pool = new StackObjectPool
                (new BasePoolableObjectFactorySample());
        Thread ts[] = new Thread[20];
        for (int j = 0; j < ts.length; j++) {
            ts[j] =  new UnsafePicker(pool);
            ts[j].start();
        }
        try {
            Thread.sleep(1000);
            /* 然而…… */
            System.out.println("NumActive:" + pool.getNumActive());
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}

要避免这种情况，就要进一步采取一些措施才行： 

								
          SafeMultiThreadPoolingSample.java 
							
        

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.StackObjectPool;
class SafePicker extends Thread {
    private ObjectPool pool;
    public SafePicker(ObjectPool op) {
        pool = op;
    }
    public void run() {
        Object obj = null;
        try {
            /* 略加处理 */
            synchronized (pool) {
                if ( pool.getNumActive() < 5 ) {
                    sleep((long) (Math.random() * 10));
                    obj = pool.borrowObject();
                }
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}
public class SafeMultiThreadPoolingSample {
    public static void main(String[] args) {
        ObjectPool pool = new StackObjectPool
                (new BasePoolableObjectFactorySample());
        Thread ts[] = new Thread[20];
        for (int j = 0; j < ts.length; j++) {
            ts[j] =  new SafePicker(pool);
            ts[j].start();
        }
        try {
            Thread.sleep(1000);
            System.out.println("NumActive:" + pool.getNumActive());
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}

基本上，可以说Pool组件是线程相容的。但是要在多线程环境中使用，还需要作一些特别的处理。

回页首

什么时候不要池化

采用对象池化的本意，是要通过减少对象生成的次数，减少花在对象初始化上面的开销，从而提高整体的性能。然而池化处理本身也要付出代价，因此，并非任何情况下都适合采用对象池化。

Dr. Cliff Click在JavaOne 2003上发表的《Performance Myths Exposed》中，给出了一组其它条件都相同时，使用与不使用对象池化技术的实际性能的比较结果。他的实测结果表明：

  • 对于类似Point这样的轻量级对象，进行池化处理后，性能反而下降，因此不宜池化；
  • 对于类似Hashtable这样的中量级对象，进行池化处理后，性能基本不变，一般不必池化（池化会使代码变复杂，增大维护的难度）；
  • 对于类似JPanel这样的重量级对象，进行池化处理后，性能有所上升，可以考虑池化。

根据使用方法的不同，实际的情况可能与这一测量结果略有出入。在配置较高的机器和技术较强的虚拟机上，不宜池化的对象的范围可能会更大。不过，对于像网络和数据库连接这类重量级的对象来说，目前还是有池化的必要。

基本上，只在重复生成某种对象的操作成为影响性能的关键因素的时候，才适合进行对象池化。如果进行池化所能带来的性能提高并不重要的话，还是不采用对象池化技术，以保持代码的简明，而使用更好的硬件和更棒的虚拟机来提高性能为佳。

回页首

结束语

恰当地使用对象池化，可以有效地降低频繁生成某些对象所造成的开销，从而提高整体的性能。而借助Jakarta Commons Pool组件，可以有效地减少花在处理对象池化上的工作量，进而，向其它重要的工作里，投入更多的时间和精力。

<!-- CMA ID: 53399 --><!-- Site ID: 10 --><!-- XSLT stylesheet used to transform this file: dw-article-6.0-beta.xsl -->

参考资料

  • 很多疑难问题的答案都可以通过查阅Pool组件的Javadoc文档和源代码的方法解决。

  • 从 Pool组件的官方站点 上，还可以进一步得到许多有用的信息。


  • DBCP 是一个基于Pool组件的Java数据库连接池管理组件，同时也可以作为Pool组件的用法示例使用。


  • 蔡学镛在 《Java夜未眠（Sleepless Java）》中的 《测不准原理》一文里，介绍了Java中的包括“软引用”（Soft Reference）在内的各种不同的引用的特点和用处。


  • Martin Fowler在 《Refactoring -- Improving the Design of Existing Code》（中译本名为 《重构――改善既有代码的设计》，由侯捷、熊节合译）一书的第三章《代码的坏味道（Bad Smells in Code）》中讨论了被称为“Long Parameter List”和“Data Class”的“坏味道”。并指明了一些可以用于对付这些问题的重构手法。


  • Brian Goetz在IBM developerWorks上发表的 《Java 理论与实践：描绘线程安全性》一文中，说明了为什么单纯地使用同步方法还不能让对象就此在多线程环境里高枕无忧的原因。


  • Dr. Cliff Click发表在JavaOne 2003上的 《Performance Myths Exposed》（Session #1522），给出了一组包括“对象池化”在内的、对“能提高Java程序性能”的做法的实际效果的测试数据，和一些恰当使用这些做法的建议。


关于作者

孙海涛从1994年6月的一个风雨交加的下午开始了他的编程生涯。目前，他的兴趣集中于Java、Web、开源软件和人机交互。但是，这并不表示他不会对其它的事物给予足够的关心和重视。可以通过 [email protected]与他取得联系。

 

 

http://www.ibm.com/developerworks/cn/java/l-common-pool/

你可能感兴趣的:(apache,多线程,虚拟机,ant,IBM)

  • vant组件库的按需导入导出 ordinary90 前端全栈开发VUEvue.jsjavascript前端
    要按需导入和导出Vant组件库的Vuex模块，首先需要在项目的入口文件中引入所需的组件：import{Button,Toast}from'vant';import'vant/lib/index.css';Vue.use(Button);Vue.use(Toast);接下来，创建一个store文件夹，在该文件夹下创建index.js文件，用于定义Vuex的模块、状态和操作。importVuefrom
  • 调用工具流程，调用并把调用结果最后一起发给openai接口进行归纳在一起 Ai君臣 pythonflask开发语言
    是的，这是OpenAI/AzureOpenAIAPI的规范要求。根据OpenAI的文档，当使用工具调用时，对话历史中需要保持以下顺序：Assistant消息（包含tool_calls）对应的Tool响应消息这种结构设计有几个重要原因：完整性追踪Assistant的消息记录了它想要调用哪些工具每个tool_call都有唯一的ID后续的工具响应通过tool_call_id与这些调用建立关联对话上下文A
  • 消失的数去哪里了 java
    大家好，我是大圣，最近消失了很长一段时间了，之前答应粉丝要更新的文章也没有按时更新。其实我这段时间去闭关修炼去了，现在满血归来啦，之前答应粉丝的文章都会陆续发出来的。消失的Count去哪了今天给大家分享一个面试经常问到的一个多线程问题，大家直接看下面的代码。代码案例publicclassCounter{privateintcount=0;publicsynchronizedvoidincremen
  • Node与Java后台对比 旭氏美术馆 Nodejs服务端并发编程多线程node.jsjava
    高并发场景下的对比：nodejs具有单线程、非阻塞IO、事件循环/驱动的特点，所以在高并发场景下，线程占用cup处理资源，cup不用等待IO的处理过程，而是不停的的发起异步请求，在异步处理结束后继续下一步异步任务。所以不会出现线程阻塞。如图1所示。优势：cpu利用率较高，因为cpu不用等待IO，而时一直在发起异步请求。不足：单个线程崩溃后，所以任务都无法进行，而多线程并发场景下，某个线程崩溃，不影
  • 学英语学压测：06 jmeter 各组件元素的作用域 学会了没 压测工具jmeterjmeter压力测试作用域元素作用域
    ：先看关键单词，再看英文，最后看中文总结，再回头看一遍英文原文，效果更佳！！关键词descendant后代/dɪˈsɛndənt/hierarchical分层的/ˌhaɪəˈrɑːrkɪkəl/irrelevant无关的/ɪˈrɛləvənt/subelement子元素/ˈsʌbˌɛlɪmənt/testtree测试树/tɛsttriː/timer计时器/ˈtaɪmər/treebranch树枝/
  • MAC安装Cloudera QuickStart VM+incubator-griffin相关配置过程 youyouiyiy virtualboxcentosclouderagriffin
    1.加载镜像至VirtualBox中，处理器核数调整至最少2个，内存默认最小4096MB。2.在虚拟机配置中增加共享文件夹路径。3.我的Macbook多加了一个屏幕，第一次启动在独立屏上显示CENTOS界面，分辨率只有800*600，关闭，修改显存大小和VirtualBox的“偏好设置”，“显示”，最大屏幕尺寸为空。重启就好了。4.Cloudera已经将所有组件都装好了，我是因为卸载重装了mysq
  • Apache SeaTunnel 荣登 2024 年度中间件开源项目 Top 50 榜单 SeaTunnel 大数据
    近日，ApacheSeaTunnel项目成功入选2024年度中间件开源项目Top50榜单。该榜单由OpenGithub技术社区评选，旨在表彰在中间件领域具有突出表现的开源项目。榜单链接：https://zhuanlan.zhihu.com/p/16116358605关于ApacheSeaTunnelApacheSeaTunnel是一个云原生的高性能海量数据集成工具。北京时间2023年6月1日，全球
  • Spark Livy 指南及livy部署访问实践 house.zhang 大数据-Spark大数据
    背景：ApacheSpark是一个比较流行的大数据框架、广泛运用于数据处理、数据分析、机器学习中，它提供了两种方式进行数据处理，一是交互式处理：比如用户使用spark-shell，编写交互式代码编译成spark作业提交到集群上去执行；二是批处理，通过spark-submit提交打包好的spark应用jar到集群中进行执行。这两种运行方式都需要安装spark客户端配置好yarn集群信息，并打通集群网
  • 迅为RK3568开发板篇OpenHarmony配置HDF驱动控制LED-新增 topeet子系统-编写 bundle.json文件 mucheni RK3568开发板rk3568
    bundle.json文件内容如下所示：下面是对各个字段的解释：1.name:"@ohos/demos"-这是组件或项目的名称，这里表示它属于OHOS（OpenHarmonyOS）生态系统下的一个名为"demos"的组件。2.description:"topeetdemos"-它描述了组件的简短说明3.version:"4.1"-组件的版本号。4.license:"Apache-2.0"-组件使用
  • Matlab多核CPU并行和多线程 m0_74823021 面试学习路线阿里巴巴资料职业发展matlabjava数据库后端
    简介这里需要明白的概念有：多核、多进程、多线程、并行计算、并发计算的区别。什么是多核在计算机设计早期，为了响应更多计算性能的需要，单处理器系统发展成为多处理器系统。更现代的、类似的系统设计趋势是将多个计算核放到单个芯片。无论多个计算核是在多个CPU芯片上还是在单个CPU芯片上，我们称之为多核或多处理器系统。多进程进程就是正在进行的一个程序或者任务，而负责执行任务的是CPU，执行任务的地方是内存。程
  • 探索数据科学新边界：Apache Livy 开源项目详解 毕艾琳
    探索数据科学新边界：ApacheLivy开源项目详解incubator-livyApacheLivyisanopensourceRESTinterfaceforinteractingwithApacheSparkfromanywhere.项目地址:https://gitcode.com/gh_mirrors/in/incubator-livyApacheLivy是一个为ApacheSpark提供的
  • FrameWork层WiFi模块架构剖析 刘争Stanley Java编程深度挖掘Android开发巅峰之路Framework框架大师C++魔法学院
    1.系统架构AndroidWiFi系统引入了wpa_supplicant，它的整个WiFi系统以wpa_supplicant为核心来定义上层用户接口和下层驱动接口。整个WiFi系统架构如下图所示：一切尽在上图中，下面将对每部分进行详细分析。1.1WifiService由SystemServer启动的时候生成的ConnecttivityService创建，负责启动关闭wpa_supplicant,启
  • C#异步和多线程,Thread,Task和async/await关键字--12 冰茶_ C#开发语言c#学习visualstudio
    目录一.多线程和异步的区别1.多线程2.异步编程多线程和异步的区别二.Thread,Task和async/await关键字的区别1.Thread2.Task3.async/await三.Thread,Task和async/await关键字的详细对比1.Thread和Task的详细对比2.Task与async/await的配合使用3.async/await的实际应用场景4.关键区别总结引言:在C#编
  • 传统架构下应用部署 aherhuo 架构linux云原生
    2.1传统架构下应用部署实验目标：目标为在传统架构下搭建LAMP（Linux+Apache+MySQL/MariaDB+PHP,流行的开源软件组合）环境并部署WordPress服务，本次模拟在安装好的openEuler22.03系统虚拟机实现。节点配置：虚拟机版本主机名Ip地址安装服务openEuler22.03web01192.168.110.200Apache、PHP、MariaDB2.1.1
  • 子平八字生成 warrah 岁月云——java基础java服务器前端
    1多线程生成数据@PostMapping("genData")publicResponseResultgenData(){StopWatchstopWatch=newStopWatch();stopWatch.start();//intthreadPoolSize=Math.min(Runtime.getRuntime().availableProcessors()*2,64);intthread
  • JVM加载 影࿐ེ jvm
    JVM（Java虚拟机）并不是在工程启动时就将所有类都加载到内存中，而是采用按需加载的方式，即在需要使用某个类时才会加载该类。JVM的类加载机制包括了加载、验证、准备、解析和初始化五个阶段。当Java程序运行时，JVM会根据需要，通过类加载器查找并加载类的字节码数据。这些数据可以来源于本地文件系统、网络、jar包等多种途径。加载完成后，JVM会将类的二进制数据转换成方法区内部的数据结构，并生成一个
  • 网络编程（3）reactor事件驱动的机制 jinbaotong 网络windows
    前言在传统的阻塞io模型中，服务器通常使用一个循环来不断监听端口是否有新的套接字连接。当有新的连接请求到来时，服务器会接受连接，并创建一个线程来处理该连接的后续读写操作。这种模型的问题在于，如果当前的请求没有处理完，后续的请求将被阻塞，直到前一个请求处理完成。这导致了服务器的吞吐量低下，无法处理高并发连接。为了解决阻塞io模型的问题，人们想到了使用多线程模型，即一请求一线程。这种模型在一定程度上提
  • 常见的图形库对比 Echarts Highcharts AntV 后端java
    图形库图形库特点图表类型适用场景依赖项官网/文档ECharts功能丰富，支持大规模数据，交互性强折线图、柱状图、饼图、地图、雷达图、散点图、热力图等复杂数据可视化无https://echarts.apache.org/Chart.js简单易用，轻量级，支持响应式设计折线图、柱状图、饼图、雷达图、散点图等简单图表，快速开发无https://www.chartjs.org/D3.js功能强大，灵活性高
  • Apache Doris安装部署 ErbaoLiu FlinkDorisApacheDoris部署安装单机部署安装FEBE
    目录Doris简介Doris安装包下载JDK安装Doris安装单机部署安装部署规划创建用户解压安装包配置FE配置BE启动FE和BE连接Doris集群添加BE节点修改root和admin用户的密码创建数据库和数据表停止ApacheDorisDoris简介ApacheDoris官网主页如下：英文版：ApacheDoris:Opensourcedatawarehouseforrealtimedataan
  • 常见的图形库概览-03-D3.js 入门例子 后端java
    常见的图形库系列常见的图形库概览-00-overview常见的图形库概览-01-Chart.js入门例子常见的图形库概览-03-D3.js入门例子HighCharts交互式图表-01-入门介绍Plotly函数图像绘制ApexCharts图表入门例子Victory图表基于React，适合React项目，支持移动端Recharts入门例子AntVG2入门例子图表库C3.js入门例子图表库GoogleC
  • 11-2.Android 项目结构 - themes.xml 文件基础解读 我命由我12345 Android-简化编程androidxmlgiteejava-eejavaandroidruntimeandroidjetpack
    themes.xml文件基础解读themes.xml用于定义一个Android应用程序的主题@color/purple_500@color/purple_700@color/white@color/teal_200@color/teal_700@color/black?attr/colorPrimaryVariant1、主题继承...定义了一个名为Theme.MyTheme的自定义主题，它继承自T
  • 深入探讨Kafka：架构、实现原理与开发实践 Ceramist kafka架构分布式
    深入探讨Kafka：架构、实现原理与开发实践ApacheKafka是一个高性能的分布式流处理平台，广泛应用于实时数据处理、日志收集、消息发布/订阅等领域。本文将详细解析Kafka的架构、实现原理，并提供一些开发中的注意事项，帮助读者更好地理解和使用Kafka。一、Kafka简介Kafka由LinkedIn开发，并于2011年开源，2012年成为Apache顶级项目。Kafka的设计目标是为处理实时
  • 2025年01月19日Github流行趋势 油泼辣子多加 GitHub每日趋势github
    项目名称：MiniCPM-o项目地址url：https://github.com/OpenBMB/MiniCPM-o项目语言：Python历史star数：15826今日star数：959项目维护者：yiranyyu,iceflame89,yaoyuanTHU,LDLINGLINGLING,tc-mb项目简介：MiniCPM-o2.6:一个适用于视觉、语音和多模态直播的GPT-4o级别模型，可在手机
  • 认知架构 cognitive architecture 谁怕平生太急 AgentLangChain
    AssistantsAPI：以开发人员为中心。有状态的API：允许存储以前的消息、上传文件、访问内置工具（代码解释器）、通过函数调用控制其他工具。认知架构应用的两个组件：（1）如何提供上下文给应用（2）应用如何推理不同级别的认知架构：（1）单个LLM、仅得到输出（2）一连串LLM、仅得到输出（3）LLM作为路由、选择要使用的操作（工具、检索器、提示）（4）状态机、使用LLMs在步骤之间进行路由，某
  • 9.kafka单实例安装 小黑要上天 Kafkakafka分布式
    1.环境信息OSVersionZookeeperVersionUserRHEL7.73.8.0rootkafka官网下载地址：ApacheKafka备注：与在同一台服务器。也需要jdk支持2.kafka单实例安装1.上传kafka_2.13-3.3.2.tgzE.g：上传至/opt目录2.解压命令：tar-zxvfkafka_2.13-3.3.2.tgz3.配置server.properties命
  • HighCharts 交互式图表-01-入门介绍 后端java
    常见的图形库系列常见的图形库概览-00-overview常见的图形库概览-01-Chart.js入门例子常见的图形库概览-03-D3.js入门例子HighCharts交互式图表-01-入门介绍Plotly函数图像绘制ApexCharts图表入门例子Victory图表基于React，适合React项目，支持移动端Recharts入门例子AntVG2入门例子图表库C3.js入门例子图表库GoogleC
  • HighCharts 交互式图表-01-入门介绍 后端java
    常见的图形库系列常见的图形库概览-00-overview常见的图形库概览-01-Chart.js入门例子常见的图形库概览-03-D3.js入门例子HighCharts交互式图表-01-入门介绍Plotly函数图像绘制ApexCharts图表入门例子Victory图表基于React，适合React项目，支持移动端Recharts入门例子AntVG2入门例子图表库C3.js入门例子图表库GoogleC
  • css中的优先级和继承 挽风莬 csshtml5html
    1.优先级(在所有的选择器中某个选择器定义的规则是否能够胜出（即优先级）取决于三个元素：（1）先考虑权重，权重一样的，后面的样式回覆盖前面的样式（2）!important声明(Importance)在css规则的值末尾添加"!important"能够保证该规则优先其他规则。（3）特性值(权重)通过4个特性值来量化一个选择器Thousands声明在元素的style属性中。特性值记为1000Hundr
  • 矩阵碰一碰发视频之视频剪辑功能开发全解析，支持OEM 余~~18538162800 音视频线性代数矩阵
    在短视频风靡的当下，矩阵碰一碰发视频结合视频剪辑功能，为内容创作与传播带来了全新的活力。本文将深入探讨这一创新功能的源码搭建过程，助力开发者打造出功能强大且用户体验良好的视频处理系统。一、技术选型前端技术框架：选用React作为前端开发框架，其高效的虚拟DOM机制和组件化开发模式，能显著提升开发效率与应用性能。借助ReactHooks，可更便捷地管理组件状态与副作用。UI库：采用AntDesign
  • 使用 Java 和 FreeMarker 实现自动生成供货清单，动态生成 Word 文档，简化文档处理流程。 熊文豪 javaapachefreemarker
    在上一篇博客中主要是使用SpringBoot+ApachePOI实现了BOM物料清单Excel表格导出，详见以下博客：SpringBoot+ApachePOI实现Exc（）el导出：BOM物料清单生成器（支持中文文件名、样式美化、数据合并）目录引言项目结构源代码展示1.WordController2.WordUtil工具类3.FreeMarker模版4.POM依赖WordController类深度
  • LeetCode[Math] - #66 Plus One Cwind javaLeetCode题解AlgorithmMath
    原题链接：#66 Plus One   要求： 给定一个用数字数组表示的非负整数，如num1 = {1, 2, 3, 9}, num2 = {9, 9}等，给这个数加上1。 注意： 1. 数字的较高位存在数组的头上，即num1表示数字1239 2. 每一位（数组中的每个元素）的取值范围为0~9   难度：简单   分析： 题目比较简单，只须从数组
  • JQuery中$.ajax()方法参数详解 AILIKES JavaScriptjsonpjqueryAjaxjson
    url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。 type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和    delete也可以使用，但仅部分浏览器支持。 timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局
  • JConsole & JVisualVM远程监视Webphere服务器JVM Kai_Ge JVisualVMJConsoleWebphere
        JConsole是JDK里自带的一个工具，可以监测Java程序运行时所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。我们可以根据这些信息判断程序是否有内存泄漏问题。 　　使用JConsole工具来分析WAS的JVM问题，需要进行相关的配置。 　　首先我们看WAS服务器端的配置. 　　1、登录was控制台https://10.4.119.18
  • 自定义annotation 120153216 annotation
    Java annotation 自定义注释@interface的用法 一、什么是注释      说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源
  • CentOS 5/6.X 使用 EPEL YUM源 2002wmj centos
    CentOS 6.X 安装使用EPEL YUM源1. 查看操作系统版本[root@node1 ~]# uname -a Linux node1.test.com 2.6.32-358.el6.x86_64 #1 SMP Fri Feb 22 00:31:26 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux [root@node1 ~]#
  • 在SQLSERVER中查找缺失和无用的索引SQL 357029540 SQL Server
    --缺失的索引 SELECT  avg_total_user_cost * avg_user_impact * ( user_scans + user_seeks ) AS PossibleImprovement ,          last_user_seek ,    
  • Spring3 MVC 笔记（二） —json+rest优化 7454103 Spring3 MVC
    接上次的 spring mvc 注解的一些详细信息！                          其实也是一些个人的学习笔记  呵呵！
  • 替换“\”的时候报错Unexpected internal error near index 1 \ ^ adminjun java“\替换”
    发现还是有些东西没有刻子脑子里,,过段时间就没什么概念了,所以贴出来...以免再忘...   在拆分字符串时遇到通过 \ 来拆分，可是用所以想通过转义 \\ 来拆分的时候会报异常   public class Main {          /*
  • POJ 1035 Spell checker(哈希表) aijuans 暴力求解--哈希表
    /* 题意：输入字典，然后输入单词，判断字典中是否出现过该单词，或者是否进行删除、添加、替换操作，如果是，则输出对应的字典中的单词 要求按照输入时候的排名输出 题解：建立两个哈希表。一个存储字典和输入字典中单词的排名，一个进行最后输出的判重 */ #include <iostream> //#define using namespace std; const int HASH =
  • 通过原型实现javascript Array的去重、最大值和最小值 ayaoxinchao JavaScriptarrayprototype
    用原型函数（prototype）可以定义一些很方便的自定义函数，实现各种自定义功能。本次主要是实现了Array的去重、获取最大值和最小值。 实现代码如下：   <script type="text/javascript"> Array.prototype.unique = function() { var a = {}; var le
  • UIWebView实现https双向认证请求 bewithme UIWebViewhttpsObjective-C
              什么是HTTPS双向认证我已在先前的博文 ASIHTTPRequest实现https双向认证请求 中有讲述，不理解的读者可以先复习一下。本文是用UIWebView来实现对需要客户端证书验证的服务请求，网上有些文章中有涉及到此内容，但都只言片语，没有讲完全，更没有完整的代码，让人困扰不已。但是此知
  • NoSQL数据库之Redis数据库管理(Redis高级应用之事务处理、持久化操作、pub_sub、虚拟内存) bijian1013 redis数据库NoSQL
    3.事务处理         Redis对事务的支持目前不比较简单。Redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务上下文，该连接后续的命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中
  • 各数据库分页sql备忘 bingyingao oraclesql分页
    ORACLE 下面这个效率很低 SELECT * FROM ( SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_FS_RETURN order by id desc) A ) WHERE RN <20; 下面这个效率很高 SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_
  • 【Scala七】Scala核心一：函数 bit1129 scala
    1. 如果函数体只有一行代码，则可以不用写{},比如 def print(x: Int) = println(x) 一行上的多条语句用分号隔开，则只有第一句属于方法体，例如   def printWithValue(x: Int) : String= println(x); "ABC"   上面的代码报错，因为，printWithValue的方法
  • 了解GHC的factorial编译过程 bookjovi haskell
    GHC相对其他主流语言的编译器或解释器还是比较复杂的，一部分原因是haskell本身的设计就不易于实现compiler，如lazy特性，static typed，类型推导等。 关于GHC的内部实现有篇文章说的挺好，这里，文中在RTS一节中详细说了haskell的concurrent实现，里面提到了green thread，如果熟悉Go语言的话就会发现，ghc的concurrent实现和Go有点类
  • Java-Collections Framework学习与总结-LinkedHashMap BrokenDreams LinkedHashMap
            前面总结了java.util.HashMap，了解了其内部由散列表实现，每个桶内是一个单向链表。那有没有双向链表的实现呢？双向链表的实现会具备什么特性呢？来看一下HashMap的一个子类——java.util.LinkedHashMap。       
  • 读《研磨设计模式》-代码笔记-抽象工厂模式-Abstract Factory bylijinnan abstract
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * Abstract Factory Pattern * 抽象工厂模式的目的是： * 通过在抽象工厂里面定义一组产品接口，方便地切换“产品簇” * 这些接口是相关或者相依赖的
  • 压暗面部高光 cherishLC PS
    方法一、压暗高光&重新着色 当皮肤很油又使用闪光灯时，很容易在面部形成高光区域。 下面讲一下我今天处理高光区域的心得： 皮肤可以分为纹理和色彩两个属性。其中纹理主要由亮度通道（Lab模式的L通道）决定，色彩则由a、b通道确定。 处理思路为在保持高光区域纹理的情况下，对高光区域着色。具体步骤为：降低高光区域的整体的亮度，再进行着色。 如果想简化步骤，可以只进行着色（参看下面的步骤1
  • Java VisualVM监控远程JVM crabdave visualvm
    Java VisualVM监控远程JVM    JDK1.6开始自带的VisualVM就是不错的监控工具. 这个工具就在JAVA_HOME\bin\目录下的jvisualvm.exe, 双击这个文件就能看到界面   通过JMX连接远程机器, 需要经过下面的配置: 1. 修改远程机器JDK配置文件 (我这里远程机器是linux).    
  • Saiku去掉登录模块 daizj saiku登录olapBI
    1、修改applicationContext-saiku-webapp.xml <security:intercept-url pattern="/rest/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />  <security:intercept-url pattern=&qu
  • 浅析 Flex中的Focus dsjt htmlFlexFlash
    关键字：focus、 setFocus、 IFocusManager、KeyboardEvent 焦点、设置焦点、获得焦点、键盘事件 一、无焦点的困扰——组件监听不到键盘事件 原因：只有获得焦点的组件（确切说是InteractiveObject）才能监听到键盘事件的目标阶段；键盘事件（flash.events.KeyboardEvent）参与冒泡阶段，所以焦点组件的父项（以及它爸
  • Yii全局函数使用 dcj3sjt126com yii
    由于YII致力于完美的整合第三方库，它并没有定义任何全局函数。yii中的每一个应用都需要全类别和对象范围。例如，Yii::app()->user;Yii::app()->params['name'];等等。我们可以自行设定全局函数，使得代码看起来更加简洁易用。(原文地址) 我们可以保存在globals.php在protected目录下。然后，在入口脚本index.php的，我们包括在
  • 设计模式之单例模式二（解决无序写入的问题） come_for_dream 单例模式volatile乱序执行双重检验锁
                    在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该
  • 程序员从初级到高级的蜕变 gcq511120594 框架工作PHPandroidhtml5
    软件开发是一个奇怪的行业，市场远远供不应求。这是一个已经存在多年的问题，而且随着时间的流逝，愈演愈烈。 我们严重缺乏能够满足需求的人才。这个行业相当年轻。大多数软件项目是失败的。几乎所有的项目都会超出预算。我们解决问题的最佳指导方针可以归结为——“用一些通用方法去解决问题，当然这些方法常常不管用，于是，唯一能做的就是不断地尝试，逐个看看是否奏效”。 现在我们把淫浸代码时间超过3年的开发人员称为
  • Reverse Linked List hcx2013 list
    Reverse a singly linked list.   /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ p
  • Spring4.1新特性——数据库集成测试 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • C# Ajax上传图片同时生成微缩图(附Demo) liyonghui160com
        1.Ajax无刷新上传图片,详情请阅我的这篇文章。（jquery + c# ashx）         2.C#位图处理  System.Drawing。         3.最新demo支持IE7,IE8,Fir
  • Java list三种遍历方法性能比较 pda158 java
    从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码例如以下： package com.hisense.tiger.list; import java.util.ArrayList; import java.util.Iterator;
  • 300个涵盖IT各方面的免费资源（上）——商业与市场篇 shoothao seo商业与市场IT资源免费资源
    A.网站模板+logo+服务器主机+发票生成 HTML5 UP:响应式的HTML5和CSS3网站模板。 Bootswatch:免费的Bootstrap主题。 Templated:收集了845个免费的CSS和HTML5网站模板。 Wordpress.org|Wordpress.com:可免费创建你的新网站。 Strikingly:关注领域中免费无限的移动优
  • localStorage、sessionStorage uule localStorage
    W3School 例子   HTML5 提供了两种在客户端存储数据的新方法： localStorage - 没有时间限制的数据存储 sessionStorage - 针对一个 session 的数据存储   之前，这些都是由 cookie 完成的。但是 cookie 不适合大量数据的存储，因为它们由每个对服务器的请求来传递，这使得 cookie 速度很慢而且效率也不
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他