HikariTish

1
package main
2

3
import (
4
  "fmt"
5
  "time"
6
)
7

8
// Result 是异步任务最终产生的结果
9
// Value 保存正常返回值，Err 保存错误
10
type Result[T any] struct {
11
  Value T
12
  Err   error
13
}
14

15
// Future 可以理解为“未来会返回一个结果的通道”
16
// <-chan 表示这是一个只读 Channel，外部只能等待结果，不能向里面写数据
17
//
18
// Async 启动任务后会立即返回 Future
19
// 调用 Await(future) 时，会阻塞当前 goroutine
20
// 直到 Future 对应的异步任务产生结果
21
type Future[T any] <-chan Result[T]
22

23
// Async 用于最标准的：
24
//
25
//  func() (T, error)
26
//
27
// 这是整个异步模型的核心函数
28
// 其他不同返回值形式，本质上都可以转换成这种形式
29
func Async[T any](fn func() (T, error)) Future[T] {
30
  // 缓冲区为 1：
31
  // 即使调用方暂时没有 Await，异步任务也可以把结果写入 Channel 后直接结束
32
  ch := make(chan Result[T], 1)
33

34
  // Async 被调用时，任务立即通过 goroutine 开始执行
35
  go func() {
36
    defer close(ch)
37

38
    value, err := fn()
39

40
    // 一个 Future 只产生一次结果
41
    ch <- Result[T]{
42
      Value: value,
43
      Err:   err,
44
    }
45
  }()
46

47
  return ch
48
}
49

50
// AsyncValue 用于：
51
//
52
//  func() T
53
//
54
// 没有 error 的函数统一转换成 (T, error)
55
// error 永远返回 nil
56
func AsyncValue[T any](fn func() T) Future[T] {
57
  return Async(func() (T, error) {
58
    return fn(), nil
59
  })
60
}
61

62
// AsyncErr 用于：
63
//
64
//  func() error
65
//
66
// 因为没有正常返回值，所以使用 struct{} 作为占位值
67
// struct{} 本身不占用实际数据空间
68
func AsyncErr(fn func() error) Future[struct{}] {
69
  return Async(func() (struct{}, error) {
70
    return struct{}{}, fn()
71
  })
72
}
73

74
// AsyncVoid 用于：
75
//
76
//  func()
77
//
78
// 既没有返回值，也没有 error，同样使用 struct{} 占位
79
func AsyncVoid(fn func()) Future[struct{}] {
80
  return Async(func() (struct{}, error) {
81
    fn()
82
    return struct{}{}, nil
83
  })
84
}
85

86
// Await 等待 Future 返回结果
87
//
88
// 如果异步任务还没有完成，这里会阻塞当前 goroutine
89
// 注意：阻塞的是 goroutine，而不是占住 OS 线程进行忙等
90
// Go runtime 可以让当前线程继续执行其他 runnable goroutine
91
func Await[T any](future Future[T]) (T, error) {
92
  result := <-future
93
  return result.Value, result.Err
94
}
95

96
// ------------------------------------------------------------
97
// 以下模拟实际业务中的各种函数签名
98
// ------------------------------------------------------------
99

100
// 1. 有参数 + 返回值 + error
101
func QueryUser(id int) (string, error) {
102
  time.Sleep(3 * time.Second)
103
  return fmt.Sprintf("user_%v", id), nil
104
}
105

106
// 2. 只有返回值
107
func GetServerName() string {
108
  time.Sleep(1 * time.Second)
109
  return "server-01"
110
}
111

112
// 3. 只有 error
113
func WriteLog(message string) error {
114
  time.Sleep(2 * time.Second)
115
  fmt.Println("write log:", message)
116
  return nil
117
}
118

119
// 4. 没有任何返回值
120
func WarmupCache() {
121
  time.Sleep(1 * time.Second)
122
  fmt.Println("cache warmup completed")
123
}
124

125
// 5. 多返回值 + error
126
//
127
// Go 泛型没有 Tuple，因此推荐将多个返回值包装成一个 struct
128
func QueryUserDetail(id int) (string, int, string, error) {
129
  time.Sleep(2 * time.Second)
130

131
  return fmt.Sprintf("user_%v", id),
132
    20,
133
    "Singapore",
134
    nil
135
}
136

137
// UserDetailResult 用来包装 QueryUserDetail 的多个正常返回值
138
type UserDetailResult struct {
139
  Name string
140
  Age  int
141
  City string
142
}
143

144
func main() {
145
  id := 4
146

147
  // --------------------------------------------------------
148
  // 先创建所有 Future
149
  //
150
  // 注意：
151
  // Async 在这里就已经启动 goroutine
152
  // 所以下面的几个任务实际上是在并发执行
153
  // --------------------------------------------------------
154

155
  // 1. 有参数 + 返回值 + error
156
  //
157
  // Async 本身不关心参数
158
  // 需要的参数直接通过闭包捕获即可
159
  userFuture := Async(func() (string, error) {
160
    return QueryUser(id)
161
  })
162

163
  // 2. 只有返回值
164
  serverFuture := AsyncValue(func() string {
165
    return GetServerName()
166
  })
167

168
  // 3. 只有 error
169
  logFuture := AsyncErr(func() error {
170
    return WriteLog("query user")
171
  })
172

173
  // 4. 无返回值
174
  cacheFuture := AsyncVoid(func() {
175
    WarmupCache()
176
  })
177

178
  // 5. 多返回值
179
  //
180
  // 将原来的多个返回值：
181
  //
182
  //  string, int, string, error
183
  //
184
  // 转换成：
185
  //
186
  //  UserDetailResult, error
187
  detailFuture := Async(func() (UserDetailResult, error) {
188
    name, age, city, err := QueryUserDetail(id)
189

190
    return UserDetailResult{
191
      Name: name,
192
      Age:  age,
193
      City: city,
194
    }, err
195
  })
196

197
  fmt.Println("所有异步任务已经启动")
198
  fmt.Println("main goroutine 可以先执行其他逻辑")
199

200
  // --------------------------------------------------------
201
  // Await
202
  // --------------------------------------------------------
203

204
  // Await 可以理解成：
205
  //
206
  // “等待这个返回值 Channel 中出现结果”
207
  //
208
  // 如果结果已经准备好，则立即返回
209
  // 如果结果还没准备好，则当前 goroutine 挂起等待
210

211
  userQuery, err := Await(userFuture)
212
  if err != nil {
213
    fmt.Println("query user error:", err)
214
    return
215
  }
216
  fmt.Println("userQuery:", userQuery)
217

218
  serverName, err := Await(serverFuture)
219
  if err != nil {
220
    fmt.Println("get server error:", err)
221
    return
222
  }
223
  fmt.Println("serverName:", serverName)
224

225
  // 只有 error 的任务，不关心 struct{} 占位返回值
226
  _, err = Await(logFuture)
227
  if err != nil {
228
    fmt.Println("write log error:", err)
229
  }
230

231
  // 无返回值任务，Value 和 error 都可以忽略
232
  _, _ = Await(cacheFuture)
233

234
  // 多返回值统一包装成结构体
235
  detail, err := Await(detailFuture)
236
  if err != nil {
237
    fmt.Println("query detail error:", err)
238
    return
239
  }
240

241
  fmt.Printf(
242
    "user detail: name=%s age=%d city=%s\n",
243
    detail.Name,
244
    detail.Age,
245
    detail.City,
246
  )
247
}