Go语言实现超时的3种方法

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!")

}

package main

import (
	"fmt"
	"time"
)

//知识点：
// 1) 多通道
// 2) 定时器
func main() {
	ch1 := make(chan int, 10)
	go func(ch chan<- int) {
		// 假设子协程j是一个耗时操作，例如访问网络，要10秒后才会有数据
		time.Sleep(10 * time.Second)
		ch <- 1
	}(ch1)

	timer := time.NewTimer(5 * time.Second) // 设置定时器的超时时间，主线程只等5秒

	fmt.Println("select start....")
	// 知识点：主协程等待子线程，并有超时机制
	select {
	case <-ch1:
		fmt.Println("从channel 1 收到一个数字")
	case <-timer.C: // 定时器也是一个通道
		fmt.Println("5秒到了，超时了，main协程不等了")
	}

	fmt.Println("done!")
}

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秒消费一次
	}

}