net.rubyeye.xmemcached.buffer.CachedBufferAllocator Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of xmemcached Show documentation
Extreme performance modern memcached client for java
There is a newer version: 2.4.8
/**
 *Copyright [2009-2010] [dennis zhuang([email protected])]
 *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
 */
/**
 *Copyright [2009-2010] [dennis zhuang([email protected])]
 *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 net.rubyeye.xmemcached.buffer;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;

import net.rubyeye.xmemcached.utils.ByteUtils;

import com.google.code.yanf4j.util.CircularQueue;

/**
 * Cached IoBuffer allocator,cached buffer in ThreadLocal.
 * 
 * @author dennis
 * 
 */
@Deprecated
public class CachedBufferAllocator implements BufferAllocator {

	private static final int DEFAULT_MAX_POOL_SIZE = 8;
	private static final int DEFAULT_MAX_CACHED_BUFFER_SIZE = 1 << 18; // 256KB
	private final int maxPoolSize;
	private final int maxCachedBufferSize;
	private final ThreadLocal>> heapBuffers;
	private final IoBuffer EMPTY_IO_BUFFER = new CachedBufferAllocator.CachedIoBuffer(
			ByteBuffer.allocate(0));

	/**
	 * Creates a new instance with the default parameters ({@literal
	 * #DEFAULT_MAX_POOL_SIZE} and {@literal #DEFAULT_MAX_CACHED_BUFFER_SIZE}).
	 */
	public CachedBufferAllocator() {
		this(DEFAULT_MAX_POOL_SIZE, DEFAULT_MAX_CACHED_BUFFER_SIZE);
	}

	/**
	 * Creates a new instance.
	 * 
	 * @param maxPoolSize
	 *            the maximum number of buffers with the same capacity per
	 *            thread. 0 disables this limitation.
	 * @param maxCachedBufferSize
	 *            the maximum capacity of a cached buffer. A buffer whose
	 *            capacity is bigger than this value is not pooled. 0
	 *            disables this limitation.
	 */
	public CachedBufferAllocator(int maxPoolSize, int maxCachedBufferSize) {
		if (maxPoolSize < 0) {
			throw new IllegalArgumentException("maxPoolSize: " + maxPoolSize);
		}
		if (maxCachedBufferSize < 0) {
			throw new IllegalArgumentException("maxCachedBufferSize: "
					+ maxCachedBufferSize);
		}

		this.maxPoolSize = maxPoolSize;
		this.maxCachedBufferSize = maxCachedBufferSize;

		this.heapBuffers = new ThreadLocal>>() {

			
			@Override
			protected Map> initialValue() {
				return newPoolMap();
			}
		};
	}

	public int getMaxPoolSize() {
		return this.maxPoolSize;
	}

	public int getMaxCachedBufferSize() {
		return this.maxCachedBufferSize;
	}

	/**
	 * 初始化缓冲池
	 * 
	 * @return
	 */
	private Map> newPoolMap() {
		Map> poolMap = new HashMap>();
		int poolSize = this.maxPoolSize == 0 ? DEFAULT_MAX_POOL_SIZE
				: this.maxPoolSize;
		for (int i = 0; i < 31; i++) {
			poolMap.put(1 << i, new CircularQueue(poolSize));
		}
		poolMap.put(0, new CircularQueue(poolSize));
		poolMap.put(Integer.MAX_VALUE, new CircularQueue(
				poolSize));
		return poolMap;
	}

	public final IoBuffer allocate(int requestedCapacity) {
		if (requestedCapacity == 0) {
			return this.EMPTY_IO_BUFFER;
		}
		// 圆整requestedCapacity到2的x次方
		int actualCapacity = ByteUtils.normalizeCapacity(requestedCapacity);
		IoBuffer buf;
		if (this.maxCachedBufferSize != 0
				&& actualCapacity > this.maxCachedBufferSize) {
			buf = wrap(ByteBuffer.allocate(actualCapacity));
		} else {
			Queue pool;
			pool = this.heapBuffers.get().get(actualCapacity);
			// 从池中取
			buf = pool.poll();
			if (buf != null) {
				buf.clear();
			} else {
				buf = wrap(ByteBuffer.allocate(actualCapacity));
			}
		}
		buf.limit(requestedCapacity);
		return buf;
	}

	public final IoBuffer wrap(ByteBuffer nioBuffer) {
		return new CachedIoBuffer(nioBuffer);
	}

	public void dispose() {
		this.heapBuffers.remove();
	}

	public static BufferAllocator newInstance() {
		return new CachedBufferAllocator();
	}

	public static BufferAllocator newInstance(int maxPoolSize,
			int maxCachedBufferSize) {
		return new CachedBufferAllocator(maxPoolSize, maxCachedBufferSize);
	}

	public class CachedIoBuffer implements IoBuffer {

		Thread ownerThread; // 所分配的线程
		ByteBuffer origBuffer;

		public CachedIoBuffer(ByteBuffer origBuffer) {
			super();
			this.ownerThread = Thread.currentThread();
			this.origBuffer = origBuffer;
		}

		
		public void putInt(int i) {
			this.origBuffer.putInt(i);

		}

		
		public void putShort(short s) {
			this.origBuffer.putShort(s);
		}

		
		public ByteOrder order() {
			return this.origBuffer.order();
		}

		
		public boolean isDirect() {
			return this.origBuffer.isDirect();
		}

		
		public void order(ByteOrder byteOrder) {
			this.origBuffer.order(byteOrder);
		}
		
		public void putLong(long l) {
			this.origBuffer.putLong(l);

		}
		
		public final void free() {
			if (this.origBuffer == null
					|| this.origBuffer.capacity() > CachedBufferAllocator.this.maxCachedBufferSize
					|| Thread.currentThread() != this.ownerThread) {
				return;
			}

			// Add to the cache.
			Queue pool;
			pool = CachedBufferAllocator.this.heapBuffers.get().get(
					this.origBuffer.capacity());
			if (pool == null) {
				return;
			}
			// 防止OOM
			if (CachedBufferAllocator.this.maxPoolSize == 0
					|| pool.size() < CachedBufferAllocator.this.maxPoolSize) {
				pool.offer(new CachedIoBuffer(this.origBuffer));
			}
			this.origBuffer = null;

		}

		
		public final ByteBuffer[] getByteBuffers() {
			return new ByteBuffer[] { this.origBuffer };
		}

		
		public final void put(byte[] bytes) {
			this.origBuffer.put(bytes);
		}

		
		public final int capacity() {
			return this.origBuffer.capacity();
		}

		
		public final void clear() {
			this.origBuffer.clear();
		}

		
		public final void reset() {
			this.origBuffer.reset();
		}

		
		public final int remaining() {
			return this.origBuffer.remaining();
		}

		
		public final int position() {
			return this.origBuffer.position();
		}

		
		public final void mark() {
			this.origBuffer.mark();
		}

		
		public final int limit() {
			return this.origBuffer.limit();
		}

		
		public final boolean hasRemaining() {
			return this.origBuffer.hasRemaining();
		}

		
		public final void flip() {
			this.origBuffer.flip();
		}

		
		public final void put(byte b) {
			this.origBuffer.put(b);
		}

		
		public final void put(ByteBuffer buff) {
			this.origBuffer.put(buff);
		}

		
		public final ByteBuffer getByteBuffer() {
			return this.origBuffer;
		}

		
		public final void limit(int limit) {
			this.origBuffer.limit(limit);
		}

		
		public final void position(int pos) {
			this.origBuffer.position(pos);
		}
	}
}