src.android.util.Pools Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.util;
import android.compat.annotation.UnsupportedAppUsage;
/**
* Helper class for crating pools of objects. An example use looks like this:
*
* public class MyPooledClass {
*
* private static final SynchronizedPool sPool =
* new SynchronizedPool(10);
*
* public static MyPooledClass obtain() {
* MyPooledClass instance = sPool.acquire();
* return (instance != null) ? instance : new MyPooledClass();
* }
*
* public void recycle() {
* // Clear state if needed.
* sPool.release(this);
* }
*
* . . .
* }
*
*
* @hide
*/
public final class Pools {
/**
* Interface for managing a pool of objects.
*
* @param The pooled type.
*/
public static interface Pool {
/**
* @return An instance from the pool if such, null otherwise.
*/
@UnsupportedAppUsage
public T acquire();
/**
* Release an instance to the pool.
*
* @param instance The instance to release.
* @return Whether the instance was put in the pool.
*
* @throws IllegalStateException If the instance is already in the pool.
*/
@UnsupportedAppUsage
public boolean release(T instance);
}
private Pools() {
/* do nothing - hiding constructor */
}
/**
* Simple (non-synchronized) pool of objects.
*
* @param The pooled type.
*/
public static class SimplePool implements Pool {
@UnsupportedAppUsage
private final Object[] mPool;
private int mPoolSize;
/**
* Creates a new instance.
*
* @param maxPoolSize The max pool size.
*
* @throws IllegalArgumentException If the max pool size is less than zero.
*/
@UnsupportedAppUsage
public SimplePool(int maxPoolSize) {
if (maxPoolSize <= 0) {
throw new IllegalArgumentException("The max pool size must be > 0");
}
mPool = new Object[maxPoolSize];
}
@Override
@SuppressWarnings("unchecked")
@UnsupportedAppUsage
public T acquire() {
if (mPoolSize > 0) {
final int lastPooledIndex = mPoolSize - 1;
T instance = (T) mPool[lastPooledIndex];
mPool[lastPooledIndex] = null;
mPoolSize--;
return instance;
}
return null;
}
@Override
@UnsupportedAppUsage
public boolean release(T instance) {
if (isInPool(instance)) {
throw new IllegalStateException("Already in the pool!");
}
if (mPoolSize < mPool.length) {
mPool[mPoolSize] = instance;
mPoolSize++;
return true;
}
return false;
}
private boolean isInPool(T instance) {
for (int i = 0; i < mPoolSize; i++) {
if (mPool[i] == instance) {
return true;
}
}
return false;
}
}
/**
* Synchronized pool of objects.
*
* @param The pooled type.
*/
public static class SynchronizedPool extends SimplePool {
private final Object mLock;
/**
* Creates a new instance.
*
* @param maxPoolSize The max pool size.
* @param lock an optional custom object to synchronize on
*
* @throws IllegalArgumentException If the max pool size is less than zero.
*/
public SynchronizedPool(int maxPoolSize, Object lock) {
super(maxPoolSize);
mLock = lock;
}
/** @see #SynchronizedPool(int, Object) */
@UnsupportedAppUsage
public SynchronizedPool(int maxPoolSize) {
this(maxPoolSize, new Object());
}
@Override
@UnsupportedAppUsage
public T acquire() {
synchronized (mLock) {
return super.acquire();
}
}
@Override
@UnsupportedAppUsage
public boolean release(T element) {
synchronized (mLock) {
return super.release(element);
}
}
}
}