}
        }
    }

    @Override
    public void addMemoryHolder(MemoryHolder holder) {
        synchronized (holdersLock) {
            holders.add(holder);
        }
    }

    @Override
    public void removeMemoryHolder(MemoryHolder holder) {
        synchronized (holdersLock) {
            holders.remove(holder);
        }
    }

    @Override

            synchronized (this) {
                return action.get();
            }
        }

        @Override
        public void useCache(Runnable action) {
            assertNotClosed();
            // The contract of useCache() means we have to provide some basic synchronization.
            synchronized (this) {
                action.run();
            }

     *
     * @param propertyName The name of the property to set
     * @param value The value to temporarily set the property to
     * @param factory Instance created by the Factory implementation
     */
    public synchronized <T> T withSystemProperty(String propertyName, String value, Factory<T> factory) {
        String originalValue = overrideProperty(propertyName, value);

        try {
            return factory.create();

      synchronized (state) {
        if (state.seenExceptions == expect) {
          state.seenExceptions = update;
        }
      }
    }

    @Override
    int decrementAndGetRemainingCount(AggregateFutureState<?> state) {
      synchronized (state) {
        return --state.remaining;
      }
    }
  }

    private final Map<TransferResourceIdentifier, TransferResourceAndSize> transfers = new LinkedHashMap<>();
    private final FileSizeFormat format = new FileSizeFormat(); // use in a synchronized fashion
    private final StringBuilder buffer = new StringBuilder(128); // use in a synchronized fashion

    private final boolean printResourceNames;
    private int lastLength;

    public ConsoleMavenTransferListener(

      synchronized (state) {
        if (state.seenExceptions == expect) {
          state.seenExceptions = update;
        }
      }
    }

    @Override
    int decrementAndGetRemainingCount(AggregateFutureState<?> state) {
      synchronized (state) {
        return --state.remaining;
      }
    }
  }

            return false;
        }
    }

    @Override
    public List<? extends Throwable> getCauses() {
        return causes;
    }

    @Override
    public synchronized Throwable initCause(Throwable throwable) {
        causes.clear();
        causes.add(throwable);
        return null;
    }

    public void initCauses(Iterable<? extends Throwable> causes) {

        return gradleInstallation;
    }

    @Nullable // if no installation can be located
    public static GradleInstallation get() {
        return locate().getInstallation();
    }

    public synchronized static CurrentGradleInstallation locate() {
        if (instance == null) {
            instance = CurrentGradleInstallationLocator.locate();
        }
        return instance;
    }

    }

    public DefaultMultiCauseExceptionNoStackTrace(Factory<String> messageFactory, Iterable<? extends Throwable> causes) {
        super(messageFactory, causes);
    }

    @Override
    public synchronized Throwable fillInStackTrace() {
        return this;
    }

  if (!status.ok()) {
    done(status);
    return;
  }
  if (auto st = stream_->BlockHostUntilDone(); !st.ok()) {
    done_event_.SetError(absl::InternalError(absl::StrFormat(
        "failed to synchronize send operation with a stream: %s",
        st.ToString())));
    return;
  }

  done_event_.SetStateConcrete();
  done(absl::OkStatus());
}