溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹“Go語言實現超時的方法有哪些”，在日常操作中，相信很多人在Go語言實現超時的方法有哪些問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Go語言實現超時的方法有哪些”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！
一個通道用來傳數據，一個用來傳停止信號。
package main
import (
"fmt"
"time"
)
// 老師視頻里的生產者消費者
func main() {
//知識點： 老師這里用了兩個線程，一個用個傳數據，一個用來傳關閉信號
messages := make(chan int, 10)
done := make(chan bool)
defer close(messages)
// consumer
go func() {
ticker := time.NewTicker(1 * time.Second)
for range ticker.C {
select {
case <-done:
fmt.Println("child process interrupt...") // 數據還沒收完，就被停止了。
return
default:
fmt.Printf("receive message:%d\n", <-messages)
}
}
}()
// producer
for i := 0; i < 10; i++ {
messages <- i
}
// 5秒后主線程關閉done通道
time.Sleep(5 * time.Second)
close(done)
time.Sleep(1 * time.Second)
fmt.Println("main process exit!")
}程序輸出如下：
receive message:0
receive message:1
receive message:2
receive message:3
child process interrupt...
main process exit!
這種方法也方法一類似，只不過是用一個Timer代替通道。
package main
import (
"fmt"
"time"
)
//知識點：
// 1) 多通道
// 2) 定時器
func main() {
ch2 := make(chan int, 10)
go func(ch chan<- int) {
// 假設子協程j是一個耗時操作，例如訪問網絡，要10秒后才會有數據
time.Sleep(10 * time.Second)
ch <- 1
}(ch2)
timer := time.NewTimer(5 * time.Second) // 設置定時器的超時時間，主線程只等5秒
fmt.Println("select start....")
// 知識點：主協程等待子線程，并有超時機制
select {
case <-ch2:
fmt.Println("從channel 1 收到一個數字")
case <-timer.C: // 定時器也是一個通道
fmt.Println("5秒到了，超時了，main協程不等了")
}
fmt.Println("done!")
}程序輸出如下：
select start....
5秒到了，超時了，main協程不等了
done!
下面的例子比較復雜，基于 Channel 編寫一個簡單的單協程生產者消費者模型。
要求如下：
1）隊列：隊列長度 10，隊列元素類型為 int
2）生產者：每 1 秒往隊列中放入一個類型為 int 的元素，隊列滿時生產者可以阻塞
3）消費者：每2秒從隊列中獲取一個元素并打印，隊列為空時消費者阻塞
4）主協程30秒后要求所有子協程退出。
5）要求優雅退出，即消費者協程退出前，要先消費完所有的int
6）通過入參支持兩種運行模式：
wb（溫飽模式）生產速度快過消費速度、
je（饑餓模式）生產速度慢于消費速度
context.WithTimeout見第87行。
package main
import (
"context"
"flag"
"fmt"
"sync"
"time"
)
// 課后練習 1.2
// 基于 Channel 編寫一個簡單的單協程生產者消費者模型。
// 要求如下：
// 1）隊列：隊列長度 10，隊列元素類型為 int
// 2）生產者：每 1 秒往隊列中放入一個類型為 int 的元素，隊列滿時生產者可以阻塞
// 3）消費者：每2秒從隊列中獲取一個元素并打印，隊列為空時消費者阻塞
// 4）主協程30秒后要求所有子協程退出。
// 5）要求優雅退出，即消費者協程退出前，要先消費完所有的int。
// 知識點：
// 1) 切片的零值也是可用的。
// 2) context.WithTimeout
var (
wg sync.WaitGroup
p Producer
c Consumer
)
type Producer struct {
Time int
Interval int
}
type Consumer struct {
Producer
}
func (p Producer) produce(queue chan<- int, ctx context.Context) {
go func() {
LOOP:
for {
p.Time = p.Time + 1
queue <- p.Time
fmt.Printf("生產者進行第%d次生產，值：%d\n", p.Time, p.Time)
time.Sleep(time.Duration(p.Interval) * time.Second)
select {
case <-ctx.Done():
close(queue)
break LOOP
}
}
wg.Done()
}()
}
func (c Consumer) consume(queue <-chan int, ctx context.Context) {
go func() {
LOOP:
for {
c.Time++
val := <-queue
fmt.Printf("-->消費者進行第%d次消費，值：%d\n", c.Time, val)
time.Sleep(time.Duration(c.Interval) * time.Second)
select {
case <-ctx.Done():
//remains := new([]int)
//remains := []int{}
var remains []int // 知識點：切片的零值也是可用的。
for val = range queue {
remains = append(remains, val)
fmt.Printf("-->消費者: 最后一次消費, 值為：%v\n", remains)
break LOOP
}
}
}
wg.Done()
}()
}
func main() {
wg.Add(2)
// 知識點：context.Timeout
timeout := 30
ctx, _ := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
queue := make(chan int, 10)
p.produce(queue, ctx)
fmt.Println("main waiting...")
wg.Wait()
fmt.Println("done")
}
/*
啟動命令：
$ go run main/main.go -m wb
$ go run main/main.go -m je
*/
func init() {
// 解析程序入參，運行模式
mode := flag.String("m", "wb", "請輸入運行模式：\nwb（溫飽模式）生產速度快過消費速度、\nje（饑餓模式）生產速度慢于消費速度)")
flag.Parse()
p = Producer{}
c = Consumer{}
if *mode == "wb" {
fmt.Println("運行模式：wb（溫飽模式）生產速度快過消費速度")
p.Interval = 1 // 每隔1秒生產一次
c.Interval = 5 // 每隔5秒消費一次
// p = Producer{Interval: 1}
// c = Consumer{Interval: 5} // 這一行會報錯，為什么？
} else {
fmt.Println("運行模式：je（饑餓模式）生產速度慢于消費速度")
p.Interval = 5 // 每隔5秒生產一次
c.Interval = 1 // 每隔1秒消費一次
}
}wb（溫飽模式）生產速度快過消費速度，輸出如下：
運行模式：wb（溫飽模式）生產速度快過消費速度
生產者: 第1次生產, 值為：1
-->消費者: 第1次消費, 值為：1
生產者: 第2次生產, 值為：2
生產者: 第3次生產, 值為：3
生產者: 第4次生產, 值為：4
生產者: 第5次生產, 值為：5
-->消費者: 第2次消費, 值為：2
生產者: 第6次生產, 值為：6
生產者: 第7次生產, 值為：7
生產者: 第8次生產, 值為：8
生產者: 第9次生產, 值為：9
生產者: 第10次生產, 值為：10
-->消費者: 第3次消費, 值為：3
生產者: 第11次生產, 值為：11
生產者: 第12次生產, 值為：12
生產者: 第13次生產, 值為：13
-->消費者: 第4次消費, 值為：4
生產者: 第14次生產, 值為：14
-->消費者: 第5次消費, 值為：5
生產者: 第15次生產, 值為：15
生產者: 第16次生產, 值為：16
-->消費者: 第6次消費, 值為：6
main waiting
生產者: 第17次生產, 值為：17
-->消費者: 最后一次消費, 值為：[7 8 9 10 11 12 13 14 15 16 17]
-- done --
je（饑餓模式）生產速度慢于消費速度，輸出如下：
運行模式：je（饑餓模式）生產速度慢于消費速度
-->消費者: 第1次消費, 值為：1
生產者: 第1次生產, 值為：1
生產者: 第2次生產, 值為：2
-->消費者: 第2次消費, 值為：2
生產者: 第3次生產, 值為：3
-->消費者: 第3次消費, 值為：3
生產者: 第4次生產, 值為：4
-->消費者: 第4次消費, 值為：4
生產者: 第5次生產, 值為：5
-->消費者: 第5次消費, 值為：5
生產者: 第6次生產, 值為：6
-->消費者: 第6次消費, 值為：6
main waiting
-->消費者: 第7次消費, 值為：0
之前手寫rpc框架的時候，吃多了網絡超時處理的苦，今天偶然發現了實現超時退出的方法，MARK
func AsyncCall() {
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(time.Millisecond*800))
defer cancel()
go func(ctx context.Context) {
// 發送HTTP請求
}()
select {
case <-ctx.Done():
fmt.Println("call successfully!!!")
return
case <-time.After(time.Duration(time.Millisecond * 900)):
fmt.Println("timeout!!!")
return
}
}
//2
func AsyncCall() {
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(time.Millisecond * 800))
defer cancel()
timer := time.NewTimer(time.Duration(time.Millisecond * 900))
go func(ctx context.Context) {
// 發送HTTP請求
}()
select {
case <-ctx.Done():
timer.Stop()
timer.Reset(time.Second)
fmt.Println("call successfully!!!")
return
case <-timer.C:
fmt.Println("timeout!!!")
return
}
}
//3
func AsyncCall() {
ctx := context.Background()
done := make(chan struct{}, 1)
go func(ctx context.Context) {
// 發送HTTP請求
done <- struct{}{}
}()
select {
case <-done:
fmt.Println("call successfully!!!")
return
case <-time.After(time.Duration(800 * time.Millisecond)):
fmt.Println("timeout!!!")
return
}
}到此，關于“Go語言實現超時的方法有哪些”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
