var count int

func add() {
	for i := 0; i< 1000; i++ {
		count++
	}
}

func main() {
	go add()
	go add()
	time.Sleep(time.Second)
	fmt.Println(count)
}

func main() {
	ch := make(chan int)
	// 沒有其他協(xié)程接收，死鎖
	ch <- 1
}

func main() {
	ch1 := make(chan int)
	ch2 := make(chan int)

	go func() {
		<-ch1
		ch2 <- 1
	}()
	
	go func() {
		<-ch2
		ch1 <- 1
	}()
	
	// 程序卡死
	time.Sleep(time.Second * 2)
}

func main() {
	ch := make(chan int)
	for {
		go func() {
			// 不斷產(chǎn)生阻塞的 goroutine，直到內(nèi)存耗盡為止
			<-ch
		}()
	}
}

// 寫入已關(guān)閉通道
ch := make(chan int)
close(ch)
ch <- 1 // panic

// 重復(fù)關(guān)閉通道
close(ch)
close(ch) // panic

// 從空通道中讀取，沒有寫入，造成死鎖
<-ch

func worker() {
    go func() {
        for {
            select {
            case msg := <-someChan:
                // 處理消息
                fmt.Println(msg)
            // ? 沒有退出條件，協(xié)程永遠(yuǎn)不會(huì)退出
            }
        }
    }()
}

func worker(ctx context.Context) {
    go func() {
        for {
            select {
            case msg := <-someChan:
                fmt.Println(msg)
            case <-ctx.Done():
                // ? 收到取消信號(hào)，退出協(xié)程
                fmt.Println("worker exiting")
                return
            }
        }
    }()
}

ctx, cancel := context.WithCancel(context.Background())
worker(ctx)

// 一段時(shí)間后或某個(gè)條件下，調(diào)用 cancel() 來(lái)通知協(xié)程退出
time.Sleep(5 * time.Second)
cancel()

// 全局 map，非線程安全
var data = make(map[int]int)

func main() {
    for i := 0; i < 100; i++ {
        go func(i int) {
            data[i] = i // ?? 多個(gè)協(xié)程同時(shí)寫入 map，會(huì)導(dǎo)致數(shù)據(jù)競(jìng)爭(zhēng)或 panic
        }(i)
    }

    time.Sleep(1 * time.Second)
    fmt.Println("done")
}

var (
    data = make(map[int]int)
    mu   sync.Mutex
)

func main() {
    for i := 0; i < 100; i++ {
        go func(i int) {
            mu.Lock()
            data[i] = i
            mu.Unlock()
        }(i)
    }

    time.Sleep(1 * time.Second)
    fmt.Println("done")
}

var data sync.Map

func main() {
    for i := 0; i < 100; i++ {
        go func(i int) {
            data.Store(i, i)
        }(i)
    }

    time.Sleep(1 * time.Second)

    data.Range(func(k, v interface{}) bool {
        fmt.Printf("key: %v, value: %v\n", k, v)
        return true
    })
}

var globalCounter int64

func worker(wg *sync.WaitGroup) {
	defer wg.Done()
	
	// 原子加1，確保并發(fā)安全
	atomic.AddInt64(&globalCounter, 1)
}

func main() {
	var wg sync.WaitGroup
	
	wg.Add(1000)
	
	for i := 0; i < 1000; i++ {
		go worker(&wg)
	}
	
	// 確保主 goroutine 等待所有子 goroutine 完成
	wg.Wait()
	fmt.Println("計(jì)數(shù)器值：", globalCounter)
}

var counter int
var mu sync.Mutex

func main() {
	mu.Lock()
	counter++
	mu.UnLock()
}

var counter = make(chan int, 1)

func init() {
	counter <- 0
}

func main() {
	v := <-counter
	v++
	counter <- v
}