I have a method which uses an index located in a specific directory.
public class TestSearchEngine implements SearchEngine<Tag> {
private static final String INDEX_PATH = "/test/index";
private Directory directory;
@Inject private TagDAO tagDAO;
private int organizationId;
@Override
public void add(Tag tag) {
IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35));
IndexWriter indexWriter = getIndexWriter(indexWriterConfig);
//Create document
Document document = new Document();
document.add(new Field("id", String.valueOf(tag.getId()), Field.Store.YES, Field.Index.NOT_ANALYZED));
document.add(new Field("title", tag.getTitle(), Field.Store.NO, Field.Index.ANALYZED));
try {
indexWriter.addDocument(document);
indexWriter.close();
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public synchronized void setDirectory(int organizationId) throws IOException {
this.organizationId = organizationId;
File path = new File(INDEX_PATH + "/" + String.valueOf(organizationId));
//If path does not exist, create it and create new index for organization
if(!path.exists()) {
path.mkdirs();
buildCompleteIndex(organizationId, false);
}
this.directory = FSDirectory.open(path); //Open directory
}
private void buildCompleteIndex(int organizationId, boolean rebuildDir) {
if(rebuildDir) {
File path = new File(INDEX_PATH + "/" + String.valueOf(organizationId));
try {
Utils.deleteDirectory(path);
} catch (IOException e) {
throw new LuceneIndexException("Error rebuilding index directory.", e);
}
path.mkdirs();
}
List<Tag> tagList = tagDAO.findAll(organizationId);
for(Tag tag : tagList) {
add(tag);
}
}
private IndexReader getIndexReader() {
try {
return IndexReader.open(directory);
} catch (CorruptIndexException e) {
buildCompleteIndex(organizationId, true);
} catch (IOException e) {
throw new LuceneIndexException("IOException prevented IndexReader from opening Index.", e);
} catch(NullPointerException e) {
throw new LuceneIndexException("Index resource not available.", e);
}
return null;
}
}
In certain situations I catch an exception if for whatever reason the index becomes corrupt, or it simply has been not been created yet. In that case, the buildCompleteIndex() method is called which deletes the directory and recreates the index from a datasource.
In a multi-threaded environment, how can I protect against another thread creating an instance of the class and using a method that calls the directory while its either deleted or being rebuilt? The setDirectory() method must be called before any of the other methods will work, so I assume setting synchronize on the method will solve this, but what if the directory becomes corrupt while threads are already in it, then they all start calling the rebuild method at the same time? In other words i’m a little confused about the proper way to go about deleting and updating IO Files in a multithreaded environment. Some advice would be appreciated.
Reviewing your code, you have synchronized on setDirectory(). For all threads that use that specific instance, it will block until that method completes. This includes buildCompleteIndex. If you have threads that create a new instance of this class, then you will need to sync against something else. For example, you could sync against a static instance.
Syncing on files and or folders can get really complicated especially if you’re running several environments (i.e. JDKs).
Something like the following might work if I’m understanding your problem: