Prevención de condiciones de carrera utilizando el paquete sync.Atomic en Go

Tengo el siguiente contador implementado en Go que me gustaría usar concurrentemente. Estoy utilizando el paquete atomic para almacenar el estado, pero no estoy seguro si podría haber condiciones de carrera. ¿Necesito agregar un mutex adicional también para protegerme de incrementar por debajo de cero, por ejemplo, o las operaciones atómicas proporcionan suficiente seguridad? ¡Gracias!

type Counter struct {
    counter  uint64
    finished uint32
    sync.Mutex
}

// Inc incrementa el contador en uno
func (c *Counter) Inc() error {
    if c.isFinished() {
        return fmt.Errorf("el contador está terminado")
    }

    atomic.AddUint64(&c.counter, 1)
    return nil
}

// Dec decrementa el contador en uno, pero evita que el contador llegue a cero
func (c *Counter) Dec() {
    // evitar desbordamiento
    if !c.isZero() {
        atomic.AddUint64(&c.counter, ^uint64(0))
    }
}

// Cancel establece el indicador de finalizado y establece el contador en cero
func (c *Counter) Cancel() {
    if !c.isFinished() {
        atomic.StoreUint32(&c.finished, 1)
        atomic.StoreUint64(&c.counter, 0)
    }
}

// isFinished devuelve verdadero si está finalizado
func (c *Counter) isFinished() bool {
    return atomic.LoadUint32(&c.finished) == uint32(1)
}

// isZero devuelve verdadero si el contador es cero
func (c *Counter) isZero() bool {
    return atomic.LoadUint64(&c.counter) == uint64(0)
}

Actualización: Al ejecutar el código de abajo con la bandera -race, pude detectar que efectivamente necesito incluir mutexes.

var counter *Counter = &Counter{}

func main() {
    wg := sync.WaitGroup{}

    numberOfLoops := 10
    wg.Add(numberOfLoops)

    for i := 0; i < numberOfLoops; i++ {
        go incrementor(&wg)
    }

    wg.Wait()
    fmt.Println("Contador Final:", counter.counter)
}

func incrementor(wg *sync.WaitGroup) {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 20; i++ {
        counter.Inc()
        time.Sleep(time.Duration(rand.Intn(3)) * time.Millisecond)
    }
    wg.Done()
    counter.Cancel()
}

Enlace al Playground: Playground link