One certainly must if it's not garbage collectable!

A problem with Java in general, particularly with newbie coders who've
only learned Java from scratch, is that they pay no attention to gc at
all and just assume that "the maid will clear it up". This works fine
for most pure Java objects, but if you start having some object that
represents another resource and isn't automatically disposable then
you're back to needing to manage these manually (at least to some
degree). Leaving it up to Java's gc means that none of them ever get
disposed, and you've a leak.

Languages that reduce the need to think about everything are great for
fast development, but when this extends into a mindset that no longer
thinks at all, it leads to sloppy development.

On 10 fév, 09:32, "pascal.lecoi...@euriware.fr"
<pascal.lecoi...@euriware.fr> wrote:

<scce>
/**
* Test of the utility of pool for primitive arrays
*/
public class TestPool {

    public static final int ITERATIONS = 100000;
    public static final int NB_INCREMENTS = 19;

    public static void main(String[] args) {
        testByteWithPool();
        testByteWithoutPool();
        testIntWithPool();
        testIntWithoutPool();
    }

    /** An object to lock the pool when we use it */
    private static Object poolLock = new Object();
    private static boolean poolUsed = false;

    private static byte[] bytePool;
    private static int[] intPool;
    private static Object[] refPool;

    private static void testByteWithPool() {
        int currentSize = 1;

        for (int j = 0; j < NB_INCREMENTS; j++) {

            long t1 = System.nanoTime();
            // Creation of the pool
            synchronized (poolLock) {
                bytePool = new byte[currentSize];
                poolUsed = false;
            }
            for (int i = 0; i < ITERATIONS; i++) {
                byte[] array = null;
                // Get the array from pool
                synchronized (poolLock) {
                    if (poolUsed) {
                        throw new RuntimeException("pool already in use");
                    }
                    array = bytePool;
                    poolUsed = true;
                }
                // use the array
                array[0] = 1;
                // put back the array in the pool
                synchronized (poolLock) {
                    poolUsed = false;
                }
            }
            long t2 = System.nanoTime();
            System.out.printf("BYTE POOL : bufsize %d elapsed = %d\n",
currentSize, (t2-t1)/1000000);

            currentSize *= 2;
        }
    }

    private static void testByteWithoutPool() {
        int currentSize = 1;

        for (int j = 0; j < NB_INCREMENTS; j++) {

            long t1 = System.nanoTime();
            for (int i = 0; i < ITERATIONS; i++) {
                // Get the array
                byte[] array = new byte[currentSize];
                // use the array
                array[0] = 1;
            }
            long t2 = System.nanoTime();
            System.out.printf("BYTE NOPOOL : bufsize %d elapsed = %d\n",
currentSize, (t2-t1)/1000000);

            currentSize *= 2;
        }
    }

    private static void testIntWithPool() {
        int currentSize = 1;

        for (int j = 0; j < NB_INCREMENTS; j++) {

            long t1 = System.nanoTime();
            // Creation of the pool
            synchronized (poolLock) {
                intPool = new int[currentSize];
                poolUsed = false;
            }
            for (int i = 0; i < ITERATIONS; i++) {
                int[] array = null;
                // Get the array from pool
                synchronized (poolLock) {
                    if (poolUsed) {
                        throw new RuntimeException("pool already in use");
                    }
                    array = intPool;
                    poolUsed = true;
                }
                // use the array
                array[0] = 1;
                // put back the array in the pool
                synchronized (poolLock) {
                    poolUsed = false;
                }
            }
            long t2 = System.nanoTime();
            System.out.printf("INT POOL : bufsize %d elapsed = %d\n",
currentSize, (t2-t1)/1000000);

            currentSize *= 2;
        }
    }

    private static void testIntWithoutPool() {
        int currentSize = 1;

        for (int j = 0; j < NB_INCREMENTS; j++) {

            long t1 = System.nanoTime();
            for (int i = 0; i < ITERATIONS; i++) {
                // Get the array
                int[] array = new int[currentSize];
                // use the array
                array[0] = 1;
            }
            long t2 = System.nanoTime();
            System.out.printf("INT NOPOOL : bufsize %d elapsed = %d\n",
currentSize, (t2-t1)/1000000);

            currentSize *= 2;
        }
    }

}
</scce>

And the results are :

BYTE POOL : bufsize 1 elapsed = 8
BYTE POOL : bufsize 2 elapsed = 4
BYTE POOL : bufsize 4 elapsed = 4
BYTE POOL : bufsize 8 elapsed = 4
BYTE POOL : bufsize 16 elapsed = 3
BYTE POOL : bufsize 32 elapsed = 4
BYTE POOL : bufsize 64 elapsed = 4
BYTE POOL : bufsize 128 elapsed = 4
BYTE POOL : bufsize 256 elapsed = 1
BYTE POOL : bufsize 512 elapsed = 6
BYTE POOL : bufsize 1024 elapsed = 4
BYTE POOL : bufsize 2048 elapsed = 3
BYTE POOL : bufsize 4096 elapsed = 2
BYTE POOL : bufsize 8192 elapsed = 4
BYTE POOL : bufsize 16384 elapsed = 6
BYTE POOL : bufsize 32768 elapsed = 2
BYTE POOL : bufsize 65536 elapsed = 6
BYTE POOL : bufsize 131072 elapsed = 4
BYTE POOL : bufsize 262144 elapsed = 4
BYTE NOPOOL : bufsize 1 elapsed = 3
BYTE NOPOOL : bufsize 2 elapsed = 1
BYTE NOPOOL : bufsize 4 elapsed = 1
BYTE NOPOOL : bufsize 8 elapsed = 4
BYTE NOPOOL : bufsize 16 elapsed = 3
BYTE NOPOOL : bufsize 32 elapsed = 4
BYTE NOPOOL : bufsize 64 elapsed = 8
BYTE NOPOOL : bufsize 128 elapsed = 19
BYTE NOPOOL : bufsize 256 elapsed = 19
BYTE NOPOOL : bufsize 512 elapsed = 49
BYTE NOPOOL : bufsize 1024 elapsed = 80
BYTE NOPOOL : bufsize 2048 elapsed = 162
BYTE NOPOOL : bufsize 4096 elapsed = 308
BYTE NOPOOL : bufsize 8192 elapsed = 651
BYTE NOPOOL : bufsize 16384 elapsed = 1210
BYTE NOPOOL : bufsize 32768 elapsed = 2389
BYTE NOPOOL : bufsize 65536 elapsed = 4750
BYTE NOPOOL : bufsize 131072 elapsed = 9634
BYTE NOPOOL : bufsize 262144 elapsed = 19496
INT POOL : bufsize 1 elapsed = 6
INT POOL : bufsize 2 elapsed = 4
INT POOL : bufsize 4 elapsed = 4
INT POOL : bufsize 8 elapsed = 4
INT POOL : bufsize 16 elapsed = 6
INT POOL : bufsize 32 elapsed = 4
INT POOL : bufsize 64 elapsed = 4
INT POOL : bufsize 128 elapsed = 2
INT POOL : bufsize 256 elapsed = 4
INT POOL : bufsize 512 elapsed = 4
INT POOL : bufsize 1024 elapsed = 4
INT POOL : bufsize 2048 elapsed = 4
INT POOL : bufsize 4096 elapsed = 4
INT POOL : bufsize 8192 elapsed = 7
INT POOL : bufsize 16384 elapsed = 4
INT POOL : bufsize 32768 elapsed = 4
INT POOL : bufsize 65536 elapsed = 2
INT POOL : bufsize 131072 elapsed = 4
INT POOL : bufsize 262144 elapsed = 4
INT NOPOOL : bufsize 1 elapsed = 5
INT NOPOOL : bufsize 2 elapsed = 5
INT NOPOOL : bufsize 4 elapsed = 0
INT NOPOOL : bufsize 8 elapsed = 4
INT NOPOOL : bufsize 16 elapsed = 5
INT NOPOOL : bufsize 32 elapsed = 11
INT NOPOOL : bufsize 64 elapsed = 25
INT NOPOOL : bufsize 128 elapsed = 42
INT NOPOOL : bufsize 256 elapsed = 80
INT NOPOOL : bufsize 512 elapsed = 161
INT NOPOOL : bufsize 1024 elapsed = 306
INT NOPOOL : bufsize 2048 elapsed = 604
INT NOPOOL : bufsize 4096 elapsed = 1180
INT NOPOOL : bufsize 8192 elapsed = 2394
INT NOPOOL : bufsize 16384 elapsed = 4763
INT NOPOOL : bufsize 32768 elapsed = 9541
INT NOPOOL : bufsize 65536 elapsed = 18997
INT NOPOOL : bufsize 131072 elapsed = 38034
INT NOPOOL : bufsize 262144 elapsed = 76232

So we can conclude :
- using the pool for a primitive array is constant (but my pool is
very light, one object, the overhead of a real pool will be much
important)
- zeroing the array of int is four times zeroing the array of byte
- the time is very short, for an array of 256k, creating and
initializing an array if about 0.19 ms

so it really depends if the creation of array is really very intense
in your program

as always, profile first, optimize after :)