Go WaitGroup에 1외에 다른 값을 Add 하면?

// Done decrements the WaitGroup counter by one.
func (wg *WaitGroup) Done() {
    wg.Add(-1)
}

func (wg *WaitGroup) Add(delta int) {
    statep, semap := wg.state()
    if race.Enabled {
        _ = *statep // trigger nil deref early
        if delta < 0 {
            // Synchronize decrements with Wait.
            race.ReleaseMerge(unsafe.Pointer(wg))
        }
        race.Disable()
        defer race.Enable()
    }
    state := atomic.AddUint64(statep, uint64(delta)<<32)
    v := int32(state >> 32)
    w := uint32(state)
    if race.Enabled && delta > 0 && v == int32(delta) {
        // The first increment must be synchronized with Wait.
        // Need to model this as a read, because there can be
        // several concurrent wg.counter transitions from 0.
        race.Read(unsafe.Pointer(semap))
    }
    if v < 0 {
        panic("sync: negative WaitGroup counter")
    }
    if w != 0 && delta > 0 && v == int32(delta) {
        panic("sync: WaitGroup misuse: Add called concurrently with Wait")
    }
    if v > 0 || w == 0 {
        return
    }
    // This goroutine has set counter to 0 when waiters > 0.
    // Now there can't be concurrent mutations of state:
    // - Adds must not happen concurrently with Wait,
    // - Wait does not increment waiters if it sees counter == 0.
    // Still do a cheap sanity check to detect WaitGroup misuse.
    if *statep != state {
        panic("sync: WaitGroup misuse: Add called concurrently with Wait")
    }
    // Reset waiters count to 0.
    *statep = 0
    for ; w != 0; w-- {
        runtime_Semrelease(semap, false)
    }
}

// Wait blocks until the WaitGroup counter is zero.
func (wg *WaitGroup) Wait() {
    statep, semap := wg.state()
    if race.Enabled {
        _ = *statep // trigger nil deref early
        race.Disable()
    }
    for {
        state := atomic.LoadUint64(statep)
        v := int32(state >> 32)
        w := uint32(state)
        if v == 0 {
            // Counter is 0, no need to wait.
            if race.Enabled {
                race.Enable()
                race.Acquire(unsafe.Pointer(wg))
            }
            return
        }
        // Increment waiters count.
        if atomic.CompareAndSwapUint64(statep, state, state+1) {
            if race.Enabled && w == 0 {
                // Wait must be synchronized with the first Add.
                // Need to model this is as a write to race with the read in Add.
                // As a consequence, can do the write only for the first waiter,
                // otherwise concurrent Waits will race with each other.
                race.Write(unsafe.Pointer(semap))
            }
            runtime_Semacquire(semap)
            if *statep != 0 {
                panic("sync: WaitGroup is reused before previous Wait has returned")
            }
            if race.Enabled {
                race.Enable()
                race.Acquire(unsafe.Pointer(wg))
            }
            return
        }
    }
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    defer wg.Wait() // Wait를 가장 마지막에 호출

    wg.Add(1)
    go func() {
        defer wg.Done()
        fmt.Println("one")
    }()

    wg.Add(1)
    go func() {
        defer wg.Done()
        fmt.Println("two")
    }()

    wg.Add(1)
    go func() {
        defer wg.Done()
        fmt.Println("three")
    }()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    wg.Done()
    wg.Add(1)
    wg.Done()
    wg.Add(1)
    wg.Done()
    wg.Wait()
}

func main() {
    var wg sync.WaitGroup
    defer wg.Wait()

    wg.Add(3)   // 한번에 3을 Add 한다
    go func() {
        defer wg.Done()
        fmt.Println("one")
    }()
    go func() {
        defer wg.Done()
        fmt.Println("two")
    }()
    go func() {
        defer wg.Done()
        fmt.Println("three")
    }()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(3)
    wg.Done()
    wg.Done()
    wg.Done()
    wg.Wait()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(3)
    wg.Add(-3)  // Done 세 번과 똑같다
    wg.Wait()
}

func main() {
    var wg sync.WaitGroup
    defer wg.Wait()

    wg.Add(4)   // 3을 Add 해야 하는데 4를 Add
    go func() {
        defer wg.Done()
        fmt.Println("one")
    }()
    go func() {
        defer wg.Done()
        fmt.Println("two")
    }()
    go func() {
        defer wg.Done()
        fmt.Println("three")
    }()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(4)
    wg.Done()
    wg.Done()
    wg.Done()
    wg.Wait()
}

func main() {
    var wg sync.WaitGroup

    defer wg.Wait()

    wg.Add(2)   // 2개만 추가
    go func() {
        defer wg.Done()
        fmt.Println("one")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("two")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("three")
    }()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    wg.Done()
    wg.Done()
    wg.Done()
    wg.Wait()
}

func main() {
    var wg sync.WaitGroup
    defer wg.Wait()

    wg.Add(6)
    go func() {
        defer wg.Add(-2)
        fmt.Println("one")
    }()
    go func() {
        defer wg.Add(-2)
        fmt.Println("two")
    }()

    go func() {
        defer wg.Add(-2)
        fmt.Println("three")
    }()
}