/// <summary> /// Tries to acquire write lock for a given transaction. If /// <CODE>this.writeCount</CODE> is greater than the currents tx's write /// count or the read count is greater than the currents tx's read count the /// transaction has to wait and the <seealso cref="RagManager.checkWaitOn"/> method is /// invoked for deadlock detection. /// <p/> /// If the lock can be acquires the lock count is updated on <CODE>this</CODE> /// and the transaction lock element (tle). /// Waiting for a lock can also be terminated. In that case waiting thread will be interrupted and corresponding /// <seealso cref="org.neo4j.kernel.impl.locking.community.RWLock.TxLockElement"/> will be marked as terminated. /// In that case lock will not be acquired and false will be return as result of acquisition /// </summary> /// <returns> true is lock was acquired, false otherwise </returns> /// <exception cref="DeadlockDetectedException"> if a deadlock is detected </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: synchronized boolean acquireWriteLock(org.neo4j.storageengine.api.lock.LockTracer tracer, Object tx) throws org.neo4j.kernel.DeadlockDetectedException internal virtual bool AcquireWriteLock(LockTracer tracer, object tx) { lock (this) { TxLockElement tle = GetOrCreateLockElement(tx); LockRequest lockRequest = null; LockWaitEvent waitEvent = null; // used to track do we need to add lock request to a waiting queue or we still have it there bool addLockRequest = true; try { tle.IncrementRequests(); Thread currentThread = currentThread(); long lockAcquisitionTimeBoundary = _clock.millis() + _lockAcquisitionTimeoutMillis; while (!tle.Terminated && (_totalWriteCount > tle.WriteCount || _totalReadCount > tle.ReadCount)) { AssertNotExpired(lockAcquisitionTimeBoundary); _ragManager.checkWaitOn(this, tx); if (addLockRequest) { lockRequest = new LockRequest(tle, WRITE, currentThread); _waitingThreadList.AddFirst(lockRequest); } if (waitEvent == null) { waitEvent = tracer.WaitForLock(true, _resource.type(), _resource.resourceId()); } addLockRequest = WaitUninterruptedly(lockAcquisitionTimeBoundary); _ragManager.stopWaitOn(this, tx); } if (!tle.Terminated) { RegisterWriteLockAcquired(tx, tle); return(true); } else { // in case if lock element was interrupted and it was never register before // we need to clean it from lock element map // if it was register before it will be cleaned up during standard lock release call if (tle.Requests == 1 && tle.Free) { _txLockElementMap.Remove(tx); } return(false); } } finally { if (waitEvent != null) { waitEvent.Close(); } CleanupWaitingListRequests(lockRequest, tle, addLockRequest); // for cases when spurious wake up was the reason why we waked up, but also there // was an interruption as described at 17.2 just clearing interruption flag interrupted(); // if deadlocked, remove marking so lock is removed when empty tle.DecrementRequests(); Unmark(); } } }