Lock.cs

Go to the documentation of this file.

/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using Lucene.Net.Support;

namespace Lucene.Net.Store
{
    
    public abstract class Lock
    {
        
        public static long LOCK_POLL_INTERVAL = 1000;
        
        public const long LOCK_OBTAIN_WAIT_FOREVER = - 1;
        
        public abstract bool Obtain();
        
        protected internal System.Exception failureReason;
        
        public virtual bool Obtain(long lockWaitTimeout)
        {
            failureReason = null;
            bool locked = Obtain();
            if (lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER)
                throw new System.ArgumentException("lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number (got " + lockWaitTimeout + ")");
            
            long maxSleepCount = lockWaitTimeout / LOCK_POLL_INTERVAL;
            long sleepCount = 0;
            while (!locked)
            {
                if (lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER && sleepCount++ >= maxSleepCount)
                {
                    System.String reason = "Lock obtain timed out: " + this.ToString();
                    if (failureReason != null)
                    {
                        reason += (": " + failureReason);
                    }
                    var e = failureReason != null
                                ? new LockObtainFailedException(reason, failureReason)
                                : new LockObtainFailedException(reason);
                    throw e;
                }
                try
                {
                    System.Threading.Thread.Sleep(TimeSpan.FromMilliseconds(LOCK_POLL_INTERVAL));
                }
                catch (System.Threading.ThreadInterruptedException)
                {
                    throw;
                }
                locked = Obtain();
            }
            return locked;
        }
        
        public abstract void  Release();
        
        public abstract bool IsLocked();
        
        
        public abstract class With
        {
            private Lock lock_Renamed;
            private long lockWaitTimeout;
            
            
            protected With(Lock lock_Renamed, long lockWaitTimeout)
            {
                this.lock_Renamed = lock_Renamed;
                this.lockWaitTimeout = lockWaitTimeout;
            }
            
            protected internal abstract System.Object DoBody();
            
            public virtual System.Object run()
            {
                bool locked = false;
                try
                {
                    locked = lock_Renamed.Obtain(lockWaitTimeout);
                    return DoBody();
                }
                finally
                {
                    if (locked)
                        lock_Renamed.Release();
                }
            }
        }
    }
}