// TODO Replace the use of this with synchronized caches from Guava
@NonNullApi
public class Synchronizer {

    private final Lock lock = new ReentrantLock();

    public <T> T synchronize(Supplier<T> factory) {
        lock.lock();
        try {
            return factory.get();
        } finally {
            lock.unlock();
        }
    }

    public void synchronize(Runnable operation) {
        lock.lock();

    final private Synchronizer synchronizer = new Synchronizer();
    final private Cache<K, V> cache;

    public CacheAccessSerializer(Cache<K, V> cache) {
        this.cache = cache;
    }

    @Override
    public V get(final K key, final Function<? super K, ? extends V> factory) {
        return synchronizer.synchronize(() -> cache.get(key, factory));
    }

    @Override

            action.run();
        } else {
            withLocks(Collections.singletonList(workerLeaseLockRegistry.newUnmanagedLease()), action);
        }
    }

    @Override
    public Synchronizer newResource() {
        return new DefaultSynchronizer(this);
    }

    @Override
    public void stop() {
        coordinationService.withStateLock(new Runnable() {
            @Override

	if race.Enabled {
		if delta < 0 {
			// Synchronize decrements with Wait.
			race.ReleaseMerge(unsafe.Pointer(wg))
		}
		race.Disable()
		defer race.Enable()
	}
	state := wg.state.Add(uint64(delta) << 32)
	v := int32(state >> 32)
	w := uint32(state)
	if race.Enabled && delta > 0 && v == int32(delta) {
		// The first increment must be synchronized with Wait.
		// Need to model this as a read, because there can be

) : Closeable {
    override fun close() {
        // we synchronize access to all resources used by callbacks
        // in case there was still an event being dispatched at closing time.
        synchronized(writeContext) {
            unsafeWrite(null)
            writeContext.close()
        }
    }

    fun write(value: T, trace: PropertyTrace? = null) {
        synchronized(writeContext) {
            withPropertyTrace(trace) {

	// the acquire in profBuf.read synchronizes with *all* prior
	// setProfLabel operations, not just the most recent one. This
	// is important because profBuf.read will observe different
	// labels set by different setProfLabel operations on
	// different goroutines, so it needs to synchronize with all
	// of them (this wouldn't be an issue if we could synchronize
	// on &getg().labels since we would synchronize with each

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Supplier;

/**
 * Synchronizes access to some resource, by making sure that 2 threads do not try to produce it at the same time.
 * The resource to be accessed is represented by a key, and the factory is whatever needs to be done to produce it.

//
// In the terminology of [the Go memory model],
// the n'th call to [RWMutex.Unlock] “synchronizes before” the m'th call to Lock
// for any n < m, just as for [Mutex].
// For any call to RLock, there exists an n such that
// the n'th call to Unlock “synchronizes before” that call to RLock,
// and the corresponding call to [RWMutex.RUnlock] “synchronizes before”
// the n+1'th call to Lock.
//
// [the Go memory model]: https://go.dev/ref/mem

        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()

    @Override
    public void println(boolean x) {
        PrintStream stream = getStream();
        synchronized (this) {
            stream.print(x);
            stream.print(lineSeparator);
        }
    }

    @Override
    public void println(char x) {
        PrintStream stream = getStream();
        synchronized (this) {
            stream.print(x);
            stream.print(lineSeparator);
        }
    }