Best way to wake 0-N sleeping goroutines at once

I'm writing a program where I start N (N is a command-line argument) worker threads, and at any time 0 to N-1 of them can be waiting on another to update a variable. What's the best way for the threads to wait for this event, and the best way for one of the threads to notify all the others at once of the event occurring? This event will be sent multiple times by each thread.
sync.Cond isn't appropriate because the threads don't need to lock a resource upon waking from sleep. sync.WaitGroup won't work because I don't know how many times to call wg.Done().

Solution #1: I could use a sync.Mutex and have the thread that will eventually notify the others acquire the lock and then unlock it to notify the others, but it seems really inefficient for the others to all fight over a lock when they all just need to pop out of sleep, read a variable to see if that particular worker is now the master, and then either go back to sleep or start working.

Solution #2: Create a wrapper for sync.WaitGroup that allows keeping track of the number of waiting threads so that I can call wg.Add(-numWaitingThreads) to wake them. This sounds like a headache to figure out how to code it without all sorts of race conditions.

Solution #3: Until someone comes up with a better idea, I'll be using a list of N channels and have the notifier non-blocking-send to all of the channels except its own. Is this really the best way?

More details: I give each worker some unique credits and have a central variable for "which credit is the next to be written to the output file". When a worker finishes its work for whichever credit ID it was working on, it needs to do the following:

for centralNextCreditID != creditID {
  wait_for_centralNextCreditID_to_change()
}
saveWorkToFile()
centralNextCreditID++
wake_other_threads_waiting_for_centralNextCreditID_to_change()

To me it does seem like this is an appropriate use case for sync.Cond. You can use a *RWMutex.RLocker() for Cond.L so all goroutines can acquire the read lock simultaneously once the Cond.Broadcast() is sent.

Additionally, it may be worth making sure you hold a write lock when changing this "who's master" variable to avoid race conditions, which would make sync.Cond an even better fit.

>sync.WaitGroup won't work because I don't know how many times to call wg.Done().

wg can be used in this case. Make a wg with count 1 and pass this to the N goroutines. Make them wg.Wait(), except the one that updates the variable.
The goroutine updating the variable calls wg.Done() after successful update thus resulting in N goroutines to come out of wait and start executing further.

The title says that you want to wake 0-N sleeping goroutines, but the body of the question indicates that you only need to wake the goroutine for the next id (if there is a goroutine waiting).

Here's how to implement the problem described in the body of the question:

// waiter sequences work according to an incrementing id.
type waiter struct {
	mu      sync.Mutex
	id      int
	waiting map[int]chan struct{}
}

func NewWaiter(firstID int) *waiter {
	return &waiter{id: firstID, waiting: make(map[int]chan struct{})}
}

// wait waits for id's turn in the sequence.
func (w *waiter) wait(id int) {
	w.mu.Lock()
	if w.id == id {
		// This id is next. Nothing to do.
		w.mu.Unlock()
		return
	}
	// Wait for our turn.
	c := make(chan struct{})
	w.waiting[id] = c
	w.mu.Unlock()
	<-c
}

// done signals that the work for the previous id is done.
func (w *waiter) done() {
    w.mu.Lock()
	w.id++
	c, ok := w.waiting[w.id]
	if ok {
		delete(w.waiting, w.id)
	}
	w.mu.Unlock()
	if ok {
		// close cause c to receive a zero value
		close(c)
	}
}

Here's how to use it:

for _, creditID := range creditIDs {
    doWorkFor(creditID)
    waiter.wait(creditID)
    saveWorkToFile()
    waiter.done()
}

WaitGroup is the best option. The reason is that is keeps its signalled state and you are safe from deadlock if the main thread signals too early.

If you use Cond there is a risk that the main thread calls cond.Broadcast BEFORE the worker thread calls cond.Wait(). Since Cond doesn't remember that it was signalled, the worker thread will wait for the event to happen.
Here is an example: https://go.dev/play/p/YLfvEGO2A18
The main thread broadcasts too early, the worker threads run into a deadlock.

Same case with con.WaitGroup: https://go.dev/play/p/R6_-ULo2eJ2
The main thread releases the wait group too early, but there is no deadlock.