Go并发

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

package main
 
import (
    "fmt"
    "runtime"
    "sync"
    "time"
)
 
var c int
 
func counter() int {
    c++
    return c
}
 
func main2() {
    a := 100
 
    go func(x, y int) {
        time.Sleep(time.Second)
        println("go:", x, y)
    }(a, counter())
 
    a += 100
    println("main:", a, counter())
 
    time.Sleep(time.Second * 3)
}
 
// 进程退出不会等待并发任务结束，可用通道阻塞，然后发出退出信号
func main3() {
    exit := make(chan struct{})
 
    go func() {
        time.Sleep(time.Second)
        println("goroutine ....")
 
        // 除关闭通道外，写入数据也可接触通道
        close(exit)
    }()
 
    println("main ....")
    <-exit
    println("main exit.")
}
 
// 等待多个并发任务结束，使用sync.WaitGroup
func main4() {
    var wg sync.WaitGroup
 
    for i := 0; i < 10; i++ {
        wg.Add(1) // 累加计数
 
        go func(id int) {
            defer wg.Done() // 递减计数
 
            time.Sleep(time.Second)
            println("goroutine", id, "done.")
        }(i)
    }
 
    println("main ...")
    wg.Wait()
    println("main exit.")
}
 
// 可在多处使用wait，它们都能接收到通知
func main5() {
    var wg sync.WaitGroup
    wg.Add(1)
 
    go func() {
        wg.Wait() // 等待归零，解除阻塞
        println("wait exit.")
    }()
 
    go func() {
        time.Sleep(time.Second)
        println("done.")
        wg.Done()
    }()
 
    wg.Wait() // 等待归零，解除阻塞
    println("main exit.")
}
 
func main7() {
    var wg sync.WaitGroup
    var gs [5]struct {
        id     int
        result int
    }
 
    for i := 0; i < len(gs); i++ {
        wg.Add(1)
 
        go func(id int) {
            defer wg.Done()
 
            gs[id].id = id
            gs[id].result = (id + 1) * 100
        }(i)
    }
 
    wg.Wait()
    fmt.Printf("%+v\n", gs)
}
 
// Gosched 暂停，释放线程去执行其他任务。当前任务被放回队列，等待下次调度时恢复执行
func main8() {
    runtime.GOMAXPROCS(1)
    exit := make(chan struct{})
 
    go func() {
        defer close(exit)
 
        go func() {
            println("b")
        }()
 
        for i := 0; i < 4; i++ {
            println("a:", i)
 
            if i == 1 { // 让出当前线程，调度执行 b
                runtime.Gosched()
            }
        }
    }()
 
    <-exit
}
 
// Goexit 立即终止当前任务，运行时确保所有已注册延迟调用被执行
// 无论身处哪一层，Goexit 都能立即终止整个调用栈，这与return仅退出当前函数不同
// 标准库函数 os.Exit 可终止进程，但不会执行延迟调用
func main9() {
    exit := make(chan struct{})
 
    go func() {
        defer close(exit)
        defer println("a")
 
        func() {
            defer func() {
                println("b", recover() == nil)
            }()
 
            func() {
                println("c")
                runtime.Goexit() // 立即终止整个调用栈
                println("c done.")
            }()
 
            println("b done.")
        }()
 
        println("a done.")
    }()
 
    <-exit
}