private ReentrantLock lockA;
  private ReentrantLock lockB;
  private ReentrantLock lockC;
  private ReentrantReadWriteLock.ReadLock readLockA;
  private ReentrantReadWriteLock.ReadLock readLockB;
  private ReentrantReadWriteLock.ReadLock readLockC;
  private ReentrantReadWriteLock.WriteLock writeLockA;
  private ReentrantReadWriteLock.WriteLock writeLockB;
  private ReentrantReadWriteLock.WriteLock writeLockC;

  private ReentrantLock lockA;
  private ReentrantLock lockB;
  private ReentrantLock lockC;
  private ReentrantReadWriteLock.ReadLock readLockA;
  private ReentrantReadWriteLock.ReadLock readLockB;
  private ReentrantReadWriteLock.ReadLock readLockC;
  private ReentrantReadWriteLock.WriteLock writeLockA;
  private ReentrantReadWriteLock.WriteLock writeLockB;
  private ReentrantReadWriteLock.WriteLock writeLockC;

      super(fair);
      this.readLock = new CycleDetectingReentrantReadLock(this);
      this.writeLock = new CycleDetectingReentrantWriteLock(this);
      this.lockGraphNode = Preconditions.checkNotNull(lockGraphNode);
    }

    ///// Overridden ReentrantReadWriteLock methods. /////

    @Override
    public ReadLock readLock() {
      return readLock;
    }

    @Override

    private final ReadWriteLock delegate;

    WeakSafeReadWriteLock() {
      this.delegate = new ReentrantReadWriteLock();
    }

    @Override
    public Lock readLock() {
      return new WeakSafeLock(delegate.readLock(), this);
    }

    @Override
    public Lock writeLock() {
      return new WeakSafeLock(delegate.writeLock(), this);
    }
  }

		defer dm.m.Unlock()

		// Check if minimally a single bool is set in the writeLocks array
		lockFound := slices.ContainsFunc(dm.readLocks, isLocked)
		if !lockFound {
			panic("Trying to RUnlock() while no RLock() is active")
		}

		// Copy write locks to stack array
		copy(locks, dm.readLocks)
	}

	// Tolerance is not set, defaults to half of the locker clients.
	tolerance := len(restClnts) / 2
	isReadLock := true

     *
     * @return list of child file info
     */
    public List<FileInfo> getChildren() {
        lock.readLock().lock();
        try {
            lastAccessTime = System.currentTimeMillis();
            return new ArrayList<>(children.values());
        } finally {
            lock.readLock().unlock();
        }
    }

    /**
     * Get a specific child
     *
     * @param name child name

     * @return the handle info or null if not found
     */
    public HandleInfo getHandleByGuid(HandleGuid guid) {
        lock.readLock().lock();
        try {
            return guidToHandle.get(guid);
        } finally {
            lock.readLock().unlock();
        }
    }

    /**
     * Get handle information by path
     * @param path the file path

    
    public List<FileInfo> getChildren() {
        lock.readLock().lock();
        try {
            lastAccessTime = System.currentTimeMillis();
            return new ArrayList<>(children.values());
        } finally {
            lock.readLock().unlock();
        }
    }
    
    public FileInfo getChild(String name) {
        lock.readLock().lock();
        try {

            mojos.put(Thread.currentThread(), mojoDescriptor);
            boolean aggregator = mojoDescriptor.isAggregator();
            acquiredAggregatorLock = aggregator ? aggregatorLock.writeLock() : aggregatorLock.readLock();
            acquiredProjectLock = getProjectLock(session);
            if (!acquiredAggregatorLock.tryLock()) {
                Thread owner = aggregatorLock.getOwner();

                }
                assertTrue(hasNonZero, "Each array should have a signature");
            }
        }

        @Test
        @DisplayName("Should handle high concurrency without deadlock")
        void testHighConcurrencyNoDeadlock() throws InterruptedException {
            int threadCount = 100;
            int operationsPerThread = 50;