public void report() {
        // Once we are here, the project lock is held. If we synchronize to avoid cross-project operations, we will have a dead lock.
        getWorkerLeaseService().runAsIsolatedTask(() -> {
            // Output reports per execution, not mixed.
            // Cross-project ModelRegistry operations do not happen concurrently.
            synchronized (DependentComponentsReport.class) {

      this.delegate = checkNotNull(delegate);
    }

    @Override
    @ParametricNullness
    public T get() {
      // A 2-field variant of Double Checked Locking.
      if (!initialized) {
        synchronized (this) {
          if (!initialized) {
            T t = delegate.get();
            value = t;
            initialized = true;
            return t;
          }
        }
      }

            }
        }
        return formatValue(value) + " " + units.format(value);
    }

    private static String formatValue(BigDecimal value) {
        synchronized (DECIMAL_FORMAT) {
            return DECIMAL_FORMAT.format(value);
        }
    }

    /**
     * Converts this amount to an equivalent amount in the specified units.
     *

            synchronized (currentStream) {
                currentStream.println();
                currentStream.notifyAll();
            }
        }

        @Override
        public void print(char c) {
            final PrintStream currentStream = getOutputStreamForCurrentThread();
            synchronized (currentStream) {
                currentStream.print(c);

</p>

<p>
The <i>synchronized before</i> relation is a partial order on synchronizing memory operations,
derived from <i>W</i>.
If a synchronizing read-like memory operation <i>r</i>
observes a synchronizing write-like memory operation <i>w</i>
(that is, if <i>W</i>(<i>r</i>) = <i>w</i>),
then <i>w</i> is synchronized before <i>r</i>.
Informally, the synchronized before relation is a subset of the implied total order

removeListener(TestListener); private synchronized java.util.List cloneListeners(); public void endTest(Test); public synchronized int errorCount(); public synchronized java.util.Enumeration errors(); public synchronized int failureCount(); public synchronized java.util.Enumeration failures(); protected void run(TestCase); public synchronized int runCount(); public void runProtected(Test, Protectable); public synchronized boolean shouldStop(); public void startTest(Test); public synchronized void stop(); public synchronized...

        then:
        thrown(IllegalArgumentException)
    }

    def "synchronized configurations reflect changes in property values"() {
        def mutableCacheConfigurations = TestUtil.objectFactory().newInstance(DefaultCacheConfigurations, Mock(LegacyCacheCleanupEnablement))

        when:
        cacheConfigurations.synchronize(mutableCacheConfigurations)

        and:
        def twoDaysAgo = daysAgo(2).get()

strapMainStarter.class package org.gradle.wrapper; public synchronized class BootstrapMainStarter { public void BootstrapMainStarter(); public void start(String[], java.io.File) throws Exception; static java.io.File findLauncherJar(java.io.File); } org/gradle/wrapper/Download$1.class package org.gradle.wrapper; synchronized class Download$1 { } org/gradle/wrapper/Download$DefaultDownloadProgr.class package org.gradle.wrapper; synchronized class Download$DefaultDownloadProgr implements DownloadProgressList...

        uqList.addAll(urlQueueList);
        urlQueueMap.put(sessionId, uqList);
    }

    public synchronized void removeUrlQueueList(final String sessionId) {
        urlQueueMap.remove(sessionId);
    }

    public synchronized void clearUrlQueueList() {
        urlQueueMap.clear();
    }

    public synchronized Map<String, AccessResultImpl<Long>> getAccessResultMap(final String sessionId) {

        }
    }

    @Override
    public synchronized Object setProperty(String key, String value) {
        return writeOperation(p -> p.setProperty(key, value));
    }

    @Override
    public synchronized Object put(Object key, Object value) {
        return writeOperation(p -> p.put(key, value));
    }

    @Override
    public synchronized Object remove(Object key) {