package main
 
import (
	"fmt"
	"time"
)
 
// 老師視頻里的生產(chǎn)者消費(fèi)者
 
func main() {
	//知識點(diǎn)： 老師這里用了兩個線程，一個用個傳數(shù)據(jù)，一個用來傳關(guān)閉信號
	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...") // 數(shù)據(jù)還沒收完，就被停止了。
				return
			default:
				fmt.Printf("receive message:%d\n", <-messages)
			}
 
		}
	}()
 
	// producer
	for i := 0; i < 10; i++ {
		messages <- i
	}
 
	// 5秒后主線程關(guān)閉done通道
	time.Sleep(5 * time.Second)
	close(done)
	time.Sleep(1 * time.Second)
	fmt.Println("main process exit!")
}

package main
 
import (
	"fmt"
	"time"
)
 
//知識點(diǎn)：
// 1) 多通道
// 2) 定時器
func main() {
	ch1 := make(chan int, 10)
	go func(ch chan<- int) {
		// 假設(shè)子協(xié)程j是一個耗時操作，例如訪問網(wǎng)絡(luò)，要10秒后才會有數(shù)據(jù)
		time.Sleep(10 * time.Second)
		ch <- 1
	}(ch1)
 
	timer := time.NewTimer(5 * time.Second) // 設(shè)置定時器的超時時間，主線程只等5秒
 
	fmt.Println("select start....")
	// 知識點(diǎn)：主協(xié)程等待子線程，并有超時機(jī)制
	select {
	case <-ch1:
		fmt.Println("從channel 1 收到一個數(shù)字")
	case <-timer.C: // 定時器也是一個通道
		fmt.Println("5秒到了，超時了，main協(xié)程不等了")
	}
 
	fmt.Println("done!")
}

package main
 
import (
	"context"
	"flag"
	"fmt"
	"sync"
	"time"
)
 
// 課后練習(xí) 1.2
// 基于 Channel 編寫一個簡單的單協(xié)程生產(chǎn)者消費(fèi)者模型。
// 要求如下：
// 1）隊(duì)列：隊(duì)列長度 10，隊(duì)列元素類型為 int
// 2）生產(chǎn)者：每 1 秒往隊(duì)列中放入一個類型為 int 的元素，隊(duì)列滿時生產(chǎn)者可以阻塞
// 3）消費(fèi)者：每2秒從隊(duì)列中獲取一個元素并打印，隊(duì)列為空時消費(fèi)者阻塞
// 4）主協(xié)程30秒后要求所有子協(xié)程退出。
// 5）要求優(yōu)雅退出，即消費(fèi)者協(xié)程退出前，要先消費(fèi)完所有的int。
 
// 知識點(diǎn)：
// 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("生產(chǎn)者進(jìn)行第%d次生產(chǎn)，值：%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("-->消費(fèi)者進(jìn)行第%d次消費(fèi)，值：%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 // 知識點(diǎn)：切片的零值也是可用的。
				for val = range queue {
					remains = append(remains, val)
					fmt.Printf("-->消費(fèi)者: 最后一次消費(fèi), 值為：%v\n", remains)
					break LOOP
				}
			}
		}
		wg.Done()
	}()
}
 
func main() {
	wg.Add(2)
 
	// 知識點(diǎn)：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() {
	// 解析程序入?yún)?，運(yùn)行模式
	mode := flag.String("m", "wb", "請輸入運(yùn)行模式：\nwb（溫飽模式）生產(chǎn)速度快過消費(fèi)速度、\nje（饑餓模式）生產(chǎn)速度慢于消費(fèi)速度)")
	flag.Parse()
 
	p = Producer{}
	c = Consumer{}
 
	if *mode == "wb" {
		fmt.Println("運(yùn)行模式：wb（溫飽模式）生產(chǎn)速度快過消費(fèi)速度")
		p.Interval = 1 // 每隔1秒生產(chǎn)一次
		c.Interval = 5 // 每隔5秒消費(fèi)一次
 
		// p = Producer{Interval: 1}
		// c = Consumer{Interval: 5}  // 這一行會報(bào)錯，為什么？
 
	} else {
		fmt.Println("運(yùn)行模式：je（饑餓模式）生產(chǎn)速度慢于消費(fèi)速度")
		p.Interval = 5 // 每隔5秒生產(chǎn)一次
		c.Interval = 1 // 每隔1秒消費(fèi)一次
	}
}

func AsyncCall() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(time.Millisecond*800))
	defer cancel()
	go func(ctx context.Context) {
		// 發(fā)送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) {
		// 發(fā)送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) {
		// 發(fā)送HTTP請求
		done <- struct{}{}
	}()

	select {
	case <-done:
		fmt.Println("call successfully!!!")
		return
	case <-time.After(time.Duration(800 * time.Millisecond)):
		fmt.Println("timeout!!!")
		return
	}
}