Directory dire = NIOFSDirectory.open(FileSystems.getDefault().getPath(indexDirectory));
IndexWriterConfig iwc = new IndexWriterConfig(new StandardAnalyzer());
iwc.setRAMBufferSizeMB(64); //兆默认刷
indexWriter = new IndexWriter(dire, iwc);
 
Document doc = createDocument(artiste, skuId);
indexWriter.addDocument(doc);
 
indexWriter.commit();
indexWriter.close();

IndexWriterConfig
 
//properties
this.analyzer = analyzer;
ramBufferSizeMB = IndexWriterConfig.DEFAULT_RAM_BUFFER_SIZE_MB;//默认超过16M就会触发flush磁盘操作
maxBufferedDocs = IndexWriterConfig.DEFAULT_MAX_BUFFERED_DOCS;//默认按照RAM空间大小触发flush
maxBufferedDeleteTerms = IndexWriterConfig.DEFAULT_MAX_BUFFERED_DELETE_TERMS;//
mergedSegmentWarmer = null;
delPolicy = new KeepOnlyLastCommitDeletionPolicy();//删除策略
commit = null;
useCompoundFile = IndexWriterConfig.DEFAULT_USE_COMPOUND_FILE_SYSTEM;
openMode = OpenMode.CREATE_OR_APPEND;//IndexWriter打开模式
similarity = IndexSearcher.getDefaultSimilarity();//相似度计算，一般初始化Searcher的时候会用（因为只有查询的时候才会用到相似度计算）
mergeScheduler = new ConcurrentMergeScheduler();//每个segement的merge交个一个线程完成
writeLockTimeout = IndexWriterConfig.WRITE_LOCK_TIMEOUT;//写操作遇到锁超时时间
indexingChain = DocumentsWriterPerThread.defaultIndexingChain;
codec = Codec.getDefault();
if (codec == null) {
  throw new NullPointerException();
}
infoStream = InfoStream.getDefault();
mergePolicy = new TieredMergePolicy();//合并策略
flushPolicy = new FlushByRamOrCountsPolicy();//flush策略
readerPooling = IndexWriterConfig.DEFAULT_READER_POOLING;
indexerThreadPool = new DocumentsWriterPerThreadPool(IndexWriterConfig.DEFAULT_MAX_THREAD_STATES);//并发写索引线程池
perThreadHardLimitMB = IndexWriterConfig.DEFAULT_RAM_PER_THREAD_HARD_LIMIT_MB;

/*{@link ThreadState} references and guards a
* {@link DocumentsWriterPerThread} instance that is used during indexing to build a in-memory index segment.
*/
final static class ThreadState extends ReentrantLock {
  DocumentsWriterPerThread dwpt;
  // TODO this should really be part of DocumentsWriterFlushControl
  // write access guarded by DocumentsWriterFlushControl
  volatile boolean flushPending = false;
  // TODO this should really be part of DocumentsWriterFlushControl
  // write access guarded by DocumentsWriterFlushControl
  long bytesUsed = 0;
  // guarded by Reentrant lock
  private boolean isActive = true;
 
  ThreadState(DocumentsWriterPerThread dpwt) {
    this.dwpt = dpwt;
  }

DocumentsWriterPerThreadPool(int maxNumThreadStates) {//默认maxNumThreadStates=8
  if (maxNumThreadStates < 1) {
    throw new IllegalArgumentException("maxNumThreadStates must be >= 1 but was: " + maxNumThreadStates);
  }
  threadStates = new ThreadState[maxNumThreadStates];
  numThreadStatesActive = 0;
  for (int i = 0; i < threadStates.length; i++) {
    threadStates[i] = new ThreadState(null);
  }
  freeList = new ThreadState[maxNumThreadStates];
}

docWriter.updateDocument(doc, analyzer, term)
 
boolean updateDocument(final Iterable<? extends IndexableField> doc, final Analyzer analyzer,
    final Term delTerm) throws IOException, AbortingException {
 
  boolean hasEvents = preUpdate();
 
  final ThreadState perThread = flushControl.obtainAndLock();
 
  final DocumentsWriterPerThread flushingDWPT;
  try {
    if (!perThread.isActive()) {
      ensureOpen();
      assert false: "perThread is not active but we are still open";
    }
    ensureInitialized(perThread);//真正初始化单个具体线程DocumentsWriterPerThread
    assert perThread.isInitialized();
    final DocumentsWriterPerThread dwpt = perThread.dwpt;
    final int dwptNumDocs = dwpt.getNumDocsInRAM();
    try {
      dwpt.updateDocument(doc, analyzer, delTerm); //DocumentsWriterPerThread线程真正更新文档
    } catch (AbortingException ae) {
      flushControl.doOnAbort(perThread);
      dwpt.abort();
      throw ae;
    } finally {
      // We don‘t know whether the document actually
      // counted as being indexed, so we must subtract here to
      // accumulate our separate counter:
      numDocsInRAM.addAndGet(dwpt.getNumDocsInRAM() - dwptNumDocs);
    }
    final boolean isUpdate = delTerm != null;
    flushingDWPT = flushControl.doAfterDocument(perThread, isUpdate);
  } finally {
    perThreadPool.release(perThread);//将该线程重新放回到线程池中，释放掉资源
  }
 
  return postUpdate(flushingDWPT, hasEvents);
} 

public void updateDocument(Iterable<? extends IndexableField> doc, Analyzer analyzer, Term delTerm) throws IOException, AbortingException {
  testPoint("DocumentsWriterPerThread addDocument start");
  assert deleteQueue != null;
  reserveOneDoc();
  docState.doc = doc;
  docState.analyzer = analyzer;
  docState.docID = numDocsInRAM;
  if (INFO_VERBOSE && infoStream.isEnabled("DWPT")) {
    infoStream.message("DWPT", Thread.currentThread().getName() + " update delTerm=" + delTerm + " docID=" + docState.docID + " seg=" + segmentInfo.name);
  }
  // Even on exception, the document is still added (but marked
  // deleted), so we don‘t need to un-reserve at that point.
  // Aborting exceptions will actually "lose" more than one
  // document, so the counter will be "wrong" in that case, but
  // it‘s very hard to fix (we can‘t easily distinguish aborting
  // vs non-aborting exceptions):
  boolean success = false;
  try {
    try {
      consumer.processDocument();
    } finally {
      docState.clear();
    }
    success = true;
  } finally {
    if (!success) {
      // mark document as deleted
      deleteDocID(docState.docID);
      numDocsInRAM++;
    }
  }
  finishDocument(delTerm);
}

@Override
public void processDocument() throws IOException, AbortingException {
 
  // How many indexed field names we‘ve seen (collapses
  // multiple field instances by the same name):
  int fieldCount = 0;
 
  long fieldGen = nextFieldGen++;
 
  // NOTE: we need two passes here, in case there are
  // multi-valued fields, because we must process all
  // instances of a given field at once, since the
  // analyzer is free to reuse TokenStream across fields
  // (i.e., we cannot have more than one TokenStream
  // running "at once"):
 
  termsHash.startDocument();
 
  fillStoredFields(docState.docID);
  startStoredFields();
 
  boolean aborting = false;
  try {
    for (IndexableField field : docState.doc) {//挨个遍历每个Field做处理，哈哈，终于露出可爱的尾巴了
      fieldCount = processField(field, fieldGen, fieldCount);
    }
  } catch (AbortingException ae) {
    aborting = true;
    throw ae;
  } finally {
    if (aborting == false) {
      // Finish each indexed field name seen in the document:
      for (int i=0;i<fieldCount;i++) {
        fields[i].finish();
      }
      finishStoredFields();
    }
  }
 
  try {
    termsHash.finishDocument();
  } catch (Throwable th) {
    // Must abort, on the possibility that on-disk term
    // vectors are now corrupt:
    throw AbortingException.wrap(th);
  }
}

private final void commitInternal(MergePolicy mergePolicy) throws IOException {
 
  if (infoStream.isEnabled("IW")) {
    infoStream.message("IW", "commit: start");
  }
 
  synchronized(commitLock) {
    ensureOpen(false);
 
    if (infoStream.isEnabled("IW")) {
      infoStream.message("IW", "commit: enter lock");
    }
 
    if (pendingCommit == null) {
      if (infoStream.isEnabled("IW")) {
        infoStream.message("IW", "commit: now prepare");
      }
      prepareCommitInternal(mergePolicy);//最关键的一行
    } else {
      if (infoStream.isEnabled("IW")) {
        infoStream.message("IW", "commit: already prepared");
      }
    }
 
    finishCommit();
  }
}