Fast, lightweight, and compatible blocking/non-blocking/soft-reference object pool for Java 6+
Go to file
nathan acf9bde399 Updated version from 2.11 to 2.12 2019-06-14 14:04:06 +02:00
gradle/wrapper Updated to use Gradle Utils for gradle/project update management 2019-05-13 15:18:33 +02:00
src/dorkbox/objectPool Updated version from 2.11 to 2.12 2019-06-14 14:04:06 +02:00
.gitignore Updated to use Gradle Utils for gradle/project update management 2019-05-13 15:18:33 +02:00
LICENSE Build converted to kotlin script 2019-03-17 22:56:01 +01:00
LICENSE.Apachev2 Initial import of ObjectPool project 2015-02-02 00:33:46 +01:00
README.md Added badges+links 2019-03-17 22:57:17 +01:00
build.gradle.kts Updated version from 2.11 to 2.12 2019-06-14 14:04:06 +02:00
gradlew Updated to use Gradle Utils for gradle/project update management 2019-05-13 15:18:33 +02:00
gradlew.bat Updated to use Gradle Utils for gradle/project update management 2019-05-13 15:18:33 +02:00
settings.gradle.kts Build converted to kotlin script 2019-03-17 22:56:01 +01:00

README.md

ObjectPool

Dorkbox Github Gitlab Bitbucket

This provides an ObjectPool, for providing for a safe, and fixed sized pool of objects. This is only recommended in systems were garbage collection is to be kept to a minimum, and the created objects are large.

  • This is for cross-platform use, specifically - linux 32/64, mac 32/64, and windows 32/64. Java 6+

Usage:

    ObjectPool<T> pool = ObjectPool.NonBlocking(new PoolableObject<T>() {
            /**
             * Called when an object is returned to the pool, useful for resetting an objects state, for example.
             */
            public
            void onReturn(T object) {
                object.foo = 0;
                object.bar = null;
            }
    
            /**
             * Called when an object is taken from the pool, useful for setting an objects state, for example.
             */
            public
            void onTake(T object) {
            }
    
            /**
             * Called when a new instance is created
             */
            @Override
            public
            T create() {
                return new Object();
            }
        });
        
        

    /**
     * Takes an object from the pool. If the pool is a {@link BlockingPool}, this will wait until an item is available in
     * the pool.
     * <p/>
     * This method catches {@link InterruptedException} and discards it silently.
     */
    T take();

    /**
     * Takes an object from the pool. If the pool is a {@link BlockingPool}, this will wait until an item is available in the pool.
     */
    T takeInterruptibly() throws InterruptedException;

    /**
     * Return object to the pool. If the pool is a {@link BlockingPool}, this will wake the threads that have blocked during take/takeInterruptibly()
     */
    void put(T object);

    /**
     * @return a new object instance created by the pool.
     */
    T newInstance();

   

Maven Info

<dependencies>
    ...
    <dependency>
      <groupId>com.dorkbox</groupId>
      <artifactId>ObjectPool</artifactId>
      <version>2.11</version>
    </dependency>
</dependencies>

Gradle Info

dependencies {
    ...
    compile 'com.dorkbox:ObjectPool:2.11'
}

Or if you don't want to use Maven, you can access the files directly here:
https://repo1.maven.org/maven2/com/dorkbox/ObjectPool/

License

This project is © 2014 dorkbox llc, and is distributed under the terms of the Apache v2.0 License. See file "LICENSE" for further references.