Apache
/
lucene
mirror of https://github.com/apache/lucene.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SOLR-1108 -- Remove un-needed synchronization in SolrCore constructor 

git-svn-id: https://svn.apache.org/repos/asf/lucene/solr/trunk@767430 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Shalin Shekhar Mangar 2009-04-22 09:25:10 +00:00
parent 1ea1e3ca37
commit 742731754d
2 changed files with 83 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGES.txt
View File

@ -234,6 +234,9 @@ Optimizations
8. SOLR-973: CommonsHttpSolrServer writes the xml directly to the server. 8. SOLR-973: CommonsHttpSolrServer writes the xml directly to the server.
(Noble Paul via shalin) (Noble Paul via shalin)
9. SOLR-1108: Remove un-needed synchronization in SolrCore constructor.
(Noble Paul via shalin)
Bug Fixes Bug Fixes
---------------------- ----------------------
1. SOLR-774: Fixed logging level display (Sean Timm via Otis Gospodnetic) 1. SOLR-774: Fixed logging level display (Sean Timm via Otis Gospodnetic)

163
src/java/org/apache/solr/core/SolrCore.java
View File

@ -354,12 +354,14 @@ public final class SolrCore implements SolrInfoMBean {
// protect via synchronized(SolrCore.class) // protect via synchronized(SolrCore.class)
private static Set<String> dirs = new HashSet<String>(); private static Set<String> dirs = new HashSet<String>();
// currently only called with SolrCore.class lock held
void initIndex() { void initIndex() {
try { try {
File dirFile = new File(getNewIndexDir()); File dirFile = new File(getNewIndexDir());
boolean indexExists = dirFile.canRead(); boolean indexExists = dirFile.canRead();
boolean firstTime = dirs.add(dirFile.getCanonicalPath()); boolean firstTime;
synchronized (SolrCore.class) {
firstTime = dirs.add(dirFile.getCanonicalPath());
}
boolean removeLocks = solrConfig.getBool("mainIndex/unlockOnStartup", false); boolean removeLocks = solrConfig.getBool("mainIndex/unlockOnStartup", false);
initDirectoryFactory(); initDirectoryFactory();
@ -483,100 +485,95 @@ public final class SolrCore implements SolrInfoMBean {
*@since solr 1.3 *@since solr 1.3
*/ */
public SolrCore(String name, String dataDir, SolrConfig config, IndexSchema schema, CoreDescriptor cd) { public SolrCore(String name, String dataDir, SolrConfig config, IndexSchema schema, CoreDescriptor cd) {
synchronized (SolrCore.class) { coreDescriptor = cd;
coreDescriptor = cd; this.setName( name );
// this is for backward compatibility (and also the reason SolrResourceLoader loader = config.getResourceLoader();
// the sync block is needed) if (dataDir == null)
instance = this; // set singleton dataDir = config.get("dataDir",cd.getDataDir());
this.setName( name );
SolrResourceLoader loader = config.getResourceLoader();
if (dataDir == null)
dataDir = config.get("dataDir",cd.getDataDir());
dataDir = SolrResourceLoader.normalizeDir(dataDir); dataDir = SolrResourceLoader.normalizeDir(dataDir);
log.info(logid+"Opening new SolrCore at " + loader.getInstanceDir() + ", dataDir="+dataDir); log.info(logid+"Opening new SolrCore at " + loader.getInstanceDir() + ", dataDir="+dataDir);
if (schema==null) { if (schema==null) {
schema = new IndexSchema(config, IndexSchema.DEFAULT_SCHEMA_FILE, null); schema = new IndexSchema(config, IndexSchema.DEFAULT_SCHEMA_FILE, null);
} }
//Initialize JMX
if (config.jmxConfig.enabled) {
infoRegistry = new JmxMonitoredMap<String, SolrInfoMBean>(name, config.jmxConfig);
} else {
log.info("JMX monitoring not detected for core: " + name);
infoRegistry = new ConcurrentHashMap<String, SolrInfoMBean>();
}
this.schema = schema; //Initialize JMX
this.dataDir = dataDir; if (config.jmxConfig.enabled) {
this.solrConfig = config; infoRegistry = new JmxMonitoredMap<String, SolrInfoMBean>(name, config.jmxConfig);
this.startTime = System.currentTimeMillis(); } else {
this.maxWarmingSearchers = config.getInt("query/maxWarmingSearchers",Integer.MAX_VALUE); log.info("JMX monitoring not detected for core: " + name);
infoRegistry = new ConcurrentHashMap<String, SolrInfoMBean>();
}
booleanQueryMaxClauseCount(); this.schema = schema;
this.dataDir = dataDir;
this.solrConfig = config;
this.startTime = System.currentTimeMillis();
this.maxWarmingSearchers = config.getInt("query/maxWarmingSearchers",Integer.MAX_VALUE);
booleanQueryMaxClauseCount();
parseListeners(); parseListeners();
initDeletionPolicy(); initDeletionPolicy();
initIndex(); initIndex();
initWriters();
initQParsers();
initValueSourceParsers();
this.searchComponents = loadSearchComponents( config );
// Processors initialized before the handlers initWriters();
updateProcessorChains = loadUpdateProcessorChains(); initQParsers();
reqHandlers = new RequestHandlers(this); initValueSourceParsers();
reqHandlers.initHandlersFromConfig( solrConfig );
this.searchComponents = loadSearchComponents( config );
// Processors initialized before the handlers
updateProcessorChains = loadUpdateProcessorChains();
reqHandlers = new RequestHandlers(this);
reqHandlers.initHandlersFromConfig( solrConfig );
highlighter = createHighlighter( highlighter = createHighlighter(
solrConfig.get("highlighting/@class", DefaultSolrHighlighter.class.getName()) solrConfig.get("highlighting/@class", DefaultSolrHighlighter.class.getName())
);
highlighter.initalize( solrConfig );
// Handle things that should eventually go away
initDeprecatedSupport();
final CountDownLatch latch = new CountDownLatch(1);
try {
// cause the executor to stall so firstSearcher events won't fire
// until after inform() has been called for all components.
// searchExecutor must be single-threaded for this to work
searcherExecutor.submit(new Callable() {
public Object call() throws Exception {
latch.await();
return null;
}
});
// Open the searcher *before* the update handler so we don't end up opening
// one in the middle.
// With lockless commits in Lucene now, this probably shouldn't be an issue anymore
getSearcher(false,false,null);
updateHandler = createUpdateHandler(
solrConfig.get("updateHandler/@class", DirectUpdateHandler2.class.getName())
); );
highlighter.initalize( solrConfig );
// Handle things that should eventually go away
initDeprecatedSupport();
final CountDownLatch latch = new CountDownLatch(1); infoRegistry.put("updateHandler", updateHandler);
try { // Finally tell anyone who wants to know
// cause the executor to stall so firstSearcher events won't fire loader.inform( loader );
// until after inform() has been called for all components. loader.inform( this );
// searchExecutor must be single-threaded for this to work instance = this; // set singleton for backwards compatibility
searcherExecutor.submit(new Callable() { } catch (IOException e) {
public Object call() throws Exception { throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, e);
latch.await(); } finally {
return null; // allow firstSearcher events to fire
} latch.countDown();
}); }
// Open the searcher *before* the update handler so we don't end up opening
// one in the middle.
// With lockless commits in Lucene now, this probably shouldn't be an issue anymore
getSearcher(false,false,null);
updateHandler = createUpdateHandler(
solrConfig.get("updateHandler/@class", DirectUpdateHandler2.class.getName())
);
infoRegistry.put("updateHandler", updateHandler);
// Finally tell anyone who wants to know
loader.inform( loader );
loader.inform( this );
} catch (IOException e) {
throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, e);
} finally {
// allow firstSearcher events to fire
latch.countDown();
}
} // end synchronized
infoRegistry.put("core", this); infoRegistry.put("core", this);
} }