Better way to exit for loop when using sync.WaitGroup?

Is there a better way to exit the for loop when using sync.WaitGroup? At the moment I am using bool e as a trigger to break out of the for loop at the end of the loop, which works. If I try to break the for loop where I check orders >= quantity I get all kinds of errors.

Is there a better way to break this loop than my bool code without causing panic?

package main

import (
	"fmt"
	"math/rand"
	"strconv"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	var accounts int = 1
	var emails int = 1000

	for i := 0; i < accounts; i++ {
		wg.Add(1)

		go func(i int) {
			defer wg.Done()
			threads := 500 //Max subroutines to run at once
			var orderMutex sync.Mutex
			var quantity = 2
			var orders = 0
			sem := make(chan bool, threads)
			var wgnested sync.WaitGroup

			var e = false

			for x := 0; x < emails; x++ {
				sem <- true //block

				orderMutex.Lock()
				if orders >= quantity {
					fmt.Println(strconv.Itoa(x) + " Quantity Exceeded Stopping")
					e = true
				}
				orderMutex.Unlock()

				wgnested.Add(1)

				go func() {
					defer wgnested.Done()
					defer func() { <-sem }()

					//Simulate orders
					if rand.Intn(50) == 7 {
						orderMutex.Lock()
						orders++
						orderMutex.Unlock()
					}

					fmt.Println(strconv.Itoa(i) + " Made to end ")

				}() //func

				if e {
					break
				}
			} //x

			wgnested.Wait()

		loop:
			for {
				select {
				case <-sem:
					fmt.Println("quit")
					break loop
				default:
					sem <- true
				}
			}
			fmt.Println(strconv.Itoa(i) + " Orders: " + strconv.Itoa(orders))

		}(i)
	} //i

	wg.Wait()
}

you use context.Context to stop a loop when the context is cancelled.

Example

package main

import (
	"context"
	"fmt"
	"math/rand"
	"strconv"
	"sync"
)

func main() {
	var (
		wg       sync.WaitGroup
		accounts int = 1
		emails   int = 1000
		//
		ctx, cancel = context.WithCancel(context.Background()) // create new context
	)

	for i := 0; i < accounts; i++ {
		wg.Add(1)

		go func(i int) {
			// when goroutine finish
			// cancel the context
			defer func() {
				wg.Done()
				cancel()
			}()
			//
			var (
				// threads    = 500 //Max subroutines to run at once
				orderMutex sync.Mutex
				quantity   = 2
				orders     = 0
				wgnested   sync.WaitGroup
			)

			for x := 0; x < emails; x++ {
				select {
				// case context is done.
				case <-ctx.Done():
					return
				default:
					// check context is cancelled
					// exit for loop
					if ctx.Err() != nil {
						return
					}

					orderMutex.Lock()
					if orders >= quantity {
						fmt.Println(strconv.Itoa(x) + " Quantity Exceeded Stopping")
						cancel() // signal cancel context
					}
					orderMutex.Unlock()

					wgnested.Add(1)
					go func() {
						defer wgnested.Done()

						//Simulate orders
						if rand.Intn(50) == 7 {
							orderMutex.Lock()
							orders++
							orderMutex.Unlock()
						}

						fmt.Println(strconv.Itoa(x) + " Made to end ") // i used "x" instead of "i"

					}()

					wgnested.Wait()
				}
			}

			//
			fmt.Println(strconv.Itoa(i) + " Orders: " + strconv.Itoa(orders))
		}(i)
	} //i

	wg.Wait()
}

Output

0 Made to end 
1 Made to end 
2 Made to end 
3 Made to end 
4 Made to end 
5 Made to end 
6 Made to end 
...
...
...
88 Made to end 
89 Made to end 
90 Made to end 
91 Made to end 
92 Made to end 
93 Made to end 
94 Quantity Exceeded Stopping
94 Made to end