package sync

import "unsafe"

// defined in package runtime

// Semacquire waits until *s > 0 and then atomically decrements it.
// It is intended as a simple sleep primitive for use by the synchronization
// library and should not be used directly.
func runtime_Semacquire(s *uint32)

// Semacquire(RW)Mutex(R) is like Semacquire, but for profiling contended
// Mutexes and RWMutexes.

				default:
				}
				Gosched()
			}
		}()
	}

	wg.Add(1)
	go func() {
		defer wg.Done()
		Semacquire(&sema)
		atomic.CompareAndSwapUint32(&res, 0, 1)

		Semrelease1(&sema, true, 0)
		close(done)
	}()
	for SemNwait(&sema) == 0 {
		Gosched() // wait for goroutine to block in Semacquire
	}

	// The crux of the test: we release the semaphore with handoff

     * If no locks were held at the time the method was called, then no attempt will be made to reacquire a lock on completion.
     * While blocking to reacquire the project lock, all worker leases held by the thread will be released and reacquired once the project lock is obtained.
     */
    <T> T runAsIsolatedTask(Factory<T> action);

    /**

     */
    <T> T withReplacedLocks(Collection<? extends ResourceLock> currentLocks, ResourceLock newLock, Factory<T> factory);

    /**
     * Runs a given {@link Factory} while the specified locks are released and then reacquire the locks
     * upon completion.  If the locks cannot be immediately reacquired, the current worker lease will be released
     * and the method will block until the locks are reacquired.
     */

    /**
     * Runs the given action as a worker. While the action is running, the thread can acquire resource locks.
     * A worker lease is also granted to the thread. The thread can release this if it needs to, but should reacquire
     * the lease prior to doing any meaningful work.
     *
     * This method is reentrant so that a thread can call this method from the given action.
     *
     * This method blocks until a worker lease is available.

Michael Anthony Knyszek <******@****.***> 1716583527 +0000

Carlos Amedee <******@****.***> 1715265901 -0400

}

func (q *Queue) resetTimer() {
	// Below is a separate function to limit the scope of the lock.
	// We don't want to lock when we modify the timer in case it causes
	// an immediate callback, which would reacquire the lock.
	needReset, resetDuration := func() (bool, time.Duration) {
		q.mutex.Lock()
		defer q.mutex.Unlock()

		if q.stopping {
			// Ignore the event, since we're already shutting down.
			return false, 0

Michael Anthony Knyszek <******@****.***> 1716583527 +0000

	// all callers may acquire. Versions of this library prior to Kubernetes 1.14 will not
	// attempt to acquire leases with empty identities and will wait for the full lease
	// interval to expire before attempting to reacquire. This value is set to empty when
	// a client voluntarily steps down.
	HolderIdentity string `json:"holderIdentity"`
	// HolderKey is the Key of the lease owner. This may be empty if a key is not set.