public boolean putKey(final String key, final long phyOffset, final long storeTimestamp) {
    	//判斷當(dāng)前的條目數(shù)是否大于最大的允許的條目數(shù)
        if (this.indexHeader.getIndexCount() < this.indexNum) {
        	//獲取KEY的hash值（正整數(shù)）
            int keyHash = indexKeyHashMethod(key);
            //計(jì)算hash槽的下標(biāo)
            int slotPos = keyHash % this.hashSlotNum;
            //獲取hash槽的物理地址
            int absSlotPos = IndexHeader.INDEX_HEADER_SIZE + slotPos * hashSlotSize;
            FileLock fileLock = null;
            try {
                // fileLock = this.fileChannel.lock(absSlotPos, hashSlotSize,
                // false);
            	//獲取hash槽中存儲(chǔ)的數(shù)據(jù)
                int slotValue = this.mappedByteBuffer.getInt(absSlotPos);
                //判斷值是否小于等于0或者 大于當(dāng)前索引文件的最大條目
                if (slotValue <= invalidIndex || slotValue > this.indexHeader.getIndexCount()) {
                    slotValue = invalidIndex;
                }
                //計(jì)算當(dāng)前消息存儲(chǔ)時(shí)間與第一條消息時(shí)間戳的時(shí)間差
                long timeDiff = storeTimestamp - this.indexHeader.getBeginTimestamp();
                //秒
                timeDiff = timeDiff / 1000;
                if (this.indexHeader.getBeginTimestamp() <= 0) {
                    timeDiff = 0;
                } else if (timeDiff > Integer.MAX_VALUE) {
                    timeDiff = Integer.MAX_VALUE;
                } else if (timeDiff < 0) {
                    timeDiff = 0;
                }
                //計(jì)算條目的物理地址  = 索引頭部大?。?0字節(jié)） + hash槽的大小(4字節(jié))*槽的數(shù)量（500w） + 當(dāng)前索引最大條目的個(gè)數(shù)*每index的大小（20字節(jié)）
                int absIndexPos =
                    IndexHeader.INDEX_HEADER_SIZE + this.hashSlotNum * hashSlotSize
                        + this.indexHeader.getIndexCount() * indexSize;
                //依次存入 key的hash值（4字節(jié)）+消息的物理偏移量（8字節(jié)）+消息存儲(chǔ)時(shí)間戳和index文件的時(shí)間戳差（4字節(jié)）+當(dāng)前hash槽的值（4字節(jié)）
                this.mappedByteBuffer.putInt(absIndexPos, keyHash);
                this.mappedByteBuffer.putLong(absIndexPos + 4, phyOffset);
                this.mappedByteBuffer.putInt(absIndexPos + 4 + 8, (int) timeDiff);
                this.mappedByteBuffer.putInt(absIndexPos + 4 + 8 + 4, slotValue);
                //存儲(chǔ)當(dāng)前index中包含的條目數(shù)量存入hash槽中，覆蓋原先hash槽的值
                this.mappedByteBuffer.putInt(absSlotPos, this.indexHeader.getIndexCount());
                
                if (this.indexHeader.getIndexCount() <= 1) {
                    this.indexHeader.setBeginPhyOffset(phyOffset);
                    this.indexHeader.setBeginTimestamp(storeTimestamp);
                }
                //更新文件索引的頭信息，hash槽的總數(shù)、index條目的總數(shù)、最后消息的物理偏移量、最后消息的存儲(chǔ)時(shí)間
                this.indexHeader.incHashSlotCount();
                this.indexHeader.incIndexCount();
                this.indexHeader.setEndPhyOffset(phyOffset);
                this.indexHeader.setEndTimestamp(storeTimestamp);
                return true;
            } catch (Exception e) {
                log.error("putKey exception, Key: " + key + " KeyHashCode: " + key.hashCode(), e);
            } finally {
                if (fileLock != null) {
                    try {
                        fileLock.release();
                    } catch (IOException e) {
                        log.error("Failed to release the lock", e);
                    }
                }
            }
        } else {
            log.warn("Over index file capacity: index count = " + this.indexHeader.getIndexCount()
                + "; index max num = " + this.indexNum);
        }
        return false;
    }

public QueryMessageResult queryMessage(String topic, String key, int maxNum, long begin, long end) 

QueryOffsetResult queryOffsetResult = this.indexService.queryOffset(topic, key, maxNum, begin, lastQueryMsgTime);

public QueryOffsetResult queryOffset(String topic, String key, int maxNum, long begin, long end)

public void selectPhyOffset(final List<Long> phyOffsets, final String key, final int maxNum, final long begin, final long end, boolean lock)

public void selectPhyOffset(final List<Long> phyOffsets, final String key, final int maxNum,
	final long begin, final long end, boolean lock) {
	if (this.mappedFile.hold()) {
		//獲取key的hash信息
		int keyHash = indexKeyHashMethod(key);
		//獲取hash槽的下標(biāo)
		int slotPos = keyHash % this.hashSlotNum;
		//獲取hash槽的物理地址
		int absSlotPos = IndexHeader.INDEX_HEADER_SIZE + slotPos * hashSlotSize;
		FileLock fileLock = null;
		try {
			if (lock) {
				// fileLock = this.fileChannel.lock(absSlotPos,
				// hashSlotSize, true);
			}
			//獲取hash槽的值
			int slotValue = this.mappedByteBuffer.getInt(absSlotPos);
			// if (fileLock != null) {
			// fileLock.release();
			// fileLock = null;
			// }
			//判斷值是否小于等于0或者 大于當(dāng)前索引文件的最大條目
			if (slotValue <= invalidIndex || slotValue > this.indexHeader.getIndexCount()
				|| this.indexHeader.getIndexCount() <= 1) {
			} else {
				for (int nextIndexToRead = slotValue; ; ) {
					if (phyOffsets.size() >= maxNum) {
						break;
					}
					//計(jì)算條目的物理地址  = 索引頭部大小（40字節(jié)） + hash槽的大小(4字節(jié))*槽的數(shù)量（500w） + 當(dāng)前索引最大條目的個(gè)數(shù)*每index的大?。?0字節(jié)）
					int absIndexPos =
						IndexHeader.INDEX_HEADER_SIZE + this.hashSlotNum * hashSlotSize
							+ nextIndexToRead * indexSize;
					//獲取key的hash值
					int keyHashRead = this.mappedByteBuffer.getInt(absIndexPos);
					//獲取消息的物理偏移量
					long phyOffsetRead = this.mappedByteBuffer.getLong(absIndexPos + 4);
					//獲取當(dāng)前消息的存儲(chǔ)時(shí)間戳與index文件的時(shí)間戳差值
					long timeDiff = (long) this.mappedByteBuffer.getInt(absIndexPos + 4 + 8);
					//獲取前一個(gè)條目的信息（鏈表結(jié)構(gòu)）
					int prevIndexRead = this.mappedByteBuffer.getInt(absIndexPos + 4 + 8 + 4);
					if (timeDiff < 0) {
						break;
					}
					timeDiff *= 1000L;
					long timeRead = this.indexHeader.getBeginTimestamp() + timeDiff;
					//判斷該消息是否在查詢的區(qū)間
					boolean timeMatched = (timeRead >= begin) && (timeRead <= end);
					//判斷key的hash值是否相等并且在查詢的時(shí)間區(qū)間內(nèi)
					if (keyHash == keyHashRead && timeMatched) {
						//加入到物理偏移量的List中
						phyOffsets.add(phyOffsetRead);
					}
					if (prevIndexRead <= invalidIndex
						|| prevIndexRead > this.indexHeader.getIndexCount()
						|| prevIndexRead == nextIndexToRead || timeRead < begin) {
						break;
					}
					//繼續(xù)前一個(gè)條目信息獲取進(jìn)行匹配
					nextIndexToRead = prevIndexRead;
				}
			}
		} catch (Exception e) {
			log.error("selectPhyOffset exception ", e);
		} finally {
			if (fileLock != null) {
				try {
					fileLock.release();
				} catch (IOException e) {
					log.error("Failed to release the lock", e);
				}
			}
			this.mappedFile.release();
		}
	}
}