delete(m.pods, uid)
}

// get a WaitingPod from the map.
func (m *waitingPodsMap) get(uid types.UID) *waitingPod {
	m.mu.RLock()
	defer m.mu.RUnlock()
	return m.pods[uid]
}

// iterate acquires a read lock and iterates over the WaitingPods map.
func (m *waitingPodsMap) iterate(callback func(framework.WaitingPod)) {
	m.mu.RLock()
	defer m.mu.RUnlock()
	for _, v := range m.pods {
		callback(v)
	}
}

     *
     * <p>This should become the default and only behaviour for all worker threads, and locks are acquired and released only when starting and finishing an execution node.
     * For now, this is an opt-in behaviour.</p>
     */
    <T> T whileDisallowingProjectLockChanges(Factory<T> action);

		return
	}

	go func() {
		r := rand.New(rand.NewSource(time.Now().UnixNano()))
		// Leader node (that successfully acquires the lock inside runCallhome)
		// will keep performing the callhome. If the leader goes down for some reason,
		// the lock will be released and another node will acquire it and take over
		// because of this loop.
		for {
			if !globalCallhomeConfig.Enabled() {
				return
			}

     * that tells the resource coordinator how to proceed:
     *
     * FINISHED - All locks were acquired, release the state lock
     * FAILED - One or more locks were not acquired, roll back any locks that were acquired and release the state lock
     * RETRY - One or more locks were not acquired, roll back any locks that were acquired and block waiting for the
     * state to change, then run the transform again
     *

 */

package org.gradle.internal.work;

import org.gradle.internal.concurrent.Stoppable;

/**
 * Represents a queue of executions that can run when a provided resource lock can be acquired.  The typical use case would
 * be that a worker lease must be acquired before execution.
 */
public interface ConditionalExecutionQueue<T> extends Stoppable {
    /**

	// This saves space in the resulting trace by keeping the counter small and allows
	// GoStatus and GoCreate events to omit a sequence number (implicitly 0).
	seq [2]uint64
}

// acquireStatus acquires the right to emit a Status event for the scheduling resource.
func (r *traceSchedResourceState) acquireStatus(gen uintptr) bool {
	if !r.statusTraced[gen%3].CompareAndSwap(0, 1) {
		return false
	}
	r.readyNextGen(gen)

import java.util.function.Supplier;

/**
 * Provides synchronised access to a cache.
 */
public interface ExclusiveCacheAccessCoordinator {
    /**
     * Performs some work against the cache. Acquires exclusive locks on the appropriate resources, so that the given action is the only action to execute across all processes (including this one). Releases the locks and all resources at the end of the action.
     *

    };

    public boolean isLockWasAcquired() {
        return false;
    }

    public FileLock getFileLock() {
        throw new IllegalStateException("Lock was not acquired");
    }

    static FileLockOutcome acquired(FileLock fileLock) {
        return new FileLockOutcome() {
            @Override
            public boolean isLockWasAcquired() {
                return true;
            }

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package flock

// Acquire is not implemented on non-unix systems.
func Acquire(path string) error {
	return nil

     *
     * Fails if the current thread is already holding the resource lock. May release project locks prior to blocking, as per {@link WorkerLeaseService#blocking(Runnable)}.
     */
    void withLock(Runnable action);

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