JAVA怎样做一个缓存到一定量数据后批量转移到其他地方，避免缓存太大至内存溢出？

0 0

JAVA怎样做一个缓存到一定量数据后批量转移到其他地方，避免缓存太大至内存溢出？15

我想实现一个缓存队列，并发情况下向该队列写入，当达到一定量后，缓存中转移一部分数据到数据库中，同时也有多条线程在消费该缓存队列，类是一个生产者-消费者，生产能力远大于消费能力，求各位给个思路。

下面是我的一段代码，运行起来不报错，但是达不到我要的效果，也请各位看看，指点下问题。

package com.pb.test.queue;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;

public class MessageQueue {
	private BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>(10);

	private BlockingQueue<Object> bufferQueue = new LinkedBlockingQueue<Object>();

	// 模拟数据库
	private BlockingQueue<Object> dbQueue = new LinkedBlockingQueue<Object>();

	private final AtomicBoolean isQueueAdded = new AtomicBoolean(true);

	private final ReentrantLock putLock = new ReentrantLock();

	public void add(Object o) {
		if (isQueueAdded.get()) {
			if (!queue.offer(o)) {
				addBuffer(o);
				isQueueAdded.set(false);
			}
		} else {
			addBuffer(o);
		}
	}

	private void addBuffer(Object o) {
		bufferQueue.offer(o);

		// 模拟向数据库写入
		if (bufferQueue.size() >= 20) {
			List<Object> ary = new ArrayList<Object>();
			bufferQueue.drainTo(ary);

			for (Object i : ary) {
				dbQueue.offer(i);
			}
		}
	}

	/**
	 * 先从queue开始消费，消费完了开始消费数据库缓存的，然后在消费bufferQueue队列中的
	 * 
	 * @return
	 */
	public Object poll() {
		Object o = queue.poll();
		if (o != null) {
			return o;
		}

		final ReentrantLock putLock = this.putLock;
		putLock.lock();
		try {
			List<Object> ary = new ArrayList<Object>(10);
			int s = dbQueue.drainTo(ary, 10);

			if (s == 0) {
				o = bufferQueue.poll();

				if (o == null) {
					isQueueAdded.set(true);
				}

				return o;
			} else {
				for (Object i : ary) {
					queue.offer(i);
				}

				return queue.poll();
			}

		} finally {
			putLock.unlock();
		}
	}

	public void display() {
		System.out.println(queue.size() + "\t" + bufferQueue.size() + "\t" + dbQueue.size() + "\t" + (queue.size() + bufferQueue.size() + dbQueue.size()));
	}
}

问题补充：

successfulroof 写道

去看看ArrayList的源码，里面有个ensureCapasity，你可以模仿，如果queue的长度要超过你的最大长度，你可以把老的一部分copy到你的数据库queue里面去。
记住你的这个类里面的方法要加锁，这样保证线程方面的安全~！

看了下ensureCapacity，感觉那种思路在并发情况下不适用啊。
还有其他办法吗？