diff --git a/CMakeLists.txt b/CMakeLists.txt
index 838b25a..f61fbc1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,6 +2,12 @@
 # init
 ####################################
 
+#set (CMAKE_CXX_FLAGS "-g -fsanitize=thread -fno-omit-frame-pointer -O0")
+set (CMAKE_CXX_FLAGS "-g -fsanitize=thread -O0")
+
+set (Boost_INCLUDE_DIRS "/home/kjetil/site/include")
+set (Boost_LIBRARY_DIRS, "/home/kjetil/site/lib")
+
 cmake_minimum_required(VERSION 3.5)
 
 project(lucene++)
@@ -17,13 +23,15 @@ set(lucene++_VERSION
 
 # set default build type as release
 if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
+  #set(CMAKE_BUILD_TYPE "Release")
+  set(CMAKE_BUILD_TYPE "Debug")
 endif()
 
 set(LIB_DESTINATION
   "${CMAKE_INSTALL_LIBDIR}" CACHE STRING "Define lib output directory name")
 
 
+
 ####################################
 # CMake Modules
 ####################################
@@ -111,6 +119,9 @@ if(ENABLE_PACKAGING)
   include(CreateLucene++Packages)
 endif()
 
+set (CMAKE_CXX_FLAGS "-O0")
+
+
 
 ####################################
 # bootstrap
@@ -132,3 +143,7 @@ message("  Boost Include:    ${Boost_INCLUDE_DIRS}")
 message("  Boost Libraries:  ${Boost_LIBRARY_DIRS}")
 message("  Zlib Include:     ${ZLIB_INCLUDE_DIRS}")
 message("  Zlib Library:     ${ZLIB_LIBRARY_RELEASE}")
+
+#set (CMAKE_CXX_FLAGS "-g -fsanitize=thread -fno-omit-frame-pointer")
+
+set(CMAKE_CPP_COMPILER clang++)
diff --git a/include/lucene++/KeywordTokenizer.h b/include/lucene++/KeywordTokenizer.h
index e93bbc4..294a88a 100644
--- a/include/lucene++/KeywordTokenizer.h
+++ b/include/lucene++/KeywordTokenizer.h
@@ -37,7 +37,10 @@ protected:
 public:
     virtual bool incrementToken();
     virtual void end();
-    virtual void reset();
+    virtual void reset(void);
+
+private:
+    using Tokenizer::reset;
 };
 
 }
diff --git a/include/lucene++/Synchronize.h b/include/lucene++/Synchronize.h
index d8ba742..6d546a6 100644
--- a/include/lucene++/Synchronize.h
+++ b/include/lucene++/Synchronize.h
@@ -7,7 +7,9 @@
 #ifndef SYNCHRONIZE_H
 #define SYNCHRONIZE_H
 
+#include <atomic>
 #include <boost/thread/recursive_mutex.hpp>
+#include <boost/thread/mutex.hpp>
 #include "Lucene.h"
 
 namespace Lucene {
@@ -60,6 +62,21 @@ protected:
     void lock(int32_t timeout);
 };
 
+
+#define LUCENE_RUN_ONCE(Command)					\
+    do {								\
+        static std::atomic<bool> RUN_ONCE_hasRun = {};		        \
+	if (!RUN_ONCE_hasRun) {					        \
+            static boost::mutex RUN_ONCE_mutex;			        \
+            boost::mutex::scoped_lock RUN_ONCE_lock(RUN_ONCE_mutex);	\
+            if (!RUN_ONCE_hasRun) {					\
+                Command;						\
+                RUN_ONCE_hasRun = true;					\
+            }								\
+        }								\
+    } while(0)
+
+
 }
 
 #endif
diff --git a/options.cmake b/options.cmake
index 205cb36..a2d1350 100644
--- a/options.cmake
+++ b/options.cmake
@@ -47,7 +47,7 @@ option(
 OPTION(
     ENABLE_DOCS
     "Build the Lucene++ documentation."
-    OFF)
+    ON)
 
 
 # documentation options
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index fffb53e..83a7263 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -10,4 +10,6 @@ endif()
 if(ENABLE_TEST)
   enable_testing()
   add_subdirectory(test)
-endif()
\ No newline at end of file
+endif()
+
+#set (CMAKE_CXX_FLAGS "-g -fsanitize=thread -fno-omit-frame-pointer")
diff --git a/src/contrib/analyzers/common/analysis/ar/ArabicAnalyzer.cpp b/src/contrib/analyzers/common/analysis/ar/ArabicAnalyzer.cpp
index be452bb..83bb7aa 100644
--- a/src/contrib/analyzers/common/analysis/ar/ArabicAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/ar/ArabicAnalyzer.cpp
@@ -89,11 +89,11 @@ ArabicAnalyzer::~ArabicAnalyzer() {
 
 const HashSet<String> ArabicAnalyzer::getDefaultStopSet() {
     static HashSet<String> stopSet;
-    if (!stopSet) {
+    LUCENE_RUN_ONCE(
         String stopWords(UTF8_TO_STRING(DEFAULT_STOPWORD_FILE));
         Collection<String> words(StringUtils::split(stopWords, L"\n"));
         stopSet = HashSet<String>::newInstance(words.begin(), words.end());
-    }
+    );
     return stopSet;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/ar/ArabicStemmer.cpp b/src/contrib/analyzers/common/analysis/ar/ArabicStemmer.cpp
index 20a4596..cb88eec 100644
--- a/src/contrib/analyzers/common/analysis/ar/ArabicStemmer.cpp
+++ b/src/contrib/analyzers/common/analysis/ar/ArabicStemmer.cpp
@@ -27,7 +27,7 @@ ArabicStemmer::~ArabicStemmer() {
 
 const Collection<String> ArabicStemmer::prefixes() {
     static Collection<String> _prefixes;
-    if (!_prefixes) {
+    LUCENE_RUN_ONCE(
         _prefixes = Collection<String>::newInstance();
         _prefixes.add(String(L"") + ALEF + LAM);
         _prefixes.add(String(L"") + WAW + ALEF + LAM);
@@ -36,13 +36,13 @@ const Collection<String> ArabicStemmer::prefixes() {
         _prefixes.add(String(L"") + FEH + ALEF + LAM);
         _prefixes.add(String(L"") + LAM + LAM);
         _prefixes.add(String(L"") + WAW);
-    }
+    );
     return _prefixes;
 }
 
 const Collection<String> ArabicStemmer::suffixes() {
     static Collection<String> _suffixes;
-    if (!_suffixes) {
+    LUCENE_RUN_ONCE(
         _suffixes = Collection<String>::newInstance();
         _suffixes.add(String(L"") + HEH + ALEF);
         _suffixes.add(String(L"") + ALEF + NOON);
@@ -54,7 +54,7 @@ const Collection<String> ArabicStemmer::suffixes() {
         _suffixes.add(String(L"") + HEH);
         _suffixes.add(String(L"") + TEH_MARBUTA);
         _suffixes.add(String(L"") + YEH);
-    }
+    );
     return _suffixes;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/br/BrazilianAnalyzer.cpp b/src/contrib/analyzers/common/analysis/br/BrazilianAnalyzer.cpp
index a5abeda..5eeb846 100644
--- a/src/contrib/analyzers/common/analysis/br/BrazilianAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/br/BrazilianAnalyzer.cpp
@@ -59,9 +59,9 @@ BrazilianAnalyzer::~BrazilianAnalyzer() {
 
 const HashSet<String> BrazilianAnalyzer::getDefaultStopSet() {
     static HashSet<String> stopSet;
-    if (!stopSet) {
+    LUCENE_RUN_ONCE(
         stopSet = HashSet<String>::newInstance(_BRAZILIAN_STOP_WORDS, _BRAZILIAN_STOP_WORDS + SIZEOF_ARRAY(_BRAZILIAN_STOP_WORDS));
-    }
+    );
     return stopSet;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/cjk/CJKAnalyzer.cpp b/src/contrib/analyzers/common/analysis/cjk/CJKAnalyzer.cpp
index 7a62f30..bd34076 100644
--- a/src/contrib/analyzers/common/analysis/cjk/CJKAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/cjk/CJKAnalyzer.cpp
@@ -36,9 +36,9 @@ CJKAnalyzer::~CJKAnalyzer() {
 
 const HashSet<String> CJKAnalyzer::getDefaultStopSet() {
     static HashSet<String> stopSet;
-    if (!stopSet) {
+    LUCENE_RUN_ONCE(
         stopSet = HashSet<String>::newInstance(_STOP_WORDS, _STOP_WORDS + SIZEOF_ARRAY(_STOP_WORDS));
-    }
+    );
     return stopSet;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/cz/CzechAnalyzer.cpp b/src/contrib/analyzers/common/analysis/cz/CzechAnalyzer.cpp
index 6136aa6..bc47293 100644
--- a/src/contrib/analyzers/common/analysis/cz/CzechAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/cz/CzechAnalyzer.cpp
@@ -86,11 +86,11 @@ CzechAnalyzer::~CzechAnalyzer() {
 
 const HashSet<String> CzechAnalyzer::getDefaultStopSet() {
     static HashSet<String> stopSet;
-    if (!stopSet) {
+    LUCENE_RUN_ONCE(
         String stopWords(UTF8_TO_STRING(_CZECH_STOP_WORDS));
         Collection<String> words(StringUtils::split(stopWords, L"\n"));
         stopSet = HashSet<String>::newInstance(words.begin(), words.end());
-    }
+    );
     return stopSet;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/de/GermanAnalyzer.cpp b/src/contrib/analyzers/common/analysis/de/GermanAnalyzer.cpp
index 5431344..8bcc337 100644
--- a/src/contrib/analyzers/common/analysis/de/GermanAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/de/GermanAnalyzer.cpp
@@ -45,9 +45,9 @@ GermanAnalyzer::~GermanAnalyzer() {
 
 const HashSet<String> GermanAnalyzer::getDefaultStopSet() {
     static HashSet<String> stopSet;
-    if (!stopSet) {
+    LUCENE_RUN_ONCE(
         stopSet = HashSet<String>::newInstance(_GERMAN_STOP_WORDS, _GERMAN_STOP_WORDS + SIZEOF_ARRAY(_GERMAN_STOP_WORDS));
-    }
+    );
     return stopSet;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/el/GreekAnalyzer.cpp b/src/contrib/analyzers/common/analysis/el/GreekAnalyzer.cpp
index 732491d..f85a47b 100644
--- a/src/contrib/analyzers/common/analysis/el/GreekAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/el/GreekAnalyzer.cpp
@@ -73,11 +73,11 @@ GreekAnalyzer::~GreekAnalyzer() {
 
 const HashSet<String> GreekAnalyzer::getDefaultStopSet() {
     static HashSet<String> stopSet;
-    if (!stopSet) {
+    LUCENE_RUN_ONCE(
         String stopWords(UTF8_TO_STRING(_GREEK_STOP_WORDS));
         Collection<String> words(StringUtils::split(stopWords, L"\n"));
         stopSet = HashSet<String>::newInstance(words.begin(), words.end());
-    }
+    );
     return stopSet;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/fa/PersianAnalyzer.cpp b/src/contrib/analyzers/common/analysis/fa/PersianAnalyzer.cpp
index 97b02aa..0bcd855 100644
--- a/src/contrib/analyzers/common/analysis/fa/PersianAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/fa/PersianAnalyzer.cpp
@@ -205,11 +205,11 @@ PersianAnalyzer::~PersianAnalyzer() {
 
 const HashSet<String> PersianAnalyzer::getDefaultStopSet() {
     static HashSet<String> stopSet;
-    if (!stopSet) {
+    LUCENE_RUN_ONCE(
         String stopWords(UTF8_TO_STRING(DEFAULT_STOPWORD_FILE));
         Collection<String> words(StringUtils::split(stopWords, L"\n"));
         stopSet = HashSet<String>::newInstance(words.begin(), words.end());
-    }
+    );
     return stopSet;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/fr/FrenchAnalyzer.cpp b/src/contrib/analyzers/common/analysis/fr/FrenchAnalyzer.cpp
index b14d09d..0ccdbb4 100644
--- a/src/contrib/analyzers/common/analysis/fr/FrenchAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/fr/FrenchAnalyzer.cpp
@@ -61,9 +61,9 @@ FrenchAnalyzer::~FrenchAnalyzer() {
 
 const HashSet<String> FrenchAnalyzer::getDefaultStopSet() {
     static HashSet<String> stoptable;
-    if (!stoptable) {
+    LUCENE_RUN_ONCE(
         stoptable = HashSet<String>::newInstance(_FRENCH_STOP_WORDS, _FRENCH_STOP_WORDS + SIZEOF_ARRAY(_FRENCH_STOP_WORDS));
-    }
+    );
     return stoptable;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/fr/FrenchStemmer.cpp b/src/contrib/analyzers/common/analysis/fr/FrenchStemmer.cpp
index 567569e..44a7d40 100644
--- a/src/contrib/analyzers/common/analysis/fr/FrenchStemmer.cpp
+++ b/src/contrib/analyzers/common/analysis/fr/FrenchStemmer.cpp
@@ -124,40 +124,42 @@ void FrenchStemmer::step1() {
 
 bool FrenchStemmer::step2a() {
     static Collection<String> search;
-    if (!search) {
-        static const wchar_t* _search[] = {
+    static const wchar_t* _search[] = {
             L"\x00eemes", L"\x00eetes", L"iraIent", L"irait", L"irais", L"irai", L"iras", L"ira",
             L"irent", L"iriez", L"irez", L"irions", L"irons", L"iront", L"issaIent",
             L"issais", L"issantes", L"issante", L"issants", L"issant", L"issait",
             L"issais", L"issions", L"issons", L"issiez", L"issez", L"issent", L"isses",
             L"isse", L"ir", L"is", L"\x00eet", L"it", L"ies", L"ie", L"i"
-        };
+    };
+
+    LUCENE_RUN_ONCE(
         search = Collection<String>::newInstance(_search, _search + SIZEOF_ARRAY(_search));
-    }
+    );
+    
     return deleteFromIfTestVowelBeforeIn(RV, search, false, RV);
 }
 
 void FrenchStemmer::step2b() {
     static Collection<String> suffix;
-    if (!suffix) {
-        static const wchar_t* _suffix[] = {
+    static const wchar_t* _suffix[] = {
             L"eraIent", L"erais", L"erait", L"erai", L"eras", L"erions", L"eriez",
             L"erons", L"eront", L"erez", L"\x00e8rent", L"era", L"\x00e9es", L"iez", L"\x00e9e", L"\x00e9s",
             L"er", L"ez", L"\x00e9"
-        };
+    };
+    LUCENE_RUN_ONCE(
         suffix = Collection<String>::newInstance(_suffix, _suffix + SIZEOF_ARRAY(_suffix));
-    }
+    );
     deleteFrom(RV, suffix);
 
     static Collection<String> search;
-    if (!search) {
-        static const wchar_t* _search[] = {
+    static const wchar_t* _search[] = {
             L"assions", L"assiez", L"assent", L"asses", L"asse", L"aIent", L"antes",
             L"aIent", L"Aient", L"ante", L"\x00e2mes", L"\x00e2tes", L"ants", L"ant", L"ait",
             L"a\x00eet", L"ais", L"Ait", L"A\x00eet", L"Ais", L"\x00e2t", L"as", L"ai", L"Ai", L"a"
-        };
-        search = Collection<String>::newInstance(_search, _search + SIZEOF_ARRAY(_search));
-    }
+    };
+    LUCENE_RUN_ONCE(
+	    search = Collection<String>::newInstance(_search, _search + SIZEOF_ARRAY(_search));
+    );
     deleteButSuffixFrom(RV, search, L"e", true);
 
     deleteFrom(R2, newCollection<String>(L"ions"));
diff --git a/src/contrib/analyzers/common/analysis/nl/DutchAnalyzer.cpp b/src/contrib/analyzers/common/analysis/nl/DutchAnalyzer.cpp
index ce1593c..a4fa595 100644
--- a/src/contrib/analyzers/common/analysis/nl/DutchAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/nl/DutchAnalyzer.cpp
@@ -57,9 +57,9 @@ void DutchAnalyzer::initialize() {
 
 const HashSet<String> DutchAnalyzer::getDefaultStopSet() {
     static HashSet<String> stoptable;
-    if (!stoptable) {
+    LUCENE_RUN_ONCE(
         stoptable = HashSet<String>::newInstance(_DUTCH_STOP_WORDS, _DUTCH_STOP_WORDS + SIZEOF_ARRAY(_DUTCH_STOP_WORDS));
-    }
+    );
     return stoptable;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/ru/RussianAnalyzer.cpp b/src/contrib/analyzers/common/analysis/ru/RussianAnalyzer.cpp
index 18907a4..3d6818f 100644
--- a/src/contrib/analyzers/common/analysis/ru/RussianAnalyzer.cpp
+++ b/src/contrib/analyzers/common/analysis/ru/RussianAnalyzer.cpp
@@ -77,11 +77,11 @@ RussianAnalyzer::~RussianAnalyzer() {
 
 const HashSet<String> RussianAnalyzer::getDefaultStopSet() {
     static HashSet<String> stopSet;
-    if (!stopSet) {
+    LUCENE_RUN_ONCE(
         String stopWords(UTF8_TO_STRING(DEFAULT_STOPWORD_FILE));
         Collection<String> words(StringUtils::split(stopWords, L"\n"));
         stopSet = HashSet<String>::newInstance(words.begin(), words.end());
-    }
+    );
     return stopSet;
 }
 
diff --git a/src/contrib/analyzers/common/analysis/ru/RussianStemmer.cpp b/src/contrib/analyzers/common/analysis/ru/RussianStemmer.cpp
index 0855081..5ae7bca 100644
--- a/src/contrib/analyzers/common/analysis/ru/RussianStemmer.cpp
+++ b/src/contrib/analyzers/common/analysis/ru/RussianStemmer.cpp
@@ -46,28 +46,28 @@ RussianStemmer::~RussianStemmer() {
 
 Collection<String> RussianStemmer::perfectiveGerundEndings1() {
     static Collection<String> _perfectiveGerundEndings1;
-    if (!_perfectiveGerundEndings1) {
+    LUCENE_RUN_ONCE(
         _perfectiveGerundEndings1 = Collection<String>::newInstance();
         _perfectiveGerundEndings1.add(String(L"") + V);
         _perfectiveGerundEndings1.add(String(L"") + V + SH + I);
         _perfectiveGerundEndings1.add(String(L"") + V + SH + I + S + SOFT);
-    }
+    );
     return _perfectiveGerundEndings1;
 }
 
 Collection<String> RussianStemmer::perfectiveGerund1Predessors() {
     static Collection<String> _perfectiveGerund1Predessors;
-    if (!_perfectiveGerund1Predessors) {
+    LUCENE_RUN_ONCE(
         _perfectiveGerund1Predessors = Collection<String>::newInstance();
         _perfectiveGerund1Predessors.add(String(L"") + A);
         _perfectiveGerund1Predessors.add(String(L"") + IA);
-    }
+    );
     return _perfectiveGerund1Predessors;
 }
 
 Collection<String> RussianStemmer::perfectiveGerundEndings2() {
     static Collection<String> _perfectiveGerundEndings2;
-    if (!_perfectiveGerundEndings2) {
+    LUCENE_RUN_ONCE(
         _perfectiveGerundEndings2 = Collection<String>::newInstance();
         _perfectiveGerundEndings2.add(String(L"") + I + V);
         _perfectiveGerundEndings2.add(String(L"") + Y + V);
@@ -75,13 +75,13 @@ Collection<String> RussianStemmer::perfectiveGerundEndings2() {
         _perfectiveGerundEndings2.add(String(L"") + Y + V + SH + I);
         _perfectiveGerundEndings2.add(String(L"") + I + V + SH + I + S + SOFT);
         _perfectiveGerundEndings2.add(String(L"") + Y + V + SH + I + S + SOFT);
-    }
+    );
     return _perfectiveGerundEndings2;
 }
 
 Collection<String> RussianStemmer::adjectiveEndings() {
     static Collection<String> _adjectiveEndings;
-    if (!_adjectiveEndings) {
+    LUCENE_RUN_ONCE(
         _adjectiveEndings = Collection<String>::newInstance();
         _adjectiveEndings.add(String(L"") + E + E);
         _adjectiveEndings.add(String(L"") + I + E);
@@ -109,57 +109,57 @@ Collection<String> RussianStemmer::adjectiveEndings() {
         _adjectiveEndings.add(String(L"") + O + G + O);
         _adjectiveEndings.add(String(L"") + E + M + U);
         _adjectiveEndings.add(String(L"") + O + M + U);
-    }
+    );
     return _adjectiveEndings;
 }
 
 Collection<String> RussianStemmer::participleEndings1() {
     static Collection<String> _participleEndings1;
-    if (!_participleEndings1) {
+    LUCENE_RUN_ONCE(
         _participleEndings1 = Collection<String>::newInstance();
         _participleEndings1.add(String(L"") + SHCH);
         _participleEndings1.add(String(L"") + E + M);
         _participleEndings1.add(String(L"") + N + N);
         _participleEndings1.add(String(L"") + V + SH);
         _participleEndings1.add(String(L"") + IU + SHCH);
-    }
+    );
     return _participleEndings1;
 }
 
 Collection<String> RussianStemmer::participleEndings2() {
     static Collection<String> _participleEndings2;
-    if (!_participleEndings2) {
+    LUCENE_RUN_ONCE(
         _participleEndings2 = Collection<String>::newInstance();
         _participleEndings2.add(String(L"") + I + V + SH);
         _participleEndings2.add(String(L"") + Y + V + SH);
         _participleEndings2.add(String(L"") + U + IU + SHCH);
-    }
+    );
     return _participleEndings2;
 }
 
 Collection<String> RussianStemmer::participle1Predessors() {
     static Collection<String> _participle1Predessors;
-    if (!_participle1Predessors) {
+    LUCENE_RUN_ONCE(
         _participle1Predessors = Collection<String>::newInstance();
         _participle1Predessors.add(String(L"") + A);
         _participle1Predessors.add(String(L"") + IA);
-    }
+	    );
     return _participle1Predessors;
 }
 
 Collection<String> RussianStemmer::reflexiveEndings() {
     static Collection<String> _participle1Predessors;
-    if (!_participle1Predessors) {
+    LUCENE_RUN_ONCE(
         _participle1Predessors = Collection<String>::newInstance();
         _participle1Predessors.add(String(L"") + S + IA);
         _participle1Predessors.add(String(L"") + S + SOFT);
-    }
+    );
     return _participle1Predessors;
 }
 
 Collection<String> RussianStemmer::verbEndings1() {
     static Collection<String> _verbEndings1;
-    if (!_verbEndings1) {
+    LUCENE_RUN_ONCE(
         _verbEndings1 = Collection<String>::newInstance();
         _verbEndings1.add(String(L"") + I_);
         _verbEndings1.add(String(L"") + L);
@@ -178,13 +178,13 @@ Collection<String> RussianStemmer::verbEndings1() {
         _verbEndings1.add(String(L"") + T + SOFT);
         _verbEndings1.add(String(L"") + E + SH + SOFT);
         _verbEndings1.add(String(L"") + N + N + O);
-    }
+    );
     return _verbEndings1;
 }
 
 Collection<String> RussianStemmer::verbEndings2() {
     static Collection<String> _verbEndings2;
-    if (!_verbEndings2) {
+    LUCENE_RUN_ONCE(
         _verbEndings2 = Collection<String>::newInstance();
         _verbEndings2.add(String(L"") + IU);
         _verbEndings2.add(String(L"") + U + IU);
@@ -215,23 +215,23 @@ Collection<String> RussianStemmer::verbEndings2() {
         _verbEndings2.add(String(L"") + I + SH + SOFT);
         _verbEndings2.add(String(L"") + E + I_ + T + E);
         _verbEndings2.add(String(L"") + U + I_ + T + E);
-    }
+    );
     return _verbEndings2;
 }
 
 Collection<String> RussianStemmer::verb1Predessors() {
     static Collection<String> _verb1Predessors;
-    if (!_verb1Predessors) {
+    LUCENE_RUN_ONCE(
         _verb1Predessors = Collection<String>::newInstance();
         _verb1Predessors.add(String(L"") + A);
         _verb1Predessors.add(String(L"") + IA);
-    }
+    );
     return _verb1Predessors;
 }
 
 Collection<String> RussianStemmer::nounEndings() {
     static Collection<String> _nounEndings;
-    if (!_nounEndings) {
+    LUCENE_RUN_ONCE(
         _nounEndings = Collection<String>::newInstance();
         _nounEndings.add(String(L"") + A);
         _nounEndings.add(String(L"") + U);
@@ -269,36 +269,36 @@ Collection<String> RussianStemmer::nounEndings() {
         _nounEndings.add(String(L"") + I + E + M);
         _nounEndings.add(String(L"") + I + IA + X);
         _nounEndings.add(String(L"") + I + IA + M + I);
-    }
+    );
     return _nounEndings;
 }
 
 Collection<String> RussianStemmer::superlativeEndings() {
     static Collection<String> _superlativeEndings;
-    if (!_superlativeEndings) {
+    LUCENE_RUN_ONCE(
         _superlativeEndings = Collection<String>::newInstance();
         _superlativeEndings.add(String(L"") + E + I_ + SH);
         _superlativeEndings.add(String(L"") + E + I_ + SH + E);
-    }
+	    );
     return _superlativeEndings;
 }
 
 Collection<String> RussianStemmer::derivationalEndings() {
     static Collection<String> _derivationalEndings;
-    if (!_derivationalEndings) {
+    LUCENE_RUN_ONCE(
         _derivationalEndings = Collection<String>::newInstance();
         _derivationalEndings.add(String(L"") + O + S + T);
         _derivationalEndings.add(String(L"") + O + S + T + SOFT);
-    }
+    );
     return _derivationalEndings;
 }
 
 Collection<String> RussianStemmer::doubleN() {
     static Collection<String> _doubleN;
-    if (!_doubleN) {
+    LUCENE_RUN_ONCE(
         _doubleN = Collection<String>::newInstance();
         _doubleN.add(String(L"") + N + N);
-    }
+    );
     return _doubleN;
 }
 
diff --git a/src/contrib/highlighter/WeightedSpanTermExtractor.cpp b/src/contrib/highlighter/WeightedSpanTermExtractor.cpp
index 19ae902..5abe39c 100644
--- a/src/contrib/highlighter/WeightedSpanTermExtractor.cpp
+++ b/src/contrib/highlighter/WeightedSpanTermExtractor.cpp
@@ -410,10 +410,10 @@ FakeReader::~FakeReader() {
 
 IndexReaderPtr FakeReader::EMPTY_MEMORY_INDEX_READER() {
     static IndexReaderPtr _EMPTY_MEMORY_INDEX_READER;
-    if (!_EMPTY_MEMORY_INDEX_READER) {
+    LUCENE_RUN_ONCE(
         _EMPTY_MEMORY_INDEX_READER = newLucene<MemoryIndex>()->createSearcher()->getIndexReader();
         CycleCheck::addStatic(_EMPTY_MEMORY_INDEX_READER);
-    }
+    );
     return _EMPTY_MEMORY_INDEX_READER;
 }
 
diff --git a/src/contrib/memory/MemoryIndex.cpp b/src/contrib/memory/MemoryIndex.cpp
index 07372e8..e1e50d9 100644
--- a/src/contrib/memory/MemoryIndex.cpp
+++ b/src/contrib/memory/MemoryIndex.cpp
@@ -214,10 +214,10 @@ MemoryIndexReader::~MemoryIndexReader() {
 
 TermPtr MemoryIndexReader::MATCH_ALL_TERM() {
     static TermPtr _MATCH_ALL_TERM;
-    if (!_MATCH_ALL_TERM) {
+    LUCENE_RUN_ONCE(
         _MATCH_ALL_TERM = newLucene<Term>(L"");
         CycleCheck::addStatic(_MATCH_ALL_TERM);
-    }
+    );
     return _MATCH_ALL_TERM;
 }
 
@@ -416,9 +416,9 @@ void MemoryIndexReader::doClose() {
 
 HashSet<String> MemoryIndexReader::getFieldNames(FieldOption fieldOption) {
     static HashSet<String> emptySet;
-    if (!emptySet) {
+    LUCENE_RUN_ONCE(
         emptySet = HashSet<String>::newInstance();
-    }
+    );
     if (fieldOption == FIELD_OPTION_UNINDEXED) {
         return emptySet;
     }
diff --git a/src/core/analysis/KeywordTokenizer.cpp b/src/core/analysis/KeywordTokenizer.cpp
index 7d0d2ee..1ae5ec1 100644
--- a/src/core/analysis/KeywordTokenizer.cpp
+++ b/src/core/analysis/KeywordTokenizer.cpp
@@ -70,7 +70,7 @@ void KeywordTokenizer::end() {
     offsetAtt->setOffset(finalOffset, finalOffset);
 }
 
-void KeywordTokenizer::reset() {
+void KeywordTokenizer::reset(void) {
     Tokenizer::reset(input);
     done = false;
 }
diff --git a/src/core/analysis/StopAnalyzer.cpp b/src/core/analysis/StopAnalyzer.cpp
index 3538031..56401cc 100644
--- a/src/core/analysis/StopAnalyzer.cpp
+++ b/src/core/analysis/StopAnalyzer.cpp
@@ -46,9 +46,9 @@ StopAnalyzer::~StopAnalyzer() {
 
 const HashSet<String> StopAnalyzer::ENGLISH_STOP_WORDS_SET() {
     static HashSet<String> __ENGLISH_STOP_WORDS_SET;
-    if (!__ENGLISH_STOP_WORDS_SET) {
+    LUCENE_RUN_ONCE(
         __ENGLISH_STOP_WORDS_SET = HashSet<String>::newInstance(_ENGLISH_STOP_WORDS_SET, _ENGLISH_STOP_WORDS_SET + SIZEOF_ARRAY(_ENGLISH_STOP_WORDS_SET));
-    }
+    );
     return __ENGLISH_STOP_WORDS_SET;
 }
 
diff --git a/src/core/analysis/TeeSinkTokenFilter.cpp b/src/core/analysis/TeeSinkTokenFilter.cpp
index a9d7257..c1bc81b 100644
--- a/src/core/analysis/TeeSinkTokenFilter.cpp
+++ b/src/core/analysis/TeeSinkTokenFilter.cpp
@@ -19,10 +19,10 @@ TeeSinkTokenFilter::~TeeSinkTokenFilter() {
 
 SinkTokenStreamPtr TeeSinkTokenFilter::newSinkTokenStream() {
     static SinkFilterPtr ACCEPT_ALL_FILTER;
-    if (!ACCEPT_ALL_FILTER) {
+    LUCENE_RUN_ONCE(
         ACCEPT_ALL_FILTER = newLucene<AcceptAllSinkFilter>();
         CycleCheck::addStatic(ACCEPT_ALL_FILTER);
-    }
+    );
     return newSinkTokenStream(ACCEPT_ALL_FILTER);
 }
 
diff --git a/src/core/analysis/Token.cpp b/src/core/analysis/Token.cpp
index 5326972..baa86c4 100644
--- a/src/core/analysis/Token.cpp
+++ b/src/core/analysis/Token.cpp
@@ -449,10 +449,10 @@ void Token::copyTo(const AttributePtr& target) {
 
 AttributeFactoryPtr Token::TOKEN_ATTRIBUTE_FACTORY() {
     static AttributeFactoryPtr _TOKEN_ATTRIBUTE_FACTORY;
-    if (!_TOKEN_ATTRIBUTE_FACTORY) {
+    LUCENE_RUN_ONCE(
         _TOKEN_ATTRIBUTE_FACTORY = newLucene<TokenAttributeFactory>(AttributeFactory::DEFAULT_ATTRIBUTE_FACTORY());
         CycleCheck::addStatic(_TOKEN_ATTRIBUTE_FACTORY);
-    }
+    );
     return _TOKEN_ATTRIBUTE_FACTORY;
 }
 
diff --git a/src/core/analysis/standard/StandardFilter.cpp b/src/core/analysis/standard/StandardFilter.cpp
index 32e3224..be1abd0 100644
--- a/src/core/analysis/standard/StandardFilter.cpp
+++ b/src/core/analysis/standard/StandardFilter.cpp
@@ -22,17 +22,21 @@ StandardFilter::~StandardFilter() {
 
 const String& StandardFilter::APOSTROPHE_TYPE() {
     static String _APOSTROPHE_TYPE;
-    if (_APOSTROPHE_TYPE.empty()) {
+    
+    LUCENE_RUN_ONCE(
         _APOSTROPHE_TYPE = StandardTokenizer::TOKEN_TYPES()[StandardTokenizer::APOSTROPHE];
-    }
+    );
+    
     return _APOSTROPHE_TYPE;
 }
 
 const String& StandardFilter::ACRONYM_TYPE() {
     static String _ACRONYM_TYPE;
-    if (_ACRONYM_TYPE.empty()) {
-        _ACRONYM_TYPE = StandardTokenizer::TOKEN_TYPES()[StandardTokenizer::ACRONYM];
-    }
+
+    LUCENE_RUN_ONCE(
+        _ACRONYM_TYPE = StandardTokenizer::TOKEN_TYPES()[StandardTokenizer::ACRONYM]
+    );
+    
     return _ACRONYM_TYPE;
 }
 
diff --git a/src/core/analysis/standard/StandardTokenizer.cpp b/src/core/analysis/standard/StandardTokenizer.cpp
index 8f85ab3..1f0c66a 100644
--- a/src/core/analysis/standard/StandardTokenizer.cpp
+++ b/src/core/analysis/standard/StandardTokenizer.cpp
@@ -47,7 +47,7 @@ StandardTokenizer::~StandardTokenizer() {
 
 const Collection<String> StandardTokenizer::TOKEN_TYPES() {
     static Collection<String> _TOKEN_TYPES;
-    if (!_TOKEN_TYPES) {
+    LUCENE_RUN_ONCE(
         _TOKEN_TYPES = newCollection<String>(
                            L"<ALPHANUM>",
                            L"<APOSTROPHE>",
@@ -59,7 +59,7 @@ const Collection<String> StandardTokenizer::TOKEN_TYPES() {
                            L"<CJ>",
                            L"<ACRONYM_DEP>"
                        );
-    }
+    );
     return _TOKEN_TYPES;
 }
 
diff --git a/src/core/document/DateField.cpp b/src/core/document/DateField.cpp
index 12ab172..6cbc92a 100644
--- a/src/core/document/DateField.cpp
+++ b/src/core/document/DateField.cpp
@@ -16,27 +16,28 @@ DateField::~DateField() {
 
 int32_t DateField::DATE_LEN() {
     static int32_t _DATE_LEN = 0;
-    if (_DATE_LEN == 0) {
-        // make date strings long enough to last a millennium
+
+    // make date strings long enough to last a millennium
+    LUCENE_RUN_ONCE(
         _DATE_LEN = (int32_t)StringUtils::toString((int64_t)(1000 * 365 * 24) * (int64_t)(60 * 60 * 1000), StringUtils::CHARACTER_MAX_RADIX).length();
-    }
+    );
     return _DATE_LEN;
 }
 
 const String& DateField::MIN_DATE_STRING() {
     static String _MIN_DATE_STRING;
-    if (_MIN_DATE_STRING.empty()) {
+    LUCENE_RUN_ONCE(
         _MIN_DATE_STRING = timeToString(0);
-    }
+    );
     return _MIN_DATE_STRING;
 }
 
 const String& DateField::MAX_DATE_STRING() {
     static String _MAX_DATE_STRING;
-    if (_MAX_DATE_STRING.empty()) {
+    LUCENE_RUN_ONCE(
         _MAX_DATE_STRING.resize(DATE_LEN());
         std::fill(_MAX_DATE_STRING.begin(), _MAX_DATE_STRING.end(), L'z');
-    }
+    );
     return _MAX_DATE_STRING;
 }
 
diff --git a/src/core/document/NumberTools.cpp b/src/core/document/NumberTools.cpp
index 954c09e..35d990f 100644
--- a/src/core/document/NumberTools.cpp
+++ b/src/core/document/NumberTools.cpp
@@ -19,27 +19,27 @@ NumberTools::~NumberTools() {
 
 const String& NumberTools::MIN_STRING_VALUE() {
     static String _MIN_STRING_VALUE;
-    if (_MIN_STRING_VALUE.empty()) {
+    LUCENE_RUN_ONCE(
         _MIN_STRING_VALUE += NEGATIVE_PREFIX;
         _MIN_STRING_VALUE += L"0000000000000";
-    }
+    );
     return _MIN_STRING_VALUE;
 }
 
 const String& NumberTools::MAX_STRING_VALUE() {
     static String _MAX_STRING_VALUE;
-    if (_MAX_STRING_VALUE.empty()) {
+    LUCENE_RUN_ONCE(
         _MAX_STRING_VALUE += POSITIVE_PREFIX;
         _MAX_STRING_VALUE += L"1y2p0ij32e8e7";
-    }
+    );
     return _MAX_STRING_VALUE;
 }
 
 int32_t NumberTools::STR_SIZE() {
     static int32_t _STR_SIZE = 0;
-    if (_STR_SIZE == 0) {
+    LUCENE_RUN_ONCE(
         _STR_SIZE = (int32_t)MIN_STRING_VALUE().length();
-    }
+    );
     return _STR_SIZE;
 }
 
diff --git a/src/core/index/DocumentsWriter.cpp b/src/core/index/DocumentsWriter.cpp
index 29b36c7..67d107e 100644
--- a/src/core/index/DocumentsWriter.cpp
+++ b/src/core/index/DocumentsWriter.cpp
@@ -159,10 +159,10 @@ PerDocBufferPtr DocumentsWriter::newPerDocBuffer() {
 
 IndexingChainPtr DocumentsWriter::getDefaultIndexingChain() {
     static DefaultIndexingChainPtr defaultIndexingChain;
-    if (!defaultIndexingChain) {
+    LUCENE_RUN_ONCE(
         defaultIndexingChain = newLucene<DefaultIndexingChain>();
         CycleCheck::addStatic(defaultIndexingChain);
-    }
+    );
     return defaultIndexingChain;
 }
 
diff --git a/src/core/index/IndexFileNameFilter.cpp b/src/core/index/IndexFileNameFilter.cpp
index 9cc9db3..64b42b2 100644
--- a/src/core/index/IndexFileNameFilter.cpp
+++ b/src/core/index/IndexFileNameFilter.cpp
@@ -52,10 +52,10 @@ bool IndexFileNameFilter::isCFSFile(const String& name) {
 
 IndexFileNameFilterPtr IndexFileNameFilter::getFilter() {
     static IndexFileNameFilterPtr singleton;
-    if (!singleton) {
+    LUCENE_RUN_ONCE(
         singleton = newLucene<IndexFileNameFilter>();
         CycleCheck::addStatic(singleton);
-    }
+    );
     return singleton;
 }
 
diff --git a/src/core/index/IndexFileNames.cpp b/src/core/index/IndexFileNames.cpp
index c140cd1..efcb326 100644
--- a/src/core/index/IndexFileNames.cpp
+++ b/src/core/index/IndexFileNames.cpp
@@ -117,7 +117,7 @@ const String& IndexFileNames::GEN_EXTENSION() {
 
 const HashSet<String> IndexFileNames::INDEX_EXTENSIONS() {
     static HashSet<String> _INDEX_EXTENSIONS;
-    if (!_INDEX_EXTENSIONS) {
+    LUCENE_RUN_ONCE(
         _INDEX_EXTENSIONS = HashSet<String>::newInstance();
         _INDEX_EXTENSIONS.add(COMPOUND_FILE_EXTENSION());
         _INDEX_EXTENSIONS.add(FIELD_INFOS_EXTENSION());
@@ -134,13 +134,13 @@ const HashSet<String> IndexFileNames::INDEX_EXTENSIONS() {
         _INDEX_EXTENSIONS.add(GEN_EXTENSION());
         _INDEX_EXTENSIONS.add(NORMS_EXTENSION());
         _INDEX_EXTENSIONS.add(COMPOUND_FILE_STORE_EXTENSION());
-    }
+    );
     return _INDEX_EXTENSIONS;
 };
 
 const HashSet<String> IndexFileNames::INDEX_EXTENSIONS_IN_COMPOUND_FILE() {
     static HashSet<String> _INDEX_EXTENSIONS_IN_COMPOUND_FILE;
-    if (!_INDEX_EXTENSIONS_IN_COMPOUND_FILE) {
+    LUCENE_RUN_ONCE(
         _INDEX_EXTENSIONS_IN_COMPOUND_FILE = HashSet<String>::newInstance();
         _INDEX_EXTENSIONS_IN_COMPOUND_FILE.add(FIELD_INFOS_EXTENSION());
         _INDEX_EXTENSIONS_IN_COMPOUND_FILE.add(FIELDS_INDEX_EXTENSION());
@@ -153,26 +153,26 @@ const HashSet<String> IndexFileNames::INDEX_EXTENSIONS_IN_COMPOUND_FILE() {
         _INDEX_EXTENSIONS_IN_COMPOUND_FILE.add(VECTORS_DOCUMENTS_EXTENSION());
         _INDEX_EXTENSIONS_IN_COMPOUND_FILE.add(VECTORS_FIELDS_EXTENSION());
         _INDEX_EXTENSIONS_IN_COMPOUND_FILE.add(NORMS_EXTENSION());
-    }
+    );
     return _INDEX_EXTENSIONS_IN_COMPOUND_FILE;
 };
 
 const HashSet<String> IndexFileNames::STORE_INDEX_EXTENSIONS() {
     static HashSet<String> _STORE_INDEX_EXTENSIONS;
-    if (!_STORE_INDEX_EXTENSIONS) {
+    LUCENE_RUN_ONCE(
         _STORE_INDEX_EXTENSIONS = HashSet<String>::newInstance();
         _STORE_INDEX_EXTENSIONS.add(VECTORS_INDEX_EXTENSION());
         _STORE_INDEX_EXTENSIONS.add(VECTORS_FIELDS_EXTENSION());
         _STORE_INDEX_EXTENSIONS.add(VECTORS_DOCUMENTS_EXTENSION());
         _STORE_INDEX_EXTENSIONS.add(FIELDS_INDEX_EXTENSION());
         _STORE_INDEX_EXTENSIONS.add(FIELDS_EXTENSION());
-    }
+    );
     return _STORE_INDEX_EXTENSIONS;
 };
 
 const HashSet<String> IndexFileNames::NON_STORE_INDEX_EXTENSIONS() {
     static HashSet<String> _NON_STORE_INDEX_EXTENSIONS;
-    if (!_NON_STORE_INDEX_EXTENSIONS) {
+    LUCENE_RUN_ONCE(
         _NON_STORE_INDEX_EXTENSIONS = HashSet<String>::newInstance();
         _NON_STORE_INDEX_EXTENSIONS.add(FIELD_INFOS_EXTENSION());
         _NON_STORE_INDEX_EXTENSIONS.add(FREQ_EXTENSION());
@@ -180,13 +180,13 @@ const HashSet<String> IndexFileNames::NON_STORE_INDEX_EXTENSIONS() {
         _NON_STORE_INDEX_EXTENSIONS.add(TERMS_EXTENSION());
         _NON_STORE_INDEX_EXTENSIONS.add(TERMS_INDEX_EXTENSION());
         _NON_STORE_INDEX_EXTENSIONS.add(NORMS_EXTENSION());
-    }
+    );
     return _NON_STORE_INDEX_EXTENSIONS;
 };
 
 const HashSet<String> IndexFileNames::COMPOUND_EXTENSIONS() {
     static HashSet<String> _COMPOUND_EXTENSIONS;
-    if (!_COMPOUND_EXTENSIONS) {
+    LUCENE_RUN_ONCE(
         _COMPOUND_EXTENSIONS = HashSet<String>::newInstance();
         _COMPOUND_EXTENSIONS.add(FIELD_INFOS_EXTENSION());
         _COMPOUND_EXTENSIONS.add(FREQ_EXTENSION());
@@ -195,18 +195,18 @@ const HashSet<String> IndexFileNames::COMPOUND_EXTENSIONS() {
         _COMPOUND_EXTENSIONS.add(FIELDS_EXTENSION());
         _COMPOUND_EXTENSIONS.add(TERMS_INDEX_EXTENSION());
         _COMPOUND_EXTENSIONS.add(TERMS_EXTENSION());
-    }
+    );
     return _COMPOUND_EXTENSIONS;
 };
 
 const HashSet<String> IndexFileNames::VECTOR_EXTENSIONS() {
     static HashSet<String> _VECTOR_EXTENSIONS;
-    if (!_VECTOR_EXTENSIONS) {
+    LUCENE_RUN_ONCE(
         _VECTOR_EXTENSIONS = HashSet<String>::newInstance();
         _VECTOR_EXTENSIONS.add(VECTORS_INDEX_EXTENSION());
         _VECTOR_EXTENSIONS.add(VECTORS_DOCUMENTS_EXTENSION());
         _VECTOR_EXTENSIONS.add(VECTORS_FIELDS_EXTENSION());
-    }
+    );
     return _VECTOR_EXTENSIONS;
 };
 
diff --git a/src/core/index/IndexWriter.cpp b/src/core/index/IndexWriter.cpp
index c7d3089..8674936 100644
--- a/src/core/index/IndexWriter.cpp
+++ b/src/core/index/IndexWriter.cpp
@@ -266,9 +266,9 @@ void IndexWriter::initialize() {
 
 int32_t IndexWriter::MAX_TERM_LENGTH() {
     static int32_t _MAX_TERM_LENGTH = 0;
-    if (_MAX_TERM_LENGTH == 0) {
+    LUCENE_RUN_ONCE(
         _MAX_TERM_LENGTH = DocumentsWriter::MAX_TERM_LENGTH;
-    }
+    );
     return _MAX_TERM_LENGTH;
 }
 
diff --git a/src/core/index/NormsWriter.cpp b/src/core/index/NormsWriter.cpp
index 54ef2a6..002a3d7 100644
--- a/src/core/index/NormsWriter.cpp
+++ b/src/core/index/NormsWriter.cpp
@@ -28,9 +28,9 @@ NormsWriter::~NormsWriter() {
 
 uint8_t NormsWriter::getDefaultNorm() {
     static uint8_t defaultNorm = 0;
-    if (defaultNorm == 0) {
+    LUCENE_RUN_ONCE(
         defaultNorm = Similarity::encodeNorm(1.0);
-    }
+    );
     return defaultNorm;
 }
 
diff --git a/src/core/index/SegmentTermPositionVector.cpp b/src/core/index/SegmentTermPositionVector.cpp
index f6e57d8..cd8dedf 100644
--- a/src/core/index/SegmentTermPositionVector.cpp
+++ b/src/core/index/SegmentTermPositionVector.cpp
@@ -23,9 +23,9 @@ SegmentTermPositionVector::~SegmentTermPositionVector() {
 
 const Collection<int32_t> SegmentTermPositionVector::EMPTY_TERM_POS() {
     static Collection<int32_t> _EMPTY_TERM_POS;
-    if (!_EMPTY_TERM_POS) {
+    LUCENE_RUN_ONCE(
         _EMPTY_TERM_POS = Collection<int32_t>::newInstance();
-    }
+    );
     return _EMPTY_TERM_POS;
 }
 
diff --git a/src/core/index/TermVectorOffsetInfo.cpp b/src/core/index/TermVectorOffsetInfo.cpp
index 66d3465..2f43144 100644
--- a/src/core/index/TermVectorOffsetInfo.cpp
+++ b/src/core/index/TermVectorOffsetInfo.cpp
@@ -19,9 +19,9 @@ TermVectorOffsetInfo::~TermVectorOffsetInfo() {
 
 const Collection<TermVectorOffsetInfoPtr> TermVectorOffsetInfo::EMPTY_OFFSET_INFO() {
     static Collection<TermVectorOffsetInfoPtr> _EMPTY_OFFSET_INFO;
-    if (!_EMPTY_OFFSET_INFO) {
+    LUCENE_RUN_ONCE(
         _EMPTY_OFFSET_INFO = Collection<TermVectorOffsetInfoPtr>::newInstance();
-    }
+    );
     return _EMPTY_OFFSET_INFO;
 }
 
diff --git a/src/core/search/DocIdSet.cpp b/src/core/search/DocIdSet.cpp
index 28d19a0..f3ddb40 100644
--- a/src/core/search/DocIdSet.cpp
+++ b/src/core/search/DocIdSet.cpp
@@ -19,10 +19,10 @@ bool DocIdSet::isCacheable() {
 
 DocIdSetPtr DocIdSet::EMPTY_DOCIDSET() {
     static DocIdSetPtr _EMPTY_DOCIDSET;
-    if (!_EMPTY_DOCIDSET) {
+    LUCENE_RUN_ONCE(
         _EMPTY_DOCIDSET = newLucene<EmptyDocIdSet>();
         CycleCheck::addStatic(_EMPTY_DOCIDSET);
-    }
+    );
     return _EMPTY_DOCIDSET;
 }
 
diff --git a/src/core/search/FieldCache.cpp b/src/core/search/FieldCache.cpp
index fab0836..7b7e51f 100644
--- a/src/core/search/FieldCache.cpp
+++ b/src/core/search/FieldCache.cpp
@@ -21,73 +21,73 @@ FieldCache::~FieldCache() {
 
 FieldCachePtr FieldCache::DEFAULT() {
     static FieldCacheImplPtr _DEFAULT;
-    if (!_DEFAULT) {
+    LUCENE_RUN_ONCE(
         _DEFAULT = newLucene<FieldCacheImpl>();
         CycleCheck::addStatic(_DEFAULT);
-    }
+    );
     return _DEFAULT;
 }
 
 ByteParserPtr FieldCache::DEFAULT_BYTE_PARSER() {
     static DefaultByteParserPtr _DEFAULT_BYTE_PARSER;
-    if (!_DEFAULT_BYTE_PARSER) {
+    LUCENE_RUN_ONCE(
         _DEFAULT_BYTE_PARSER = newLucene<DefaultByteParser>();
         CycleCheck::addStatic(_DEFAULT_BYTE_PARSER);
-    }
+    );
     return _DEFAULT_BYTE_PARSER;
 }
 
 IntParserPtr FieldCache::DEFAULT_INT_PARSER() {
     static DefaultIntParserPtr _DEFAULT_INT_PARSER;
-    if (!_DEFAULT_INT_PARSER) {
+    LUCENE_RUN_ONCE(
         _DEFAULT_INT_PARSER = newLucene<DefaultIntParser>();
         CycleCheck::addStatic(_DEFAULT_INT_PARSER);
-    }
+    );
     return _DEFAULT_INT_PARSER;
 }
 
 LongParserPtr FieldCache::DEFAULT_LONG_PARSER() {
     static DefaultLongParserPtr _DEFAULT_LONG_PARSER;
-    if (!_DEFAULT_LONG_PARSER) {
+    LUCENE_RUN_ONCE(
         _DEFAULT_LONG_PARSER = newLucene<DefaultLongParser>();
         CycleCheck::addStatic(_DEFAULT_LONG_PARSER);
-    }
+    );
     return _DEFAULT_LONG_PARSER;
 }
 
 DoubleParserPtr FieldCache::DEFAULT_DOUBLE_PARSER() {
     static DefaultDoubleParserPtr _DEFAULT_DOUBLE_PARSER;
-    if (!_DEFAULT_DOUBLE_PARSER) {
+    LUCENE_RUN_ONCE(
         _DEFAULT_DOUBLE_PARSER = newLucene<DefaultDoubleParser>();
         CycleCheck::addStatic(_DEFAULT_DOUBLE_PARSER);
-    }
+    );
     return _DEFAULT_DOUBLE_PARSER;
 }
 
 IntParserPtr FieldCache::NUMERIC_UTILS_INT_PARSER() {
     static NumericUtilsIntParserPtr _NUMERIC_UTILS_INT_PARSER;
-    if (!_NUMERIC_UTILS_INT_PARSER) {
+    LUCENE_RUN_ONCE(
         _NUMERIC_UTILS_INT_PARSER = newLucene<NumericUtilsIntParser>();
         CycleCheck::addStatic(_NUMERIC_UTILS_INT_PARSER);
-    }
+    );
     return _NUMERIC_UTILS_INT_PARSER;
 }
 
 LongParserPtr FieldCache::NUMERIC_UTILS_LONG_PARSER() {
     static NumericUtilsLongParserPtr _NUMERIC_UTILS_LONG_PARSER;
-    if (!_NUMERIC_UTILS_LONG_PARSER) {
+    LUCENE_RUN_ONCE(
         _NUMERIC_UTILS_LONG_PARSER = newLucene<NumericUtilsLongParser>();
         CycleCheck::addStatic(_NUMERIC_UTILS_LONG_PARSER);
-    }
+    );
     return _NUMERIC_UTILS_LONG_PARSER;
 }
 
 DoubleParserPtr FieldCache::NUMERIC_UTILS_DOUBLE_PARSER() {
     static NumericUtilsDoubleParserPtr _NUMERIC_UTILS_DOUBLE_PARSER;
-    if (!_NUMERIC_UTILS_DOUBLE_PARSER) {
+    LUCENE_RUN_ONCE(
         _NUMERIC_UTILS_DOUBLE_PARSER = newLucene<NumericUtilsDoubleParser>();
         CycleCheck::addStatic(_NUMERIC_UTILS_DOUBLE_PARSER);
-    }
+    );
     return _NUMERIC_UTILS_DOUBLE_PARSER;
 }
 
diff --git a/src/core/search/FilterManager.cpp b/src/core/search/FilterManager.cpp
index c553013..c598bc4 100644
--- a/src/core/search/FilterManager.cpp
+++ b/src/core/search/FilterManager.cpp
@@ -35,10 +35,10 @@ void FilterManager::initialize() {
 
 FilterManagerPtr FilterManager::getInstance() {
     static FilterManagerPtr manager;
-    if (!manager) {
+    LUCENE_RUN_ONCE(
         manager = newLucene<FilterManager>();
         CycleCheck::addStatic(manager);
-    }
+    );
     return manager;
 }
 
diff --git a/src/core/search/MultiTermQuery.cpp b/src/core/search/MultiTermQuery.cpp
index 89a0e98..cb004e3 100644
--- a/src/core/search/MultiTermQuery.cpp
+++ b/src/core/search/MultiTermQuery.cpp
@@ -30,37 +30,37 @@ MultiTermQuery::~MultiTermQuery() {
 
 RewriteMethodPtr MultiTermQuery::CONSTANT_SCORE_FILTER_REWRITE() {
     static RewriteMethodPtr _CONSTANT_SCORE_FILTER_REWRITE;
-    if (!_CONSTANT_SCORE_FILTER_REWRITE) {
+    LUCENE_RUN_ONCE(
         _CONSTANT_SCORE_FILTER_REWRITE = newLucene<ConstantScoreFilterRewrite>();
         CycleCheck::addStatic(_CONSTANT_SCORE_FILTER_REWRITE);
-    }
+    );
     return _CONSTANT_SCORE_FILTER_REWRITE;
 }
 
 RewriteMethodPtr MultiTermQuery::SCORING_BOOLEAN_QUERY_REWRITE() {
     static RewriteMethodPtr _SCORING_BOOLEAN_QUERY_REWRITE;
-    if (!_SCORING_BOOLEAN_QUERY_REWRITE) {
+    LUCENE_RUN_ONCE(
         _SCORING_BOOLEAN_QUERY_REWRITE = newLucene<ScoringBooleanQueryRewrite>();
         CycleCheck::addStatic(_SCORING_BOOLEAN_QUERY_REWRITE);
-    }
+    );
     return _SCORING_BOOLEAN_QUERY_REWRITE;
 }
 
 RewriteMethodPtr MultiTermQuery::CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE() {
     static RewriteMethodPtr _CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE;
-    if (!_CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE) {
+    LUCENE_RUN_ONCE(
         _CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE = newLucene<ConstantScoreBooleanQueryRewrite>();
         CycleCheck::addStatic(_CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE);
-    }
+    );
     return _CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE;
 }
 
 RewriteMethodPtr MultiTermQuery::CONSTANT_SCORE_AUTO_REWRITE_DEFAULT() {
     static RewriteMethodPtr _CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
-    if (!_CONSTANT_SCORE_AUTO_REWRITE_DEFAULT) {
+    LUCENE_RUN_ONCE(
         _CONSTANT_SCORE_AUTO_REWRITE_DEFAULT = newLucene<ConstantScoreAutoRewriteDefault>();
         CycleCheck::addStatic(_CONSTANT_SCORE_AUTO_REWRITE_DEFAULT);
-    }
+    );
     return _CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
 }
 
diff --git a/src/core/search/Similarity.cpp b/src/core/search/Similarity.cpp
index 4a11b46..3df64e5 100644
--- a/src/core/search/Similarity.cpp
+++ b/src/core/search/Similarity.cpp
@@ -25,22 +25,23 @@ Similarity::~Similarity() {
 }
 
 SimilarityPtr Similarity::getDefault() {
+	// race condition?
     static SimilarityPtr defaultImpl;
-    if (!defaultImpl) {
+    LUCENE_RUN_ONCE(
         defaultImpl = newLucene<DefaultSimilarity>();
         CycleCheck::addStatic(defaultImpl);
-    }
+    );
     return defaultImpl;
 }
 
 static const Collection<double> GEN_NORM_TABLE() {
     static Collection<double> _NORM_TABLE;
-    if (!_NORM_TABLE) {
+    LUCENE_RUN_ONCE(
         _NORM_TABLE = Collection<double>::newInstance(256);
         for (int32_t i = 0; i < 256; ++i) {
             _NORM_TABLE[i] = SmallDouble::byteToDouble((uint8_t)i);
         }
-    }
+    );
     return _NORM_TABLE;
 }
 
diff --git a/src/core/search/Sort.cpp b/src/core/search/Sort.cpp
index 3d1b384..fe2f25d 100644
--- a/src/core/search/Sort.cpp
+++ b/src/core/search/Sort.cpp
@@ -28,19 +28,19 @@ Sort::~Sort() {
 
 SortPtr Sort::RELEVANCE() {
     static SortPtr _RELEVANCE;
-    if (!_RELEVANCE) {
+    LUCENE_RUN_ONCE(
         _RELEVANCE = newLucene<Sort>();
         CycleCheck::addStatic(_RELEVANCE);
-    }
+    );
     return _RELEVANCE;
 }
 
 SortPtr Sort::INDEXORDER() {
     static SortPtr _INDEXORDER;
-    if (!_INDEXORDER) {
+    LUCENE_RUN_ONCE(
         _INDEXORDER = newLucene<Sort>(SortField::FIELD_DOC());
         CycleCheck::addStatic(_INDEXORDER);
-    }
+    );
     return _INDEXORDER;
 }
 
diff --git a/src/core/search/SortField.cpp b/src/core/search/SortField.cpp
index fa7d453..9937b32 100644
--- a/src/core/search/SortField.cpp
+++ b/src/core/search/SortField.cpp
@@ -86,19 +86,19 @@ SortField::~SortField() {
 
 SortFieldPtr SortField::FIELD_SCORE() {
     static SortFieldPtr _FIELD_SCORE;
-    if (!_FIELD_SCORE) {
+    LUCENE_RUN_ONCE(
         _FIELD_SCORE = newLucene<SortField>(L"", SCORE);
         CycleCheck::addStatic(_FIELD_SCORE);
-    }
+    );
     return _FIELD_SCORE;
 }
 
 SortFieldPtr SortField::FIELD_DOC() {
     static SortFieldPtr _FIELD_DOC;
-    if (!_FIELD_DOC) {
+    LUCENE_RUN_ONCE(
         _FIELD_DOC = newLucene<SortField>(L"", DOC);
         CycleCheck::addStatic(_FIELD_DOC);
-    }
+    );
     return _FIELD_DOC;
 }
 
diff --git a/src/core/search/TimeLimitingCollector.cpp b/src/core/search/TimeLimitingCollector.cpp
index 56f07d4..39174f4 100644
--- a/src/core/search/TimeLimitingCollector.cpp
+++ b/src/core/search/TimeLimitingCollector.cpp
@@ -30,10 +30,10 @@ TimeLimitingCollector::~TimeLimitingCollector() {
 
 TimerThreadPtr TimeLimitingCollector::TIMER_THREAD() {
     static TimerThreadPtr _TIMER_THREAD;
-    if (!_TIMER_THREAD) {
+    LUCENE_RUN_ONCE(
         _TIMER_THREAD = newLucene<TimerThread>();
         CycleCheck::addStatic(_TIMER_THREAD);
-    }
+    );
     if (!_TIMER_THREAD->isAlive()) {
         _TIMER_THREAD->start();    // start single thread instance
     }
diff --git a/src/core/search/TopDocsCollector.cpp b/src/core/search/TopDocsCollector.cpp
index 6c95a09..c16c3cd 100644
--- a/src/core/search/TopDocsCollector.cpp
+++ b/src/core/search/TopDocsCollector.cpp
@@ -21,10 +21,10 @@ TopDocsCollector::~TopDocsCollector() {
 
 TopDocsPtr TopDocsCollector::EMPTY_TOPDOCS() {
     static TopDocsPtr _EMPTY_TOPDOCS;
-    if (!_EMPTY_TOPDOCS) {
+    LUCENE_RUN_ONCE(
         _EMPTY_TOPDOCS = newLucene<TopDocs>(0, Collection<ScoreDocPtr>::newInstance(), std::numeric_limits<double>::quiet_NaN());
         CycleCheck::addStatic(_EMPTY_TOPDOCS);
-    }
+    );
     return _EMPTY_TOPDOCS;
 }
 
diff --git a/src/core/search/TopFieldCollector.cpp b/src/core/search/TopFieldCollector.cpp
index cc7efc2..188232f 100644
--- a/src/core/search/TopFieldCollector.cpp
+++ b/src/core/search/TopFieldCollector.cpp
@@ -29,9 +29,9 @@ TopFieldCollector::~TopFieldCollector() {
 
 const Collection<ScoreDocPtr> TopFieldCollector::EMPTY_SCOREDOCS() {
     static Collection<ScoreDocPtr> _EMPTY_SCOREDOCS;
-    if (!_EMPTY_SCOREDOCS) {
+    LUCENE_RUN_ONCE(
         _EMPTY_SCOREDOCS = Collection<ScoreDocPtr>::newInstance();
-    }
+    );
     return _EMPTY_SCOREDOCS;
 }
 
diff --git a/src/core/store/NativeFSLockFactory.cpp b/src/core/store/NativeFSLockFactory.cpp
index 3a3adba..2ba0471 100644
--- a/src/core/store/NativeFSLockFactory.cpp
+++ b/src/core/store/NativeFSLockFactory.cpp
@@ -53,17 +53,17 @@ NativeFSLock::~NativeFSLock() {
 
 SynchronizePtr NativeFSLock::LOCK_HELD_LOCK() {
     static SynchronizePtr _LOCK_HELD_LOCK;
-    if (!_LOCK_HELD_LOCK) {
+    LUCENE_RUN_ONCE(
         _LOCK_HELD_LOCK = newInstance<Synchronize>();
-    }
+    );
     return _LOCK_HELD_LOCK;
 }
 
 HashSet<String> NativeFSLock::LOCK_HELD() {
     static HashSet<String> _LOCK_HELD;
-    if (!_LOCK_HELD) {
+    LUCENE_RUN_ONCE(
         _LOCK_HELD = HashSet<String>::newInstance();
-    }
+    );
     return _LOCK_HELD;
 }
 
diff --git a/src/core/store/NoLockFactory.cpp b/src/core/store/NoLockFactory.cpp
index 03c9b4a..539369b 100644
--- a/src/core/store/NoLockFactory.cpp
+++ b/src/core/store/NoLockFactory.cpp
@@ -15,20 +15,20 @@ NoLockFactory::~NoLockFactory() {
 
 NoLockFactoryPtr NoLockFactory::getNoLockFactory() {
     static NoLockFactoryPtr singleton;
-    if (!singleton) {
+    LUCENE_RUN_ONCE(
         singleton = newLucene<NoLockFactory>();
         CycleCheck::addStatic(singleton);
-    }
+    );
     return singleton;
 }
 
 NoLockPtr NoLockFactory::getSingletonLock() {
     // Single instance returned whenever makeLock is called.
     static NoLockPtr singletonLock;
-    if (!singletonLock) {
+    LUCENE_RUN_ONCE(
         singletonLock = newLucene<NoLock>();
         CycleCheck::addStatic(singletonLock);
-    }
+    );
     return singletonLock;
 }
 
diff --git a/src/core/util/AttributeSource.cpp b/src/core/util/AttributeSource.cpp
index c5fb392..12e6b21 100644
--- a/src/core/util/AttributeSource.cpp
+++ b/src/core/util/AttributeSource.cpp
@@ -22,10 +22,12 @@ AttributePtr AttributeFactory::createAttributeInstance(const String& className)
 
 AttributeFactoryPtr AttributeFactory::DEFAULT_ATTRIBUTE_FACTORY() {
     static AttributeFactoryPtr _DEFAULT_ATTRIBUTE_FACTORY;
-    if (!_DEFAULT_ATTRIBUTE_FACTORY) {
+
+    LUCENE_RUN_ONCE(
         _DEFAULT_ATTRIBUTE_FACTORY = newLucene<DefaultAttributeFactory>();
         CycleCheck::addStatic(_DEFAULT_ATTRIBUTE_FACTORY);
-    }
+    );
+    
     return _DEFAULT_ATTRIBUTE_FACTORY;
 }
 
diff --git a/src/core/util/CycleCheck.cpp b/src/core/util/CycleCheck.cpp
index 60349c2..4866732 100644
--- a/src/core/util/CycleCheck.cpp
+++ b/src/core/util/CycleCheck.cpp
@@ -34,9 +34,9 @@ void CycleCheck::addRef(const String& className, int32_t ref) {
 
 void CycleCheck::addStatic(LuceneObjectPtr* staticRef) {
 #ifdef LPP_USE_CYCLIC_CHECK
-    if (!staticRefs) {
+    LUCENE_RUN_ONCE(
         staticRefs = Set<LuceneObjectPtr*>::newInstance();
-    }
+    );
     staticRefs.add(staticRef);
 #endif
 }
diff --git a/src/core/util/ThreadPool.cpp b/src/core/util/ThreadPool.cpp
index c8dc10e..8086d8b 100644
--- a/src/core/util/ThreadPool.cpp
+++ b/src/core/util/ThreadPool.cpp
@@ -28,10 +28,10 @@ ThreadPool::~ThreadPool() {
 
 ThreadPoolPtr ThreadPool::getInstance() {
     static ThreadPoolPtr threadPool;
-    if (!threadPool) {
+    LUCENE_RUN_ONCE(
         threadPool = newLucene<ThreadPool>();
         CycleCheck::addStatic(threadPool);
-    }
+    );
     return threadPool;
 }
 
diff --git a/src/demo/indexfiles/CMakeLists.txt b/src/demo/indexfiles/CMakeLists.txt
index a1dd582..4f6cabf 100644
--- a/src/demo/indexfiles/CMakeLists.txt
+++ b/src/demo/indexfiles/CMakeLists.txt
@@ -44,3 +44,7 @@ target_link_libraries(indexfiles
     ZLIB::ZLIB
     lucene++::lucene++
     lucene++::lucene++-contrib)
+
+#  set (CMAKE_CXX_FLAGS "-g -fsanitize=address -fno-omit-frame-pointer")
+  set (CMAKE_CXX_FLAGS "-g -fsanitize=thread -fno-omit-frame-pointer")
+  
diff --git a/src/demo/indexfiles/main.cpp b/src/demo/indexfiles/main.cpp
index e6911f4..72070ea 100644
--- a/src/demo/indexfiles/main.cpp
+++ b/src/demo/indexfiles/main.cpp
@@ -20,9 +20,27 @@
 
 using namespace Lucene;
 
-int32_t docNumber = 0;
 
-DocumentPtr fileDocument(const String& docFile) {
+static void doSearching(const IndexReaderPtr &reader){
+	String field = L"contents";
+	String line = L"lucene";
+	
+        SearcherPtr searcher = newLucene<IndexSearcher>(reader);
+        AnalyzerPtr analyzer = newLucene<StandardAnalyzer>(LuceneVersion::LUCENE_CURRENT);
+        QueryParserPtr parser = newLucene<QueryParser>(LuceneVersion::LUCENE_CURRENT, field, analyzer);
+
+	//ReaderPtr in = newLucene<FileReader>("lucene");
+
+	QueryPtr query = parser->parse(line);
+	std::wcout << L"Searching for: " << query->toString(field) << L"\n";
+
+	searcher->search(query, FilterPtr(), 100);
+}
+
+
+static std::atomic<int32_t> docNumber = {};
+
+static DocumentPtr fileDocument(const String& docFile) {
     DocumentPtr doc = newLucene<Document>();
 
     // Add the path of the file as a field named "path".  Use a field that is indexed (ie. searchable), but
@@ -34,6 +52,14 @@ DocumentPtr fileDocument(const String& docFile) {
     doc->add(newLucene<Field>(L"modified", DateTools::timeToString(FileUtils::fileModified(docFile), DateTools::RESOLUTION_MINUTE),
                               Field::STORE_YES, Field::INDEX_NOT_ANALYZED));
 
+    Lucene::NumericFieldPtr field = Lucene::newLucene<Lucene::NumericField>(L"modified_number",
+									    Lucene::Field::STORE_YES,
+									    Lucene::Field::INDEX_NOT_ANALYZED);
+
+    field->setLongValue(FileUtils::fileModified(docFile));
+    
+    doc->add(field);
+
     // Add the contents of the file to a field named "contents".  Specify a Reader, so that the text of the file is
     // tokenized and indexed, but not stored.  Note that FileReader expects the file to be in the system's default
     // encoding.  If that's not the case searching for special characters will fail.
@@ -42,25 +68,38 @@ DocumentPtr fileDocument(const String& docFile) {
     return doc;
 }
 
-void indexDocs(const IndexWriterPtr& writer, const String& sourceDir) {
+static void indexDocs(const IndexWriterPtr& writer, const String& sourceDir, const IndexReaderPtr &reader) {
     HashSet<String> dirList(HashSet<String>::newInstance());
     if (!FileUtils::listDirectory(sourceDir, false, dirList)) {
         return;
     }
 
+    std::vector<std::thread> threads;
+    
     for (HashSet<String>::iterator dirFile = dirList.begin(); dirFile != dirList.end(); ++dirFile) {
-        String docFile(FileUtils::joinPath(sourceDir, *dirFile));
-        if (FileUtils::isDirectory(docFile)) {
-            indexDocs(writer, docFile);
-        } else {
-            std::wcout << L"Adding [" << ++docNumber << L"]: " << *dirFile << L"\n";
-
-            try {
-                writer->addDocument(fileDocument(docFile));
-            } catch (FileNotFoundException&) {
-            }
-        }
+	    auto theDirFile = *dirFile;
+	    threads.push_back(std::thread([writer, sourceDir, theDirFile, reader](){
+						  String docFile(FileUtils::joinPath(sourceDir, theDirFile));
+						  if (FileUtils::isDirectory(docFile)) {
+							  indexDocs(writer, docFile, reader);
+						  } else {
+							  std::wcout << L"Adding [" << ++docNumber << L"]: " << theDirFile << L"\n";
+							  
+							  
+							  try {
+								  writer->addDocument(fileDocument(docFile));
+							  } catch (FileNotFoundException&) {
+							  }
+
+						  }
+
+						  doSearching(reader);
+					  }));
     }
+	    
+
+    for(auto &thread : threads)
+	    thread.join();
 }
 
 /// Index all text files under a directory.
@@ -69,7 +108,8 @@ int main(int argc, char* argv[]) {
         std::wcout << L"Usage: indexfiles.exe <index source dir> <lucene index dir>\n";
         return 1;
     }
-
+    //argv[50000] = (char*)"aiai";
+    
     String sourceDir(StringUtils::toUnicode(argv[1]));
     String indexDir(StringUtils::toUnicode(argv[2]));
 
@@ -88,10 +128,12 @@ int main(int argc, char* argv[]) {
     uint64_t beginIndex = MiscUtils::currentTimeMillis();
 
     try {
-        IndexWriterPtr writer = newLucene<IndexWriter>(FSDirectory::open(indexDir), newLucene<StandardAnalyzer>(LuceneVersion::LUCENE_CURRENT), true, IndexWriter::MaxFieldLengthLIMITED);
-        std::wcout << L"Indexing to directory: " << indexDir << L"...\n";
+	    IndexWriterPtr writer = newLucene<IndexWriter>(FSDirectory::open(indexDir), newLucene<StandardAnalyzer>(LuceneVersion::LUCENE_CURRENT), true, IndexWriter::MaxFieldLengthLIMITED);
+	    IndexReaderPtr reader = IndexReader::open(FSDirectory::open(indexDir), true);
+	    
+	    std::wcout << L"Indexing to directory: " << indexDir << L"...\n";
 
-        indexDocs(writer, sourceDir);
+	    indexDocs(writer, sourceDir, reader);
 
         uint64_t endIndex = MiscUtils::currentTimeMillis();
         uint64_t indexDuration = endIndex - beginIndex;
@@ -103,6 +145,8 @@ int main(int argc, char* argv[]) {
         uint64_t optimizeDuration = MiscUtils::currentTimeMillis() - endIndex;
         std::wcout << L"Optimize time: " << optimizeDuration << L" milliseconds\n";
 
+	reader->close();
+	
         writer->close();
 
         std::wcout << L"Total time: " << indexDuration + optimizeDuration << L" milliseconds\n";