* thread-safe. Messages are delivered to the handler by a single thread.
     *
     * <p>A handler instance may also implement {@link org.gradle.internal.dispatch.StreamCompletion}, in which case it will be notified when no further messages will be forwarded to it.
     * This may happen because the peer has signalled that it has finished sending messages, or closes the connection, or crashes. It may also happen when

 * #whenReady(groovy.lang.Closure)} or {@link #addTaskExecutionGraphListener(TaskExecutionGraphListener)}.</p>
 */
public interface TaskExecutionGraph {
    /**
     * <p>Adds a listener to this graph, to be notified when this graph is ready.</p>
     *
     * @param listener The listener to add. Does nothing if this listener has already been added.
     */
    void addTaskExecutionGraphListener(TaskExecutionGraphListener listener);

    /**
     * Notify other threads about changes to resource locks.
     */
    void notifyStateChange();

    void assertHasStateLock();

    /**
     * Adds a listener that is notified when a lock is released. Called while the state lock is held.
     */
    void addLockReleaseListener(Action<ResourceLock> listener);

    void removeLockReleaseListener(Action<ResourceLock> listener);

import org.gradle.internal.DeprecatedInGradleScope;
import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

/**
 * <p>A {@code BuildListener} is notified of the major lifecycle events as a build is executed.</p>
 *
 * @see org.gradle.api.invocation.Gradle#addListener(Object)
 */
@EventScope(Scope.Build.class)
@DeprecatedInGradleScope
public interface BuildListener {

 *
 * Further modification tracking is implemented with a subscription-based mechanism via [KotlinModificationTopics]. Modification trackers make the most
 * sense when there are many, possibly short-lived objects that need to be notified of a change. In such cases, subscriber management in the
 * message bus adds too much overhead.
 */
public abstract class KotlinModificationTrackerFactory : KotlinPlatformComponent {
    /**

        return kind == CallableKindInfo.STATIC_METHOD ? "static method" :
            kind == CallableKindInfo.INSTANCE_METHOD ? "instance method" :
                kind == CallableKindInfo.AFTER_CONSTRUCTOR ? "constructor (getting notified after it)" :
                    kind == CallableKindInfo.GROOVY_PROPERTY_GETTER ? "Groovy property getter" :
                        kind == CallableKindInfo.GROOVY_PROPERTY_SETTER ? "Groovy property setter" : null;
    }

    List<Closeable> openedLocks = []

    def cleanup() {
        CompositeStoppable.stoppable(openedLocks).add(contentionHandler, contentionHandler2).stop()
    }

    def "lock manager is notified while holding an exclusive lock when another lock manager in same process requires lock with mode #lockMode"() {
        given:
        def file = tmpDir.file("lock-file.bin")
        def action = Mock(Consumer)

  }

  Status LocalDeviceManager(
      const tensorflow::DeviceMgr** deviceMgrPtr) override {
    // This method returns a null device manager without making an error.
    // Users of this method will be notified since it will have a fake data.
    *deviceMgrPtr = nullptr;
    return OkStatus();
  }

  Status Run(const std::vector<std::pair<std::string, Tensor>>& inputs,
             const std::vector<std::string>& output_names,

    private int lockCount;
    private FileLock fileLock;
    private final CacheInitializationAction initAction;
    private FileLockReleasedSignal lockReleaseSignal;

    /**
     * Actions are notified when lock is opened or closed. Actions are called while holding state lock, so that no other threads are working with cache while these are running.
     *
     * @param stateLock Lock to hold while mutating state.

 * system.
 *
 * <p>While the methods work with any Object, in general only interfaces should be used as listener types.
 *
 * <p>Implementations are thread-safe: A listener is notified by at most 1 thread at a time, and so do not need to be thread-safe. All listeners
 * of a given type receive events in the same order. Listeners can be added and removed at any time.
 */
@ServiceScope(Scope.Global.class)