public class ObjectId implements Comparable<ObjectId> , java.io.Serializable {
 
    static final boolean D = false;
 
    /** Gets a new object id.
     * @return the new id
     */
    public static ObjectId get(){
        return new ObjectId();
    }
 
    /** Checks if a string could be an <code>ObjectId</code>.
     * @return whether the string could be an object id
     */
    public static boolean isValid( String s ){
        if ( s == null )
            return false;
 
        if ( s.length() < 18 )
            return false;
 
        for ( int i=0; i<s.length(); i++ ){
            char c = s.charAt( i );
            if ( c >= '0' && c <= '9' )
                continue;
            if ( c >= 'a' && c <= 'f' )
                continue;
            if ( c >= 'A' && c <= 'F' )
                continue;
 
            return false;
        }        
 
        return true;
    }
 
    /** Turn an object into an <code>ObjectId</code>, if possible.
     * Strings will be converted into <code>ObjectId</code>s, if possible, and <code>ObjectId</code>s will
     * be cast and returned.  Passing in <code>null</code> returns <code>null</code>.
     * @param o the object to convert 
     * @return an <code>ObjectId</code> if it can be massaged, null otherwise 
     */
    public static ObjectId massageToObjectId( Object o ){
        if ( o == null )
            return null;
 
        if ( o instanceof ObjectId )
            return (ObjectId)o;
 
        if ( o instanceof String ){
            String s = o.toString();
            if ( isValid( s ) )
                return new ObjectId( s );
        }
 
        return null;
    }
 
    public ObjectId( Date time ){
        _time = _flip( (int)(time.getTime() / 1000) );
        _machine = _genmachine;
        synchronized ( _incLock ){
            _inc = _nextInc++;
        }     
        _new = false;
    }
 
    public ObjectId( Date time , int inc ){
        this( time , _genmachine , inc );
    }
 
    public ObjectId( Date time , int machine , int inc ){
        _time = _flip( (int)(time.getTime() / 1000) );
        _machine = machine;
        _inc = inc;
        _new = false;
    }
 
 
    /** Creates a new instance from a string.
     * @param s the string to convert
     * @throws IllegalArgumentException if the string is not a valid id
     */
    public ObjectId( String s ){
        this( s , false );
    }
 
    public ObjectId( String s , boolean babble ){
 
        if ( ! isValid( s ) )
            throw new IllegalArgumentException( "invalid ObjectId [" + s + "]" );
 
        if ( babble )
            s = babbleToMongod( s );
 
        byte b[] = new byte[12];
        for ( int i=0; i<b.length; i++ ){
            b[b.length-(i+1)] = (byte)Integer.parseInt( s.substring( i*2 , i*2 + 2) , 16 );
        }
        ByteBuffer bb = ByteBuffer.wrap( b );
 
        _inc = bb.getInt(); 
        _machine = bb.getInt();
        _time = bb.getInt();
 
        _new = false;
    }
 
    public ObjectId( byte[] b ){
        if ( b.length != 12 )
            throw new IllegalArgumentException( "need 12 bytes" );
        reverse( b );
        ByteBuffer bb = ByteBuffer.wrap( b );
 
        _inc = bb.getInt();            
        _machine = bb.getInt();
        _time = bb.getInt();
    }
 
 
    public ObjectId( int time , int machine , int inc ){
        _time = time;
        _machine = machine;
        _inc = inc;
 
        _new = false;
    }
 
    /** Create a new object id.
     */
    public ObjectId(){
        _time = _gentime;
        _machine = _genmachine;
 
        synchronized ( _incLock ){
            _inc = _nextInc++;
        }
 
        _new = true;
    }
 
    public int hashCode(){
        return _inc;
    }
 
    public boolean equals( Object o ){
 
        if ( this == o )
            return true;
 
        ObjectId other = massageToObjectId( o );
        if ( other == null )
            return false;
 
        return 
            _time == other._time && 
            _machine == other._machine && 
            _inc == other._inc;
    }
 
    public String toStringBabble(){
        return babbleToMongod( toStringMongod() );
    }
 
    public String toStringMongod(){
        byte b[] = toByteArray();
 
        StringBuilder buf = new StringBuilder(24);
 
        for ( int i=0; i<b.length; i++ ){
            int x = b[i] & 0xFF;
            String s = Integer.toHexString( x );
            if ( s.length() == 1 )
                buf.append( "0" );
            buf.append( s );
        }
 
        return buf.toString();
    }
 
    public byte[] toByteArray(){
        byte b[] = new byte[12];
        ByteBuffer bb = ByteBuffer.wrap( b );
        bb.putInt( _inc );
        bb.putInt( _machine );
        bb.putInt( _time );
        reverse( b );
        return b;
    }
 
    static void reverse( byte[] b ){
        for ( int i=0; i<b.length/2; i++ ){
            byte t = b[i];
            b[i] = b[ b.length-(i+1) ];
            b[b.length-(i+1)] = t;
        }
    }
 
    static String _pos( String s , int p ){
        return s.substring( p * 2 , ( p * 2 ) + 2 );
    }
 
    public static String babbleToMongod( String b ){
        if ( ! isValid( b ) )
            throw new IllegalArgumentException( "invalid object id: " + b );
 
        StringBuilder buf = new StringBuilder( 24 );
        for ( int i=7; i>=0; i-- )
            buf.append( _pos( b , i ) );
        for ( int i=11; i>=8; i-- )
            buf.append( _pos( b , i ) );
 
        return buf.toString();
    }
 
    public String toString(){
        return toStringMongod();
    }
 
    public int compareTo( ObjectId id ){
        if ( id == null )
            return -1;
 
        long xx = id.getTime() - getTime();
        if ( xx > 0 )
            return -1;
        else if ( xx < 0 )
            return 1;
 
        int x = id._machine - _machine;
        if ( x != 0 )
            return -x;
 
        x = id._inc - _inc;
        if ( x != 0 )
            return -x;
 
        return 0;
    }
 
    public int getMachine(){
        return _machine;
    }
 
    public long getTime(){
        long z = _flip( _time );
        return z * 1000;
    }
 
    public int getInc(){
        return _inc;
    }
 
    public int _time(){
        return _time;
    }
    public int _machine(){
        return _machine;
    }
    public int _inc(){
        return _inc;
    }
 
    public boolean isNew(){
        return _new;
    }
 
    public void notNew(){
        _new = false;
    }
 
    final int _time;
    final int _machine;
    final int _inc;
 
    boolean _new;
 
    static int _flip( int x ){
        if ( true ){
            byte b[] = new byte[4];
            ByteBuffer bb = ByteBuffer.wrap( b );
            bb.order( ByteOrder.LITTLE_ENDIAN );
            bb.putInt( x );
            bb.flip();
            bb.order( ByteOrder.BIG_ENDIAN );
            return bb.getInt();
        }
        int z = 0;
        z |= ( x & 0xFF ) << 24;
        z |= ( x & 0xFF00 ) << 8;
        z |= ( x & 0xFF00000 ) >> 8;
        z |= ( x & 0xFF000000 ) >> 24;
        return z;
    }
 
    private static int _nextInc = (new java.util.Random()).nextInt();
    private static final String _incLock = new String( "ObjectId._incLock" );
 
    private static int _gentime = _flip( (int)(System.currentTimeMillis()/1000) );
 
    static final Thread _timeFixer;
    private static final int _genmachine;
    static {
 
        try {
 
            final int machinePiece;
            {
                StringBuilder sb = new StringBuilder();
                Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces();
                while ( e.hasMoreElements() ){
                    NetworkInterface ni = e.nextElement();
                    sb.append( ni.toString() );
                }
                machinePiece = sb.toString().hashCode() << 16;
                if ( D ) System.out.println( "machine piece post: " + Integer.toHexString( machinePiece ) );
            }
 
            final int processPiece = java.lang.management.ManagementFactory.getRuntimeMXBean().getName().hashCode() & 0xFFFF;
            if ( D ) System.out.println( "process piece: " + Integer.toHexString( processPiece ) );
 
            _genmachine = machinePiece | processPiece;
            if ( D ) System.out.println( "machine : " + Integer.toHexString( _genmachine ) );
        }
        catch ( java.io.IOException ioe ){
            throw new RuntimeException( ioe );
        }
 
        _timeFixer = new Thread("ObjectId-TimeFixer"){
                public void run(){
                    while ( true ){
                        try {
                            Thread.sleep( 499 );
                        }
                        catch ( Exception e ){}
                        _gentime = _flip( (int)(System.currentTimeMillis()/1000) );
                    }
                }
            };
        _timeFixer.setDaemon( true );
        _timeFixer.start();
    }
 
}

private boolean copyAFile(final File tmpIdxDir, final File indexDir, final String fname, final List<String> copiedfiles) {
    final File indexFileInTmpDir = new File(tmpIdxDir, fname);
    final File indexFileInIndex = new File(indexDir, fname);
    final boolean success = indexFileInTmpDir.renameTo(indexFileInIndex);
    if (!success) {
      LOG.error("Unable to move index file from: " + indexFileInTmpDir
          + " to: " + indexFileInIndex);
      for (final String f : copiedfiles) {
        final File indexFile = new File(indexDir, f);
        if (indexFile.exists()) {
          indexFile.delete();
        }
      }
      delTree(tmpIdxDir);
      return false;
    }
    return true;
  }

 private File createTempindexDir(final SolrCore core) {
    final String tmpIdxDirName = "index." + new SimpleDateFormat(SnapShooter.DATE_FMT).format(new Date());
    final File tmpIdxDir = new File(core.getDataDir(), tmpIdxDirName);
    tmpIdxDir.mkdirs();
    return tmpIdxDir;
  }

  public static final String DATE_FMT = "yyyyMMddhhmmss";

	public void setDefaultMaxConnectionsPerHost(int maxHostConnections);
	public void setMaxTotalConnections(int maxTotalConnections);

    /** The default maximum number of connections allowed per host */
    public static final int DEFAULT_MAX_HOST_CONNECTIONS = 2;   // Per RFC 2616 sec 8.1.4
 
    /** The default maximum number of connections allowed overall */
    public static final int DEFAULT_MAX_TOTAL_CONNECTIONS = 20;

    _httpClient = (client == null) ? new HttpClient(new MultiThreadedHttpConnectionManager()) : client;
    if (client == null) {
      // set some better defaults if we created a new connection manager and client
      // increase the default connections
      this.setDefaultMaxConnectionsPerHost( 32 );  // 2
      this.setMaxTotalConnections( 128 ); // 20
    }

public abstract class RefCounted<Type> {
  protected final Type resource;
  protected final AtomicInteger refcount = new AtomicInteger();
 
  public RefCounted(Type resource) {
    this.resource = resource;
  }
 
  public int getRefcount() {
    return refcount.get();
  }
 
  public final RefCounted<Type> incref() {
    refcount.incrementAndGet();
    return this;
  }
 
  public final Type get() {
    return resource;
  }
 
  public void decref() {
    if (refcount.decrementAndGet() == 0) {
      close();
    }
  }
 
  protected abstract void close();
}

private RefCounted<SolrIndexSearcher> _searcher

private final LinkedList<RefCounted<SolrIndexSearcher>> _searchers

RefCounted<SolrIndexSearcher>

  private RefCounted<SolrIndexSearcher> newHolder(SolrIndexSearcher newSearcher) {
    RefCounted<SolrIndexSearcher> holder = new RefCounted<SolrIndexSearcher>(newSearcher) {
      public void close() {
        try {
          synchronized(searcherLock) {
            // it's possible for someone to get a reference via the _searchers queue
            // and increment the refcount while RefCounted.close() is being called.
            // we check the refcount again to see if this has happened and abort the close.
            // This relies on the RefCounted class allowing close() to be called every
            // time the counter hits zero.
            if (refcount.get() > 0) return;
            _searchers.remove(this);
          }
          resource.close();
        } catch (IOException e) {
          log.error("Error closing searcher:" + SolrException.toStr(e));
        }
      }
    };
    holder.incref();  // set ref count to 1 to account for this._searcher
    return holder;
  }

  protected RefCounted<SolrIndexSearcher> searcherHolder;
  public SolrIndexSearcher getSearcher() {
    if(core == null) return null;//a request for a core admin will no have a core
    // should this reach out and get a searcher from the core singleton, or
    // should the core populate one in a factory method to create requests?
    // or there could be a setSearcher() method that Solr calls
    if (searcherHolder==null) {
      searcherHolder = core.getSearcher();
    }
    return searcherHolder.get();
  }
  public void close() {
    if (searcherHolder!=null) {
      searcherHolder.decref();
      searcherHolder = null;
    }
  }

private final AtomicInteger refCount = new AtomicInteger(1);
 
  final void open() {
    refCount.incrementAndGet();
  }
  public void close() {
    int count = refCount.decrementAndGet();
    if (count > 0) return; // close is called often, and only actually closes if nothing is using it.
    if (count < 0) {
      log.error("Too many close [count:{}] on {}. Please report this exception to solr-user@lucene.apache.org", count, this );
      return;
    }
    //释放对象和资源
  }

public SolrCore getCore(String name) {
    synchronized(cores) {
      SolrCore core = cores.get(name);
      if (core != null)
        core.open();  // increment the ref count while still synchronized
      return core;
    }
  }

<schema name="eshequn.post.db_post.0" version="1.1"
    xmlns:xi="http://www.w3.org/2001/XInclude">
     <fields>
     	<!-- for title -->
        <field name="t" type="text" indexed="true" stored="false" />
        <!-- for abstract -->
        <field name="a" type="text" indexed="true" stored="false" />
        <!-- for title and abstract -->
        <field name="ta" type="text" indexed="true" stored="false" multiValued="true"/>
    </fields>
    <copyField source="t" dest="ta" />
    <copyField source="a" dest="ta" />
</schema>

class DocSetCollector extends Collector {
  int pos=0;
  OpenBitSet bits;
  final int maxDoc;
  final int smallSetSize;
  int base;
  // in case there aren't that many hits, we may not want a very sparse
  // bit array.  Optimistically collect the first few docs in an array
  // in case there are only a few.
  final int[] scratch;
  DocSetCollector(int smallSetSize, int maxDoc) {
    this.smallSetSize = smallSetSize;
    this.maxDoc = maxDoc;
    this.scratch = new int[smallSetSize];
  }
  public void collect(int doc) throws IOException {
    doc += base;
    // optimistically collect the first docs in an array
    // in case the total number will be small enough to represent
    // as a small set like SortedIntDocSet instead...
    // Storing in this array will be quicker to convert
    // than scanning through a potentially huge bit vector.
    // FUTURE: when search methods all start returning docs in order, maybe
    // we could have a ListDocSet() and use the collected array directly.
    if (pos < scratch.length) {
      scratch[pos]=doc;
    } else {
      // this conditional could be removed if BitSet was preallocated, but that
      // would take up more memory, and add more GC time...
      if (bits==null) bits = new OpenBitSet(maxDoc);
      bits.fastSet(doc);
    }
    pos++;
  }
 
  public DocSet getDocSet() {
    if (pos<=scratch.length) {
      // assumes docs were collected in sorted order!
      return new SortedIntDocSet(scratch, pos);
    } else {
      // set the bits for ids that were collected in the array
      for (int i=0; i

$this->init();
$this->createCopyTable();
$this->alterCopyTable();
$this->createDeltasTable();
$this->createTriggers();
$this->startSnapshotXact();
$this->selectTableIntoOutfile();
$this->dropNCIndexes();
$this->loadCopyTable();
$this->replayChanges(false); // false means not in single xact
$this->recreateNCIndexes();
$this->replayChanges(false); // false means not in single xact
$this->swapTables();
$this->cleanup();

db.runCommand(
 { mapreduce : <collection>,
   map : <mapfunction>,
   reduce : <reducefunction>
   [, query : <query filter object>]
   [, sort : <sort the query.  useful for optimization>]
   [, limit : <number of objects to return from collection>]
   [, out : <output-collection name>]
   [, keeptemp: <true|false>]
   [, finalize : <finalizefunction>]
   [, scope : <object where fields go into javascript global scope >]
   [, verbose : true]
 }
);

{ result : <collection_name>,
  counts : {
       input :  <number of objects scanned>,
       emit  : <number of times emit was called>,
       output : <number of items in output collection>
  } ,
  timeMillis : <job_time>,
  ok : <1_if_ok>,
  [, err : <errmsg_if_error>]
}

	db.collection.mapReduce(mapfunction,reducefunction[,options]);

	function map(void) -> void

	function reduce(key, value_array) -> value

map = function() { 
	emit(this.query, this.cnt);
};
reduce = function(key , vals) {
	var sum = 0;
	for(var i in vals) {
		sum += vals[i];
	}
	return sum;
};
res = db.log_info.mapReduce(map,reduce,{"query":{"year":2010}});

{
	"result" : "tmp.mr.mapreduce_1284794393_2",
	"timeMillis" : 72,
	"counts" : {
		"input" : 1000,
		"emit" : 1000,
		"output" : 113
	},
	"ok" : 1,
}

{ "_id" : "a", "value" : 521 }
{ "_id" : "aa", "value" : 128 }
{ "_id" : "aaa", "value" : 40 }
{ "_id" : "aaaa", "value" : 4 }
{ "_id" : "aaab", "value" : 9 }
{ "_id" : "aaac", "value" : 13 }
{ "_id" : "aab", "value" : 45 }
{ "_id" : "aaba", "value" : 5 }
{ "_id" : "aabb", "value" : 14 }
{ "_id" : "aabc", "value" : 20 }
{ "_id" : "aac", "value" : 39 }
{ "_id" : "aaca", "value" : 6 }
{ "_id" : "aacb", "value" : 2 }
{ "_id" : "aacc", "value" : 5 }
{ "_id" : "ab", "value" : 65 }
{ "_id" : "aba", "value" : 37 }
{ "_id" : "abaa", "value" : 12 }
{ "_id" : "abab", "value" : 13 }
{ "_id" : "abac", "value" : 10 }
{ "_id" : "abb", "value" : 42 }

public MapReduceOutput mapReduce( String map , String reduce , String outputCollection , DBObject query );
public MapReduceOutput mapReduce( DBObject command );

public class MapReduceOutput {
 
    MapReduceOutput( DBCollection from , BasicDBObject raw ){
        _collname = raw.getString( "result" );
        _coll = from._db.getCollection( _collname );
        _counts = (BasicDBObject)raw.get( "counts" );
    }
 
    public DBCursor results(){
        return _coll.find();
    }
 
    public void drop(){
        _coll.drop();
    }
 
    public DBCollection getOutputCollection(){
        return _coll;
    }
 
    final String _collname;
    final DBCollection _coll;
    final BasicDBObject _counts;
}

public class TubaQuerySenderListener implements SolrEventListener {
 
  private static final Logger logger = LoggerFactory
  .getLogger(TubaQuerySenderListener.class);
 
  protected final SolrCore core;
  protected List<NamedList> queryArgs;
 
  public void init(final NamedList args) {
    final String coreName = core.getName();
    queryArgs = (List<NamedList>)args.get(coreName);
    if (queryArgs == null) {
      queryArgs = (List<NamedList>)args.get("default");
      if (queryArgs == null) {
        logger.warn("TubaQuerySenderListener not valid for core:"+coreName);
      }
    }
    logger.info("core["+coreName+"]register TubaQuerySenderListener : " + queryArgs);
  }
 
  public TubaQuerySenderListener(final SolrCore core) {
    this.core = core;
  }
 
  /**
   * Add the {@link org.apache.solr.common.params.EventParams#EVENT} with either the {@link org.apache.solr.common.params.EventParams#NEW_SEARCHER}
   * or {@link org.apache.solr.common.params.EventParams#FIRST_SEARCHER} values depending on the value of currentSearcher.
   * <p/>
   * Makes a copy of NamedList and then adds the parameters.
   *
   *
   * @param currentSearcher If null, add FIRST_SEARCHER, otherwise NEW_SEARCHER
   * @param nlst The named list to add the EVENT value to
   */
  protected NamedList addEventParms(final SolrIndexSearcher currentSearcher, final NamedList nlst) {
    final NamedList result = new NamedList();
    result.addAll(nlst);
    if (currentSearcher != null) {
      result.add(EventParams.EVENT, EventParams.NEW_SEARCHER);
    } else {
      result.add(EventParams.EVENT, EventParams.FIRST_SEARCHER);
    }
    return result;
  }
 
  @Override
  public void newSearcher(final SolrIndexSearcher newSearcher, final SolrIndexSearcher currentSearcher) {
    if (queryArgs == null) {
      return;
    }
    final SolrIndexSearcher searcher = newSearcher;
    for (final NamedList nlst : queryArgs) {
      try {
        // bind the request to a particular searcher (the newSearcher)
        final NamedList params = addEventParms(currentSearcher, nlst);
        final LocalSolrQueryRequest req = new LocalSolrQueryRequest(core,params) {
          @Override public SolrIndexSearcher getSearcher() { return searcher; }
          @Override public void close() { }
        };
 
        final SolrQueryResponse rsp = new SolrQueryResponse();
        core.execute(core.getRequestHandler(req.getParams().get(CommonParams.QT)), req, rsp);
        // Retrieve the Document instances (not just the ids) to warm
        // the OS disk cache, and any Solr document cache.  Only the top
        // level values in the NamedList are checked for DocLists.
        final NamedList values = rsp.getValues();
        for (int i=0; i<values.size(); i++) {
          final Object o = values.getVal(i);
          if (o instanceof DocList) {
            final DocList docs = (DocList)o;
            for (final DocIterator iter = docs.iterator(); iter.hasNext();) {
              newSearcher.doc(iter.nextDoc());
            }
          }
        }
        req.close();
      } catch (final Exception e) {
        // do nothing... we want to continue with the other requests.
        // the failure should have already been logged.
        logger.warn("",e);
      }
    }
    logger.info("core["+core.getName()+"]TubaQuerySenderListener newSearcher done.");
  }
 
  @Override
  public void postCommit() {
    throw new UnsupportedOperationException();
  }
 
}

	<query>
		<listener event="firstSearcher"
			class="com.tintintech.tuba.search.TubaQuerySenderListener">
			<arr name="default">
				<lst>
					<str name="q">手机</str>
					<str name="start">0</str>
					<str name="rows">10</str>
				</lst>
			</arr>
			<arr name="core1">
				<lst>
					<str name="q">手机</str>
					<str name="start">0</str>
					<str name="rows">10</str>
					<str name="sort">at desc</str>
				</lst>
			</arr>
		</listener>
 
		<listener event="newSearcher"
			class="com.tintintech.tuba.search.TubaQuerySenderListener">
			<arr name="default">
				<lst>
					<str name="q">手机</str>
					<str name="start">0</str>
					<str name="rows">10</str>
				</lst>
			</arr>
			<arr name="core1">
				<lst>
					<str name="q">手机</str>
					<str name="start">0</str>
					<str name="rows">10</str>
					<str name="sort">at desc</str>
				</lst>
			</arr>
		</listener>
	</query>

    public byte[] getResponseBody() throws IOException {
        if (this.responseBody == null) {
            InputStream instream = getResponseBodyAsStream();
            if (instream != null) {
                long contentLength = getResponseContentLength();
                if (contentLength > Integer.MAX_VALUE) { //guard below cast from overflow
                    throw new IOException("Content too large to be buffered: "+ contentLength +" bytes");
                }
                int limit = getParams().getIntParameter(HttpMethodParams.BUFFER_WARN_TRIGGER_LIMIT, 1024*1024);
                if ((contentLength == -1) || (contentLength > limit)) {
                    LOG.warn("Going to buffer response body of large or unknown size. "
                            +"Using getResponseBodyAsStream instead is recommended.");
                }
                LOG.debug("Buffering response body");
                ByteArrayOutputStream outstream = new ByteArrayOutputStream(
                        contentLength > 0 ? (int) contentLength : DEFAULT_INITIAL_BUFFER_SIZE);
                byte[] buffer = new byte[4096];
                int len;
                while ((len = instream.read(buffer)) > 0) {
                    outstream.write(buffer, 0, len);
                }
                outstream.close();
                setResponseStream(null);
                this.responseBody = outstream.toByteArray();
            }
        }
        return this.responseBody;
    }

public interface MapWrapper {
 
  void put(Object key,Object value);
 
  Object get(Object key);
 
  void clear();
 
  String getName();
}
 
public class HashTableMapWrapper implements MapWrapper{
  private final Map<Object,Object> map;
 
 
  public HashTableMapWrapper() {
    map = new Hashtable<Object,Object>();
  }
 
  @Override
  public void clear() {
    map.clear();
  }
 
  @Override
  public Object get(final Object key) {
    return map.get(key);
  }
 
  @Override
  public void put(final Object key, final Object value) {
    map.put(key, value);
  }
 
  @Override
  public String getName() {
    return "hashtable";
  }
 
}
 
public class SyncMapWrapper  implements MapWrapper{
  private final Map<Object,Object> map;
 
 
  public SyncMapWrapper() {
    map = new HashMap<Object,Object>();
  }
 
  @Override
  public synchronized void clear() {
    map.clear();
  }
 
  @Override
  public synchronized Object  get(final Object key) {
    return map.get(key);
  }
 
  @Override
  public synchronized void put(final Object key, final Object value) {
    map.put(key, value);
  }
 
  @Override
  public String getName() {
    return "synclock";
  }
}
 
public class LockMapWrapper implements MapWrapper{
  private final Map<Object,Object> map;
 
  private final Lock lock;
 
 
  public LockMapWrapper() {
    map = new HashMap<Object,Object>();
    lock = new ReentrantLock();
  }
 
  @Override
  public void clear() {
    lock.lock();
    try {
      map.clear();
    } catch (final Exception e) {
    } finally {
      lock.unlock();
    }
 
  }
 
  @Override
  public Object get(final Object key) {
    lock.lock();
    try {
      return map.get(key);
    } catch (final Exception e) {
      // TODO: handle exception
    }finally {
      lock.unlock();
    }
    return null;
  }
 
  @Override
  public void put(final Object key, final Object value) {
    lock.lock();
    try {
      map.put(key, value);
    } catch (final Exception e) {
    } finally {
      lock.unlock();
    }
  }
 
  @Override
  public String getName() {
    return "mutexlock";
  }
}
 
public class RWLockMapWrapper implements MapWrapper{
 
  private final Map<Object,Object> map;
 
  private final Lock readLock;
 
  private final Lock writeLock;
 
  public RWLockMapWrapper() {
    map = new HashMap<Object,Object>();
    final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    readLock = lock.readLock();
    writeLock = lock.writeLock();
  }
 
  @Override
  public void clear() {
    writeLock.lock();
    try {
      map.clear();
    } catch (final Exception e) {
    } finally {
      writeLock.unlock();
    }
 
  }
 
  @Override
  public Object get(final Object key) {
    readLock.lock();
    try {
      return map.get(key);
    } catch (final Exception e) {
      // TODO: handle exception
    }finally {
      readLock.unlock();
    }
    return null;
  }
 
  @Override
  public void put(final Object key, final Object value) {
    writeLock.lock();
    try {
      map.put(key, value);
    } catch (final Exception e) {
    } finally {
      writeLock.unlock();
    }
  }
 
  @Override
  public String getName() {
    return "rwlock";
  }
}
 
public class ConcurrentMapWrapper  implements MapWrapper{
  private final Map<Object,Object> map;
 
  public ConcurrentMapWrapper() {
    map = new ConcurrentHashMap<Object,Object>();
  }
 
  @Override
  public void clear() {
    map.clear();
  }
 
  @Override
  public Object get(final Object key) {
    return map.get(key);
  }
 
  @Override
  public void put(final Object key, final Object value) {
    map.put(key, value);
  }
 
  @Override
  public String getName() {
    return "concrrent";
  }
 
}
 
public class WriteLockMapWrapper implements MapWrapper{
  private final Map<Object,Object> map;
 
  private final Lock lock;
 
 
  public WriteLockMapWrapper() {
    map = new HashMap<Object,Object>();
    lock = new ReentrantLock();
  }
 
  @Override
  public void clear() {
    lock.lock();
    try {
      map.clear();
    } catch (final Exception e) {
    } finally {
      lock.unlock();
    }
 
  }
 
  @Override
  public Object get(final Object key) {
    return map.get(key);
  }
 
  @Override
  public void put(final Object key, final Object value) {
    lock.lock();
    try {
      map.put(key, value);
    } catch (final Exception e) {
    } finally {
      lock.unlock();
    }
  }
 
  @Override
  public String getName() {
    return "writelock";
  }
}
 
 
public class BenchMark {
 
  public volatile long totalTime;
 
  private CountDownLatch latch;
 
  private final int loop;
 
  private final int threads;
 
  private final float ratio;
 
  public BenchMark(final int loop, final int threads,final float ratio) {
    super();
    this.loop = loop;
    this.threads = threads;
    this.ratio = ratio;
  }
 
  class BenchMarkRunnable implements Runnable{
 
    private final MapWrapper mapWrapper;
 
    private final int size;
 
    public void benchmarkRandomReadPut(final MapWrapper mapWrapper,final int loop) {
      final Random random = new Random();
      int writeTime = 0;
      for (int i=0;i<loop;i++) {
        final int n = random.nextInt(size);
        if (mapWrapper.get(n) == null) {
          mapWrapper.put(n, n);
          writeTime++;
        }
      }
    }
 
    public BenchMarkRunnable(final MapWrapper mapWrapper,final int size) {
      this.mapWrapper = mapWrapper;
      this.size = size;
    }
 
    @Override
    public void run() {
      final long start = System.currentTimeMillis();
      benchmarkRandomReadPut(mapWrapper,loop);
      final long end = System.currentTimeMillis();
      totalTime += end-start;
      latch.countDown();
    }
 
  }
 
  public void benchmark(final MapWrapper mapWrapper) {
    final float size = loop*threads*ratio;
    totalTime = 0;
    for (int k=0;k<3;k++) {
      latch = new CountDownLatch(threads);
      for (int i=0;i<threads;i++) {
        new Thread(new BenchMarkRunnable(mapWrapper,(int)size)).start();
      }
      try {
        latch.await();
      } catch (final Exception e) {
        e.printStackTrace();
      }
      mapWrapper.clear();
      Runtime.getRuntime().gc();
      Runtime.getRuntime().runFinalization();
      try {
        Thread.sleep(1000);
      } catch (final Exception e) {
      }
    }
    final int rwratio = (int)(1.0/ratio);
    System.out.println("["+mapWrapper.getName()+"]threadnum["+threads+"]ratio["+rwratio+"]avgtime["+totalTime/3+"]");
  }
 
  public static void benchmark2(final int loop, final int threads,final float ratio) {
    final BenchMark benchMark = new BenchMark(loop,threads,ratio);
    final MapWrapper[] wrappers = new MapWrapper[] {
        new HashTableMapWrapper(),
        new SyncMapWrapper(),
        new LockMapWrapper(),
        new RWLockMapWrapper(),
        new ConcurrentMapWrapper(),
        new WriteLockMapWrapper(),
    };
    for (final MapWrapper wrapper : wrappers) {
      benchMark.benchmark(wrapper);
    }
  }
 
  public static void test() {
    benchmark2(1000000,10,1);//r:w 1:1
    benchmark2(1000000,10,0.1f);//r:w 10:1
    benchmark2(1000000,10,0.01f);//r:w 100:1
    benchmark2(1000000,10,0.001f);//r:w 1000:1
    /////
    benchmark2(1000000,50,0.1f);//r:w 10:1
    benchmark2(1000000,50,0.01f);//r:w 100:1
    benchmark2(1000000,50,0.001f);//r:w 1000:1
    /////
    benchmark2(100000,100,1f);//r:w 10:1
    benchmark2(100000,100,0.1f);//r:w 10:1
    benchmark2(100000,100,0.01f);//r:w 100:1
    benchmark2(100000,100,0.001f);//r:w 1000:1
    ////
  }
 
  public static void main(final String[] args) {
    test();
  }
}

   public V get(Object key) {
        Entry<K,V> e = (Entry<K,V>)getEntry(key);
        if (e == null)
            return null;
        e.recordAccess(this);
        return e.value;
    }

   void addEntry(int hash, K key, V value, int bucketIndex) {
        createEntry(hash, key, value, bucketIndex);
        // Remove eldest entry if instructed, else grow capacity if appropriate
        Entry<K,V> eldest = header.after;
        if (removeEldestEntry(eldest)) {
            removeEntryForKey(eldest.key);
        } else {
            if (size >= threshold)
                resize(2 * table.length);
        }
    }

    public Object init(final Map args, Object persistence, final CacheRegenerator regenerator) {
	//一堆解析参数参数初始化的代码
	//map map    
    map = new LinkedHashMap(initialSize, 0.75f, true) {
      @Override
      protected boolean removeEldestEntry(final Map.Entry eldest) {
        if (size() > limit) {
          // increment evictions regardless of state.
          // this doesn't need to be synchronized because it will
          // only be called in the context of a higher level synchronized block.
          evictions++;
          stats.evictions.incrementAndGet();
          return true;
        }
        return false;
      }
    };
    if (persistence==null) {
      // must be the first time a cache of this type is being created
      persistence = new CumulativeStats();
    }
    stats = (CumulativeStats)persistence;
    return persistence;
  }
 
    public Object put(final Object key, final Object value) {
    synchronized (map) {
      if (state == State.LIVE) {
        stats.inserts.incrementAndGet();
      }
      // increment local inserts regardless of state???
      // it does make it more consistent with the current size...
      inserts++;
      return map.put(key,value);
    }
  }
 
  public Object get(final Object key) {
    synchronized (map) {
      final Object val = map.get(key);
      if (state == State.LIVE) {
        // only increment lookups and hits if we are live.
        lookups++;
        stats.lookups.incrementAndGet();
        if (val!=null) {
          hits++;
          stats.hits.incrementAndGet();
        }
      }
      return val;
    }
  }

  public V get(final K key) {
    final CacheEntry<K,V> e = map.get(key);
    if (e == null) {
      if (islive) {
        stats.missCounter.incrementAndGet();
      }
      return null;
    }
    if (islive) {
      e.lastAccessed = stats.accessCounter.incrementAndGet();
    }
    return e.value;
  }
 
  public V remove(final K key) {
    final CacheEntry<K,V> cacheEntry = map.remove(key);
    if (cacheEntry != null) {
      stats.size.decrementAndGet();
      return cacheEntry.value;
    }
    return null;
  }
 
  public Object put(final K key, final V val) {
    if (val == null) {
      return null;
    }
    final CacheEntry e = new CacheEntry(key, val, stats.accessCounter.incrementAndGet());
    final CacheEntry oldCacheEntry = map.put(key, e);
    int currentSize;
    if (oldCacheEntry == null) {
      currentSize = stats.size.incrementAndGet();
    } else {
      currentSize = stats.size.get();
    }
    if (islive) {
      stats.putCounter.incrementAndGet();
    } else {
      stats.nonLivePutCounter.incrementAndGet();
    }
 
    // Check if we need to clear out old entries from the cache.
    // isCleaning variable is checked instead of markAndSweepLock.isLocked()
    // for performance because every put invokation will check until
    // the size is back to an acceptable level.
    // There is a race between the check and the call to markAndSweep, but
    // it's unimportant because markAndSweep actually aquires the lock or returns if it can't.
    // Thread safety note: isCleaning read is piggybacked (comes after) other volatile reads
    // in this method.
    if (currentSize > upperWaterMark && !isCleaning) {
      if (newThreadForCleanup) {
        new Thread() {
          @Override
          public void run() {
            markAndSweep();
          }
        }.start();
      } else if (cleanupThread != null){
        cleanupThread.wakeThread();
      } else {
        markAndSweep();
      }
    }
    return oldCacheEntry == null ? null : oldCacheEntry.value;
  }

public class TestLock {
  private final HashMap map = new HashMap();
  public TestLock() {
    final Thread t1 = new Thread() {
      @Override
      public void run() {
        for(int i=0; i<500000; i++) {
          map.put(new Integer(i), i);
        }
        System.out.println("t1 over");
      }
    };
    final Thread t2 = new Thread() {
      @Override
      public void run() {
        for(int i=0; i<500000; i++) {
          map.put(new Integer(i), i);
        }
        System.out.println("t2 over");
      }
    };
    t1.start();
    t2.start();
  }
 
  public static void main(final String[] args) {
    new TestLock();
  }
}

public V put(final K key, final V value) {
    if (key == null) {
      return putForNullKey(value);
    }
    final int hash = hash(key.hashCode());
    final int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {//@标记1
      Object k;
      if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
        final V oldValue = e.value;
        e.value = value;
        e.recordAccess(this);
        return oldValue;
      }
    }
 
    modCount++;
    addEntry(hash, key, value, i);
    return null;
  }
 
void addEntry(final int hash, final K key, final V value, final int bucketIndex) {
    final Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    if (size++ >= threshold) {
      resize(2 * table.length);
    }
  }
 
void resize(final int newCapacity) {
    final Entry[] oldTable = table;
    final int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
      threshold = Integer.MAX_VALUE;
      return;
    }
 
    final Entry[] newTable = new Entry[newCapacity];
    transfer(newTable);
    table = newTable;
    threshold = (int)(newCapacity * loadFactor);
  }
 
void transfer(final Entry[] newTable) {
    final Entry[] src = table;
    final int newCapacity = newTable.length;
    final long time1 = System.currentTimeMillis();
    for (int j = 0; j < src.length; j++) {
      Entry<K,V> e = src[j];
      if (e != null) {
        src[j] = null;
        int k=0;//@标记2
        do {
          final Entry<K,V> next = e.next;
          final int i = indexFor(e.hash, newCapacity);
          e.next = newTable[i];
          newTable[i] = e;
          e = next;
          if (k++ > 1000) {//@标记3
            System.out.println(Thread.currentThread().getName()+
                ",e==next:"+(e==e.next)+",e==next.next:"+(e==e.next.next)+
                ",e:"+e+",next:"+e.next+",eq:"+e.equals(e.next));
            try {
              Thread.sleep(2000);
            } catch (final Exception e2) {
            }
 
          }
        } while (e != null);
      }
    }
  }

public interface SolrCache {
  /**
   * Solr在解析配置文件构造SolrConfig实例时会初始化配置中的各种CacheConfig，
   * 在构造SolrIndexSearcher时通过SolrConfig实例来newInstance SolrCache，
   * 这会调用init方法。参数args就是和具体实现（LRUCache和FastLRUCache）相关的
   * 参数Map，参数persistence是个全局的东西，LRUCache和FastLRUCache用其来统计
   * cache访问情况（因为cache是和SolrIndexSearcher绑定的，所以这种统计就需要个
   * 全局的注入参数），参数regenerator是autowarm时如何重新加载cache，
   * CacheRegenerator接口只有一个被SolrCache warm方法回调的方法：
   * boolean regenerateItem(SolrIndexSearcher newSearcher,
   * SolrCache newCache, SolrCache oldCache, Object oldKey, Object oldVal)
   */
  public Object init(Map args, Object persistence, CacheRegenerator regenerator);
  /** :TODO: copy from Map */
  public int size();
  /** :TODO: copy from Map */
  public Object put(Object key, Object value);
  /** :TODO: copy from Map */
  public Object get(Object key);
  /** :TODO: copy from Map */
  public void clear();
  /**
   * 新创建的SolrIndexSearcher autowarm方法，该方法的实现就是遍历已有cache中合适的
   * 范围（因为通常不会把旧cache中的所有项都重新加载一遍），对每一项调用regenerator的
   * regenerateItem方法来对searcher加载新cache项。
   */
  void warm(SolrIndexSearcher searcher, SolrCache old) throws IOException;
  /** Frees any non-memory resources */
  public void close();
}

    <!-- Internal cache used by SolrIndexSearcher for filters (DocSets),
         unordered sets of *all* documents that match a query.
         When a new searcher is opened, its caches may be prepopulated
         or "autowarmed" using data from caches in the old searcher.
         autowarmCount is the number of items to prepopulate.  For LRUCache,
         the prepopulated items will be the most recently accessed items.
      -->
    <filterCache
      class="solr.LRUCache"
      size="16384"
      initialSize="4096"
      autowarmCount="4096"/>

	    <!-- queryResultCache caches results of searches - ordered lists of
         document ids (DocList) based on a query, a sort, and the range
         of documents requested.
      -->
    <queryResultCache
      class="solr.LRUCache"
      size="16384"
      initialSize="4096"
      autowarmCount="1024"/>

public QueryResultKey(Query query, List<Query> filters, Sort sort, int nc_flags) {
    this.query = query;
    this.sort = sort;
    this.filters = filters;
    this.nc_flags = nc_flags;
    int h = query.hashCode();
    if (filters != null) h ^= filters.hashCode();
    sfields = (this.sort !=null) ? this.sort.getSort() : defaultSort;
    for (SortField sf : sfields) {
      // mix the bits so that sortFields are position dependent
      // so that a,b won't hash to the same value as b,a
      h ^= (h << 8) | (h >>> 25);   // reversible hash
      if (sf.getField() != null) h += sf.getField().hashCode();
      h += sf.getType();
      if (sf.getReverse()) h=~h;
      if (sf.getLocale()!=null) h+=sf.getLocale().hashCode();
      if (sf.getFactory()!=null) h+=sf.getFactory().hashCode();
    }
    hc = h;
  }

      <!-- An optimization for use with the queryResultCache.  When a search
         is requested, a superset of the requested number of document ids
         are collected.  For example, of a search for a particular query
         requests matching documents 10 through 19, and queryWindowSize is 50,
         then documents 0 through 50 will be collected and cached.  Any further
         requests in that range can be satisfied via the cache.
    -->
    <queryResultWindowSize>50</queryResultWindowSize>

	<!-- documentCache caches Lucene Document objects (the stored fields for each document).
      -->
    <documentCache
      class="solr.LRUCache"
      size="16384"
      initialSize="16384"/>

    <!-- Example of a generic cache.  These caches may be accessed by name
         through SolrIndexSearcher.getCache(),cacheLookup(), and cacheInsert().
         The purpose is to enable easy caching of user/application level data.
         The regenerator argument should be specified as an implementation
         of solr.search.CacheRegenerator if autowarming is desired.
    -->
    <!--
    <cache name="yourCacheNameHere"
      class="solr.LRUCache"
      size="4096"
      initialSize="2048"
      autowarmCount="4096"
      regenerator="org.foo.bar.YourRegenerator"/>
    -->

	      solrConfig.filterCacheConfig.setRegenerator(
              new CacheRegenerator() {
                public boolean regenerateItem(SolrIndexSearcher newSearcher, SolrCache newCache, SolrCache oldCache, Object oldKey, Object oldVal) throws IOException {
                  newSearcher.cacheDocSet((Query)oldKey, null, false);
                  return true;
                }
              }
      );

          <listener event="newSearcher" class="solr.QuerySenderListener">
      <arr name="queries">
        <!-- seed common sort fields -->
        <lst> <str name="q">anything</str> <str name="sort">name desc price desc populartiy desc</str> </lst>
      </arr>
    </listener>
    <listener event="firstSearcher" class="solr.QuerySenderListener">
      <arr name="queries">
        <!-- seed common sort fields -->
        <lst> <str name="q">anything</str> <str name="sort">name desc, price desc, populartiy desc</str> </lst>
        <!-- seed common facets and filter queries -->
        <lst> <str name="q">anything</str> 
              <str name="facet.field">category</str> 
              <str name="fq">inStock:true</str>
              <str name="fq">price:[0 TO 100]</str>
        </lst>
      </arr>
    </listener>