lucene-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scottga...@apache.org
Subject cvs commit: jakarta-lucene/src/java/org/apache/lucene/store Lock.java
Date Tue, 12 Aug 2003 15:05:03 GMT
scottganyo    2003/08/12 08:05:03

  Modified:    src/java/org/apache/lucene/index IndexReader.java
                        IndexWriter.java SegmentReader.java
               src/java/org/apache/lucene/store Lock.java
  Log:
  added ability to wait on any Lock. changed write.lock wait to 1 sec from none.
  
  Revision  Changes    Path
  1.17      +3 -3      jakarta-lucene/src/java/org/apache/lucene/index/IndexReader.java
  
  Index: IndexReader.java
  ===================================================================
  RCS file: /home/cvs/jakarta-lucene/src/java/org/apache/lucene/index/IndexReader.java,v
  retrieving revision 1.16
  retrieving revision 1.17
  diff -u -r1.16 -r1.17
  --- IndexReader.java	1 May 2003 19:50:17 -0000	1.16
  +++ IndexReader.java	12 Aug 2003 15:05:03 -0000	1.17
  @@ -100,7 +100,7 @@
     /** Returns an IndexReader reading the index in the given Directory. */
     public static IndexReader open(final Directory directory) throws IOException{
       synchronized (directory) {			  // in- & inter-process sync
  -      return (IndexReader)new Lock.With(directory.makeLock("commit.lock")) {
  +      return (IndexReader)new Lock.With(directory.makeLock("commit.lock"), IndexWriter.COMMIT_LOCK_TIMEOUT)
{
   	  public Object doBody() throws IOException {
   	    SegmentInfos infos = new SegmentInfos();
   	    infos.read(directory);
  @@ -255,7 +255,7 @@
     public final synchronized void delete(int docNum) throws IOException {
       if (writeLock == null) {
         Lock writeLock = directory.makeLock("write.lock");
  -      if (!writeLock.obtain())			  // obtain write lock
  +      if (!writeLock.obtain(IndexWriter.WRITE_LOCK_TIMEOUT)) // obtain write lock
           throw new IOException("Index locked for write: " + writeLock);
         this.writeLock = writeLock;
       }
  @@ -338,7 +338,7 @@
         return
           directory.makeLock("write.lock").isLocked() ||
           directory.makeLock("commit.lock").isLocked();
  -        
  +
       }
   
     /**
  
  
  
  1.14      +7 -4      jakarta-lucene/src/java/org/apache/lucene/index/IndexWriter.java
  
  Index: IndexWriter.java
  ===================================================================
  RCS file: /home/cvs/jakarta-lucene/src/java/org/apache/lucene/index/IndexWriter.java,v
  retrieving revision 1.13
  retrieving revision 1.14
  diff -u -r1.13 -r1.14
  --- IndexWriter.java	11 Jul 2003 22:13:13 -0000	1.13
  +++ IndexWriter.java	12 Aug 2003 15:05:03 -0000	1.14
  @@ -87,6 +87,9 @@
     */
   
   public class IndexWriter {
  +  public static long WRITE_LOCK_TIMEOUT = 1000;
  +  public static long COMMIT_LOCK_TIMEOUT = 10000;
  +  
     private Directory directory;			  // where this index resides
     private Analyzer analyzer;			  // how to analyze text
   
  @@ -97,7 +100,7 @@
   
     private Lock writeLock;
   
  -  /** Expert: Set the Similarity implementation used by this IndexWriter.
  +    /** Expert: Set the Similarity implementation used by this IndexWriter.
      *
      * @see Similarity#setDefault(Similarity)
      */
  @@ -141,12 +144,12 @@
       analyzer = a;
   
       Lock writeLock = directory.makeLock("write.lock");
  -    if (!writeLock.obtain())                      // obtain write lock
  +    if (!writeLock.obtain(WRITE_LOCK_TIMEOUT)) // obtain write lock
         throw new IOException("Index locked for write: " + writeLock);
       this.writeLock = writeLock;                   // save it
   
       synchronized (directory) {			  // in- & inter-process sync
  -      new Lock.With(directory.makeLock("commit.lock")) {
  +      new Lock.With(directory.makeLock("commit.lock"), COMMIT_LOCK_TIMEOUT) {
   	  public Object doBody() throws IOException {
   	    if (create)
   	      segmentInfos.write(directory);
  @@ -365,7 +368,7 @@
   					    directory));
   
       synchronized (directory) {			  // in- & inter-process sync
  -      new Lock.With(directory.makeLock("commit.lock")) {
  +      new Lock.With(directory.makeLock("commit.lock"), COMMIT_LOCK_TIMEOUT) {
   	  public Object doBody() throws IOException {
   	    segmentInfos.write(directory);	  // commit before deleting
   	    deleteSegments(segmentsToDelete);	  // delete now-unused segments
  
  
  
  1.10      +1 -1      jakarta-lucene/src/java/org/apache/lucene/index/SegmentReader.java
  
  Index: SegmentReader.java
  ===================================================================
  RCS file: /home/cvs/jakarta-lucene/src/java/org/apache/lucene/index/SegmentReader.java,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- SegmentReader.java	12 Aug 2003 09:17:53 -0000	1.9
  +++ SegmentReader.java	12 Aug 2003 15:05:03 -0000	1.10
  @@ -119,7 +119,7 @@
     final synchronized void doClose() throws IOException {
       if (deletedDocsDirty) {
         synchronized (directory) {		  // in- & inter-process sync
  -	new Lock.With(directory.makeLock("commit.lock")) {
  +	new Lock.With(directory.makeLock("commit.lock"), IndexWriter.COMMIT_LOCK_TIMEOUT) {
   	    public Object doBody() throws IOException {
   	      deletedDocs.write(directory, segment + ".tmp");
   	      directory.renameFile(segment + ".tmp", segment + ".del");
  
  
  
  1.4       +50 -25    jakarta-lucene/src/java/org/apache/lucene/store/Lock.java
  
  Index: Lock.java
  ===================================================================
  RCS file: /home/cvs/jakarta-lucene/src/java/org/apache/lucene/store/Lock.java,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- Lock.java	1 May 2003 19:50:17 -0000	1.3
  +++ Lock.java	12 Aug 2003 15:05:03 -0000	1.4
  @@ -54,6 +54,8 @@
    * <http://www.apache.org/>.
    */
   
  +import org.apache.lucene.index.IndexWriter;
  +
   import java.io.IOException;
   
   /** An interprocess mutex lock.
  @@ -70,12 +72,39 @@
   */
   
   public abstract class Lock {
  -  /** Attempt to obtain exclusive access.
  -   *
  +    public static long LOCK_POLL_INTERVAL = 1000;
  +
  +  /** Attempt to obtain exclusive access and immediately return
  +   *  upon success or failure.
      * @return true iff exclusive access is obtained
      */
     public abstract boolean obtain() throws IOException;
   
  +  /** Attempt to obtain an exclusive lock within amount
  +   *  of time given. Currently polls once per second until
  +   *  lockWaitTimeout is passed.
  +   * @param lockWaitTimeout length of time to wait in ms
  +   * @return true if lock was obtained
  +   * @throws IOException if lock wait times out or obtain() throws an IOException
  +   */
  +  public boolean obtain(long lockWaitTimeout) throws IOException {
  +     boolean locked = obtain();
  +     int maxSleepCount = (int)(lockWaitTimeout / LOCK_POLL_INTERVAL);
  +     int sleepCount = 0;
  +     while (!locked) {
  +         if (++sleepCount == maxSleepCount) {
  +             throw new IOException("Lock obtain timed out");
  +         }
  +         try {
  +             Thread.sleep(LOCK_POLL_INTERVAL);
  +         } catch (InterruptedException e) {
  +             throw new IOException(e.toString());
  +         }
  +         locked = obtain();
  +     }
  +     return locked;
  +  }
  +
     /** Release exclusive access. */
     public abstract void release();
   
  @@ -87,12 +116,21 @@
     /** Utility class for executing code with exclusive access. */
     public abstract static class With {
       private Lock lock;
  -    private int sleepInterval = 1000;
  -    private int maxSleeps = 10;
  -    
  +    private long lockWaitTimeout;
  +
  +      /** Constructs an executor that will grab the named lock.
  +       *  Defaults lockWaitTimeout to Lock.COMMIT_LOCK_TIMEOUT.
  +       *  @deprecated Kept only to avoid breaking existing code.
  +       */
  +      public With(Lock lock)
  +      {
  +          this(lock, IndexWriter.COMMIT_LOCK_TIMEOUT);
  +      }
  +
       /** Constructs an executor that will grab the named lock. */
  -    public With(Lock lock) {
  +    public With(Lock lock, long lockWaitTimeout) {
         this.lock = lock;
  +      this.lockWaitTimeout = lockWaitTimeout;
       }
   
       /** Code to execute with exclusive access. */
  @@ -100,29 +138,16 @@
   
       /** Calls {@link #doBody} while <i>lock</i> is obtained.  Blocks if lock
        * cannot be obtained immediately.  Retries to obtain lock once per second
  -     * until it is obtained, or until it has tried ten times. */
  +     * until it is obtained, or until it has tried ten times. Lock is released when
  +     * {@link #doBody} exits. */
       public Object run() throws IOException {
         boolean locked = false;
         try {
  -	locked = lock.obtain();
  -	int sleepCount = 0;
  -	while (!locked) {
  -	  if (++sleepCount == maxSleeps) {
  -	    throw new IOException("Timed out waiting for: " + lock);
  -	  }
  -	  try {
  -	    Thread.sleep(sleepInterval);
  -	  } catch (InterruptedException e) {
  -	    throw new IOException(e.toString());
  -	  }
  -	  locked = lock.obtain();
  -	}
  -
  -	return doBody();
  -	
  +         locked = lock.obtain(lockWaitTimeout);
  +         return doBody();
         } finally {
  -	if (locked)
  -	  lock.release();
  +        if (locked)
  +	      lock.release();
         }
       }
     }
  
  
  

Mime
View raw message