golang并发编程-04-通道-02-定时器、断续器

合集 - 【进阶卷】----------------------------(14)

1.golang并发编程-01多进程编程-01概述2022-05-042.golang并发编程-01多进程编程-02管道2022-05-043.golang并发编程-01多进程编程-03信号2022-05-054.golang并发编程-01多进程编程-04socket2022-05-065.golang并发编程-02多线程编程-01线程概述2022-05-066.golang并发编程-02多线程编程-02线程的同步2022-05-087.golang并发编程-03-协程（Goroutine）概述2022-05-088.golang并发编程-04-通道-01-基本使用/缓冲通道/非缓冲通道2022-05-09

9.golang并发编程-04-通道-02-定时器、断续器2022-05-09

10.golang并发编程-05-同步-01-锁的使用（sync包Mutex、RWMutex结构体的常用方法）2022-05-0911.golang并发编程-05-同步-02-条件变量（Cond结构体的常用方法）2022-05-1312.golang并发编程-05-同步-03-原子操作（atomic包）2022-05-1113.golang并发编程-05-同步-04-sync包的once、WaitGroup结构体的常用方法2022-05-1314.golang并发编程-05-同步-05-临时对象池（sync.Pool）2022-05-15

收起

@

目录

• 1. 定时器
  • 1.1 time.NewTimer
  • 1.2 <-time.After()
  • 1.3 停止
  • 1.4 定时器重置
• 2 断续器
  • 2.1 断续器使用
  • 2.2 断续器中断

1. 定时器

1.1 time.NewTimer

• 语法
  创建一个定时器

time.NewTimer(N * time.Second)

该定时器到设定时间会向通道中写入一个当时时间。
而在此之间，线程会阻塞。

• 示例

要求：
写一个定时器，设定五秒。
到达预定时间后，读出定时器写入通道的时间。

func main() {
	//创建一个定时器,设置时间为5s
	timer := time.NewTimer(5 * time.Second)
	fmt.Printf("【孔明先生在睡觉】   时间： %d:%d \n", time.Now().Minute(),time.Now().Second())
 
	//5s后,往timer.c写数据
	t := <-timer.C //channel没有数据前后阻塞
	fmt.Printf("【孔明先生睡醒了】   时间： %d:%d ", t.Minute(),t.Second())
}

输出

【孔明先生在睡觉】   时间： 37:56 
【孔明先生睡醒了】   时间： 38:1 

1.2 <-time.After()

• 语法

<-time.After(N* time.Second)

• 作用：
  阻塞线程N秒

• 示例

说明：
启动一个协程定时5秒后输出
主线程放一个for循环计数

func main() {
	fmt.Println("=========孔明先生睡了=========")
	go myTimer()
	for i:=0;i<10;i++{
		fmt.Println(i)
		time.Sleep(1*time.Second)
	}
}
 
func myTimer(){
	<-time.After(5* time.Second)
	fmt.Println("*****叮铃铃******\n孔明先生起床了")
}

输出

=========孔明先生睡了=========
0
1
2
3
4
*****叮铃铃******
孔明先生起床了
5
6
7
8
9

1.3 停止

• 语法

timer.Stop()

• 示例

func main() {
	timer := time.NewTimer(3 * time.Second)
	go func() {
		<-timer.C
		fmt.Println("*****叮铃铃*****")
	}()
 
	//关闭定时器
	timer.Stop()
	fmt.Println("【闹钟被关了】")
 
	time.Sleep(5*time.Second)
 
}

1.4 定时器重置

• 语法

timer.Reset(5 * time.Second)

返回布尔值

• 作用
  闹钟重置后，之前的失效，从重置时刻起重新计时

• 示例

func main() {
	fmt.Println("=========孔明先生睡了=========")
	go myTimer()
	for i:=0;i<15;i++{
		fmt.Println(i)
		time.Sleep(1*time.Second)
	}
}
 
func myTimer()  {
	timer := time.NewTimer(5 * time.Second)
	time.Sleep(4*time.Second)
	flag := timer.Reset(8 * time.Second)
	if flag {
		fmt.Println("【闹钟重置成功】")
	}
	<-timer.C
	fmt.Println("********叮铃铃**********\n孔明先生起床了")
}

输出：

=========孔明先生睡了=========
0
1
2
3
4
【闹钟重置成功】
5
6
7
8
9
10
11
12
********叮铃铃**********
孔明先生起床了
13
14

2 断续器

2.1 断续器使用

• 作用：每隔N秒向通道中发一个时间

• 语法

time.NewTicker(N * time.Second)

示例：

ticker := time.NewTicker(1 * time.Second)

• 示例

func main() {
    go myTimer()
	time.Sleep(10*time.Second)
}
 
func myTimer(){
	ticker := time.NewTicker(1 * time.Second)
	fmt.Println("========  长沟流月  白驹过隙  ========")
	for {
		t := <-ticker.C
		fmt.Println("秒钟 = ",t.Second())
	}
}

输出

========  长沟流月  白驹过隙  ========
秒钟 =  27
秒钟 =  28
秒钟 =  29
秒钟 =  30
秒钟 =  31
秒钟 =  32
秒钟 =  33
秒钟 =  34
秒钟 =  35
秒钟 =  36

2.2 断续器中断

func main() {
	ticker := time.NewTicker(1 * time.Second)
	fmt.Println("========  老狼老狼几点了？  ========")
	for {
		t := <-ticker.C
		c := t.Second()%12
		if c == 0 {
			ticker.Stop()
			fmt.Println("老狼：12点了！！嗷~~~~~")
			break
		}
		fmt.Printf("老狼：%d 点了~ \n",c)
 
	}
}

• 输出

========  老狼老狼几点了？  ========
老狼：4 点了~ 
老狼：5 点了~ 
老狼：6 点了~ 
老狼：7 点了~ 
老狼：8 点了~ 
老狼：9 点了~ 
老狼：10 点了~ 
老狼：11 点了~ 
老狼：12点了！！嗷~~~~~

---