在golang中，闭包是一个非常有用的特性，它可以嵌套在函数内部，并且可以访问函数外部的变量。使用闭包，我们可以实现一些复杂的逻辑，同时也能更好地组织和封装代码。本文将介绍三个典型的使用场景。

1. 保存状态

闭包可以方便地保存函数的状态。举个例子，我们可以用闭包来实现一个计数器：

func newCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}
counter := newCounter()
fmt.Println(counter()) // 输出1
fmt.Println(counter()) // 输出2
fmt.Println(counter()) // 输出3

在上面的代码中，newCounter函数返回一个匿名函数，该匿名函数通过闭包引用了count变量，每次调用该匿名函数，count都会自增。

2. 协程同步

使用闭包可以很方便地实现协程之间的同步。举个例子，我们可以通过闭包来实现一个简单的生产者-消费者模型：

func producer(c chan< int) {
    for i := 0; i < 5; i++ {
        c <- i // 将i发送到通道c
    }
    close(c) // 关闭通道c
}

func consumer(c chan< int, done chan< struct{}) {
    for {
        x, ok := <-c // 从通道c接收一个值
        if !ok {
            done <- struct{}{} // 告诉done协程已完成
            return
        }
        fmt.Println(x)
    }
}

func main() {
    c := make(chan int)
    done := make(chan struct{})
    go producer(c)
    go consumer(c, done)
    <-done // 等待消费者协程完成
}

在上述代码中，producer函数将0到4的整数发送到通道c，而consumer函数不停地从通道c接收值，并打印出来。使用闭包，我们可以很方便地共享通道c和done信号，实现协程之间的同步。

3. 延迟执行

闭包还可以用于实现延迟执行。举个例子，我们可以使用闭包来封装一段需要延迟执行的逻辑：

func deferFunc() {
    name := "Go"
    defer func() {
        fmt.Println("Hello", name)
    }()
    name = "Golang"
    fmt.Println("Welcome to", name)
}

func main() {
    deferFunc()
}

在上面的代码中，我们使用defer关键字来延迟执行匿名函数，该匿名函数通过闭包引用了外部变量name。当deferFunc函数执行到defer语句时，当前的name值会被保存起来，在函数执行完毕后，被延迟执行的匿名函数会输出"Hello Go"，而不是"Hello Golang"。使用闭包，我们可以实现更灵活的延迟执行逻辑。