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

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.work;

import org.gradle.internal.Factory;

public interface Synchronizer {
    /**
     * Runs the given action while holding the associated resource lock, blocking until the lock can be acquired.
     *

    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

        [core, utils]
    }

    @Override
    def setup() {
        synchronizer = new BlockingHttpServer()
        synchronizer.hostAlias = "host.testcontainers.internal"
        synchronizer.start()
        GradleInContainer.exposeHostPort(synchronizer.port)
    }

    @Override
    def cleanup() {
        synchronizer.stop()
    }

    @Override
    protected void checkIncubationMessage() {

    private final Synchronizer synchronizer;
    // This structure is immutable, and this field is mutated only by the thread that owns the lock
    private volatile CurrentState<T> state;

    public StateTransitionController(DisplayName displayName, T initialState, Synchronizer synchronizer) {
        this.displayName = displayName;
        this.synchronizer = synchronizer;

        Synchronizer synchronizer = new Synchronizer()

        given:
        def action1 = {
            instant.action1Start
            thread.block()
            instant.action1End
        }
        def action2 = {
            instant.action2Start
        }

        when:
        start {
            synchronizer.runNow(action1)
        }
        async {

        action.run()
    }

    @Override
    void runAsUnmanagedWorkerThread(Runnable action) {
        action.run()
    }

    @Override
    Synchronizer newResource() {
        return new Synchronizer() {
            @Override
            void withLock(Runnable action) {
                action.run()
            }

            @Override
            <T> T withLock(Factory<T> action) {

        executionList.execute();
      }
      return result;
    }

    /**
     * Following the contract of {@link AbstractQueuedSynchronizer} we create a private subclass to
     * hold the synchronizer. This synchronizer is used to implement the blocking and waiting calls
     * as well as to handle state changes in a thread-safe manner. The current state of the future

        executionList.execute();
      }
      return result;
    }

    /**
     * Following the contract of {@link AbstractQueuedSynchronizer} we create a private subclass to
     * hold the synchronizer. This synchronizer is used to implement the blocking and waiting calls
     * as well as to handle state changes in a thread-safe manner. The current state of the future

 * limitations under the License.
 */

package org.gradle.internal.work;

import org.gradle.internal.Factory;
import org.gradle.internal.UncheckedException;

class DefaultSynchronizer implements Synchronizer {
    private final WorkerLeaseService workerLeaseService;
    private Thread owner;

    public DefaultSynchronizer(WorkerLeaseService workerLeaseService) {
        this.workerLeaseService = workerLeaseService;
    }