lucene管理IndexReader和IndexWriter

实例化IndexReader是非常昂贵的操作，且它是一个线程安全的，跟索引目录是一一对应的，通常我们只需要实例化一个IndexReader。当索引数据足够大（G的数量级）的时候，一般把索引资源按照某种规则散列到多个文件目录里（如：index-0,index-1,index-2.... 或者 blog,posts....），当然这些文件目录应该放在同一个根目录下---这时，最好的方式就是用一个Pool去维护这些IndexReader：保证一个文件目录只有一个实例，且不同的IndexReader可以动态的组合。


StandardIndexReaderPool.java

package com.qiu.search.pool.impl;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.store.FSDirectory;
import org.springframework.util.Assert;

import com.dukuai.search.exception.PoolException;
import com.dukuai.search.pool.IndexReaderPool;
import com.dukuai.search.util.IndexResourceUtil;
import com.spinn3r.log5j.Logger;

/**
 * {@link IndexReaderPool}的实现类。{@link StandardIndexReaderPool}确保一个目录至多只有一个{@link IndexReader}，它是线程安全的，
 * {@link IndexReader}也是线程安全
 * 
 */

public class StandardIndexReaderPool implements IndexReaderPool {
	private static final Logger LOG = Logger.getLogger(StandardIndexReaderPool.class);
	/** 低版本的IndexReader的存活时间 5s */
	private static final int STALE_INDEXREADER_SURVIVAL_TIME = 5000;

	private String name = null;
	// 索引文件的根目录的路径
	private String indexRootDirectory = null;
	// 索引文件目录名列表，目录名不包含路径
	private List<String> indexDirNameList = null;
	/**
	 * 存放IndexReader的Map，Map里存放的都是已经实例化好的IndexReader
	 */
	private final Map<String, IndexReader> indexReaderMap = new ConcurrentHashMap<String, IndexReader>();
	/**
	 * 待关闭的IndexReader。indexReader.reopen()之后，会产生新的IndexReader。但是旧的IndexReader有可能还被其他线程调用着。
	 * 旧的IndexReader都要放置到staleIndexReadersMap里，5秒之后再释放资源。
	 */
	private final Map<Long, IndexReader> staleIndexReadersMap = new ConcurrentHashMap<Long, IndexReader>();

	@Override
	public void setIndexDirNameList(List<String> indexDirNameList) {
		this.indexDirNameList = indexDirNameList;
	}

	public void init() {
		LOG.info("%s begin initialize", getName());
		for (String indexDirName : indexDirNameList) {
			try {
				IndexReader indexReader = createIndexReader(indexDirName);
				if (indexReader != null)
					indexReaderMap.put(indexDirName, indexReader);
			} catch (IOException e) {// 若初始化时出错，就直接抛错，终止程序再执行下去
				throw new PoolException(e);
			}
		}
		LOG.info("%s initialization complete", getName());
	}

	/**
	 * 根据indexDirPath，返回IndexReader。
	 * 
	 * @param indexDirName 文件目录名
	 * @return IndexReader
	 */
	public IndexReader getIndexReader(String indexDirName) {
		Assert.hasText(indexDirName, "this indexDirName must not be empty");

		IndexReader indexReader = indexReaderMap.get(indexDirName);
		if (indexReader != null)
			return refreshIndexReader(indexDirName, indexReader);

		synchronized (indexReaderMap) {
			if (!indexReaderMap.containsKey(indexDirName)) {
				try {
					indexReader = createIndexReader(indexDirName);
				} catch (CorruptIndexException e) {
					LOG.error("CorruptIndexException while creating IndexReader of %s,the root cause is %s",
							indexDirName, e.getMessage());
				} catch (IOException e) {
					LOG.error("IOException while creating IndexReader of %s,%s", indexDirName, e.getMessage());
				}
				if (indexReader != null)
					indexReaderMap.put(indexDirName, indexReader);
			}
		}
		return indexReaderMap.get(indexDirName);
	}

	/**
	 * 刷新指定的indexReader--加载新的索引数据,若产生新的indexReader，则在indexReaderMap里替换旧的indexReader
	 * 
	 * @param indexDirName
	 * @param indexReader
	 * @return {@link IndexReader}
	 */
	private synchronized IndexReader refreshIndexReader(String indexDirName, IndexReader indexReader) {
		try {
			closeStaleIndexReaders(staleIndexReadersMap);
			LOG.debug("hashCode of indexReader is %s", indexReader.hashCode());
			IndexReader newIndexReader = indexReader.reopen();
			if (newIndexReader != indexReader) {
				// this indexReader are old version
				IndexReader oldIndexReader = indexReader;
				/**
				 * may be this oldIndexReader was invoke by other thread,so put
				 * oldIndexReader to staleIndexReadersMap,closing it after 5s;
				 */
				staleIndexReadersMap.put(System.currentTimeMillis(), oldIndexReader);
				LOG.debug("hashCode of oldIndexReader is %s", oldIndexReader.hashCode());
				// replace old version IndexReader with newIndexReader
				indexReaderMap.put(indexDirName, newIndexReader);
				LOG.debug("hashCode of newIndexReader is %s", newIndexReader.hashCode());
			}
		} catch (Exception e) {
			LOG.error("Exception while getting IndexReader of %s,the root cause is %s", indexDirName, e.getMessage());
		}
		// return newest IndexReader
		return indexReaderMap.get(indexDirName);
	}

	/**
	 * 关闭所有低版本的IndexReaders
	 * 
	 * @param staleIndexReadersMap
	 */
	private void closeStaleIndexReaders(Map<Long, IndexReader> staleIndexReadersMap) {
		Iterator<Entry<Long, IndexReader>> entryIterator = staleIndexReadersMap.entrySet().iterator();
		while (entryIterator.hasNext()) {
			Entry<Long, IndexReader> entry = entryIterator.next();
			if ((System.currentTimeMillis() - entry.getKey()) >= STALE_INDEXREADER_SURVIVAL_TIME) {
				try {
					entry.getValue().close();
					LOG.debug("a stale IndexReader whose hashCode is %s has bean closed", entry.getValue().hashCode());
				} catch (IOException e) {
					LOG.error("IOException while colsing IndexReader,%s", e.getMessage());
				} finally {
					entryIterator.remove();
					LOG.debug("delete a stale IndexReader from pool,hashCode:" + entry.getValue().hashCode());
				}
			}
		}
	}

	public void destroy() {
		Iterator<Entry<String, IndexReader>> iterator = indexReaderMap.entrySet().iterator();
		while (iterator.hasNext()) {
			Entry<String, IndexReader> entry = iterator.next();
			IndexReader indexReader = entry.getValue();
			try {
				indexReader.close();
				indexReader = null;
			} catch (IOException e) {
				LOG.info("IOException while closing IndexReader whose indexDirName is %s", entry.getKey());
			}
		}
		indexReaderMap.clear();
		LOG.info("%s destroyed", getName());
	}
	/**
	 * 根据索引目录名实例化{@link IndexReader},有可能返回null，调用者需要判断返回的{@link IndexReader}是否为null
	 * 
	 * @param indexDirName
	 * @return {@link IndexReader}
	 *         返回indexDirName对应的IndexReader，如果对应的目录不存在就返回null，
	 */
	private IndexReader createIndexReader(String indexDirName) throws CorruptIndexException, IOException {
		File indexFile = new File(IndexResourceUtil.getDirPath(indexRootDirectory, indexDirName));
		if (IndexResourceUtil.isEmptyIndexDir(indexFile)) {
			LOG.warn("%s is empty,no index resource", indexDirName);
			return null;
		}
		if (indexFile.exists() && indexFile.isDirectory()) {// 判断索引目录是否存在。
			return IndexReader.open(FSDirectory.getDirectory(indexFile));
		}
		return null;
	}

	public int size() {
		return indexReaderMap.size();
	}

	@Override
	public String toString() {
		return (new ToStringBuilder(this).append("name", getName()).append("indexRootDirectory", indexRootDirectory)
				.append("size", size()).append("indexReader Set", indexReaderMap.keySet())).toString();
	}

	public String getName() {
		return name;
	}

	/** spring inject */
	public void setIndexRootDirectory(String indexRootDirectory) {
		this.indexRootDirectory = indexRootDirectory;
	}
	public void setName(String name) {
		this.name = name;
	}

}

IndexWriter也需要Pool来管理

StandardIndexWriterPool.java

文章来源：http://www.xinxilong.com

作者：不详　来源：网络

• ·百度贴吧推广大师2.2.1
• ·石青微博营销软件2.4.1.1
• ·石青邮件大师2.2.6.1
• ·百度关键字优化精灵2.3.6.1
• ·石青微信工具箱1.3.5.1
• ·快手解封助手1.1.2.1
• ·百度知道推广大师2.1.7.1
• ·石青抖音推广大师软件1.2.5.1
• ·小红书解封助手1.0.9.1
• ·淘宝推广大师2.2.6.1
• ·论坛群发大师2.5.3
• ·博客群发大师2.5.7
• ·石青伪原创软件1.7.5.1
• ·百度热议删除软件1.3.0.1
• ·石青抖音营销软件1.3.0.1
• ·石青微博私信软件1.2.2.1
• ·网格回测工具1.2.9.1
• ·剪映备份大师1.1.4.1
• ·B站视频快传助手1.0.2.1
• ·小红书解封助手1.0.8.1