Go语言精修（尚硅谷笔记）第十六章

Posted 2023-04-05 瞧帆

十六、goroutine和channel

16.1 goroutine线程-基本介绍

• 进程就是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位
• 线程是进程的一个执行实例，是程序执行的最小单元，它是比进程更小的能独立运行的基本单位
• 一个进程可以创建销毁多个线程，同一个进程中的多个线程可以并发执行
• 一个程序至少一个进程，一个进程至少一个线程

• 并发和并行

1 ) 多线程程序在单核上运行，就是并发

2 ) 多线程程序在多核上运行，就是并行

并发：因为是在一个cpu上，比如有10个线程，每个线程执行10毫秒（进行轮询操作），从人的角度看，好像这10个线程都在运行，但是从微观上看，在某一个时间点看，其实只有一个线程在执行，这就是并发。

并行：因为是在多个cpu上（比如有10个cpu），比如有10个线程，每个线程执行10毫秒（各自在不同cpu上执行），从人的角度看，这10个线程都在运行，但是从微观上看，在某一个时间点看，也同时有10个线程在执行，这就是并行。

16.2 Go协程和Go主线程

• Go主线程(有程序员直接称为线程/也可以理解成进程): 一个Go线程上，可以起多个协程，你可以 这样理解，协程是轻量级的线程[编译器做优化]。

• Go协程的特点

  1 ) 有独立的栈空间

  2 ) 共享程序堆空间

  3 ) 调度由用户控制

  4 ) 协程是轻量级的线程

• 一个示意图

• 请编写一个程序，完成如下功能:

1 ) 在主线程(可以理解成进程)中，开启一个goroutine, 该协程每隔 1 秒输出 “hello,world”

2 ) 在主线程中也每隔一秒输出"hello,golang", 输出 10 次后，退出程序

3 ) 要求主线程和goroutine同时执行

4 ) 画出主线程和协程执行流程图

package main
import (
	"fmt"
	"strconv"
	"time"
)

// 在主线程(可以理解成进程)中，开启一个goroutine, 该协程每隔1秒输出 "hello,world"
// 在主线程中也每隔一秒输出"hello,golang", 输出10次后，退出程序
// 要求主线程和goroutine同时执行

//编写一个函数，每隔1秒输出 "hello,world"
func test() 
	for i := 1; i <= 10; i++ 
		fmt.Println("tesst () hello,world " + strconv.Itoa(i))
		time.Sleep(time.Second)
	


func main() 

	go test() // 开启了一个协程

	for i := 1; i <= 10; i++ 
		fmt.Println(" main() hello,golang" + strconv.Itoa(i))
		time.Sleep(time.Second)
	

输出的效果说明，main这个主线程和 test 协程同时执行

 main() hello,golang1
tesst () hello,world 1
 main() hello,golang2
tesst () hello,world 2
 main() hello,golang3
tesst () hello,world 3
 main() hello,golang4
tesst () hello,world 4
 main() hello,golang5
tesst () hello,world 5
 main() hello,golang6
tesst () hello,world 6
 main() hello,golang7
tesst () hello,world 7
 main() hello,golang8
tesst () hello,world 8
 main() hello,golang9
tesst () hello,world 9
 main() hello,golang10
tesst () hello,world 10

• 协程特点

1 ) 主线程是一个物理线程，直接作用在cpu上的。是重量级的，非常耗费cpu资源。

2 ) 协程从主线程开启的，是轻量级的线程，是逻辑态。对资源消耗相对小。

3 ) Golang的协程机制是重要的特点，可以轻松的开启上万个协程。其它编程语言的并发机制是一般基于线程的，开启过多的线程，资源耗费大，这里就突显Golang在并发上的优势了

16.3 MPG模式基本介绍

• M:操作系统的主线程（是物理线程）
• P:协程执行需要的上下文
• G：协程

16.3.1 MPG模式运行的状态 1

• 当前程序有三个M，如果三个M都在一个cpu运行，就是并发，如果在不同的cpu运行就是并行
• M1，M2，M3正在执行一个G，M1的协程队列有三个，M2的协程队列有3个，M3协程队列有2个
• 从上图可以看到:Go的协程是轻量级的线程，是逻辑态的，Go可以容易的起上万个协程。
• 其他程序c/java的多线程，往往是内核态的，比较重量级，几千个线程可能耗光cpu

16.3.2 MPG模式运行的状态 2

• 设置GOLANG运行的CPU数

• 为了充分了利用多cpu的优势，在Golang程序中，设置运行的cpu数目

package main
import (
	"runtime"
	"fmt"
)

func main() 
	cpuNum := runtime.NumCPU()
	fmt.Println("cpuNum=", cpuNum)

	//可以自己设置使用多个cpu
	runtime.GOMAXPROCS(cpuNum - 1)
	fmt.Println("ok")

• go1.8后，默认让程序运行在多个核上，可以不用设置了
• go1.8前，还是要设置以下，可以更高效的利用cpu

16.4 channel管道介绍

1. 使用goroutine 来完成，效率高，但是会出现并发/并行安全问题

   package main
   import (
   	"fmt"
   	"time"
   )
   
   // 需求：现在要计算 1-200 的各个数的阶乘，并且把各个数的阶乘放入到map中。
   // 最后显示出来。要求使用goroutine完成 
   
   // 思路
   // 1. 编写一个函数，来计算各个数的阶乘，并放入到 map中.
   // 2. 我们启动的协程多个，统计的将结果放入到 map中
   // 3. map 应该做出一个全局的.
   
   var (
   	myMap = make(map[int]int, 10)  
   )
   
   // test 函数就是计算 n!, 让将这个结果放入到 myMap
   func test(n int) 
   	
   	res := 1
   	for i := 1; i <= n; i++ 
   		res *= i
   	
   
   	//这里我们将 res 放入到myMap
   	myMap[n] = res //concurrent map writes?
   
   
   func main() 
   
   	// 我们这里开启多个协程完成这个任务[200个]
   	for i := 1; i <= 200; i++ 
   		go test(i)
   	
   
   
   	//休眠10秒钟【第二个问题 】
   	time.Sleep(time.Second * 10)
   
   	//这里我们输出结果,变量这个结果
   	for i, v := range myMap 
   		fmt.Printf("map[%d]=%d\\n", i, v)
   	
   
   

   

2. 这里就提出了不同goroutine如何通信的问题

   • 1 ) 全局变量的互斥锁
   • 2 ) 使用管道channel来解决

16.4.1 全局变量加锁同步改进程序

• 因为没有对全局变量 m 加锁，因此会出现资源争夺问题，代码会出现错误，提示concurrent map writes
• 解决方案：加入互斥锁
• 我们的数的阶乘很大，结果会越界,可以将求阶乘改成 sum+=uint 64 (i)

package main
import (
	"fmt"
	_ "time"
	"sync"
)

// 需求：现在要计算 1-200 的各个数的阶乘，并且把各个数的阶乘放入到map中。
// 最后显示出来。要求使用goroutine完成 

// 思路
// 1. 编写一个函数，来计算各个数的阶乘，并放入到 map中.
// 2. 我们启动的协程多个，统计的将结果放入到 map中
// 3. map 应该做出一个全局的.

var (
	myMap = make(map[int]int, 10)  
	//声明一个全局的互斥锁
	//lock 是一个全局的互斥锁， 
	//sync 是包: synchornized 同步
	//Mutex : 是互斥
	lock sync.Mutex
)

// test 函数就是计算 n!, 让将这个结果放入到 myMap
func test(n int) 
	
	res := 1
	for i := 1; i <= n; i++ 
		res *= i
	

	//这里我们将 res 放入到myMap
	//加锁
	lock.Lock()
	myMap[n] = res //concurrent map writes?
	//解锁
	lock.Unlock()


func main() 

	// 我们这里开启多个协程完成这个任务[200个]
	for i := 1; i <= 20; i++ 
		go test(i)
	

	//休眠10秒钟【第二个问题 】
	//time.Sleep(time.Second * 5)

	//这里我们输出结果,变量这个结果
	lock.Lock()
	for i, v := range myMap 
		fmt.Printf("map[%d]=%d\\n", i, v)
	
	lock.Unlock()

16.4.2 为什么需要channel

1. 前面使用全局变量加锁同步来解决goroutine的通讯，但不完美
2. 主线程在等待所有goroutine全部完成的时间很难确定，我们这里设置 10 秒，仅仅是估算。
3. 如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有goroutine处于工作状态，这时也会随主线程的退出而销毁
4. 通过全局变量加锁同步来实现通讯，也并不利用多个协程对全局变量的读写操作。
5. 上面种种分析都在呼唤一个新的通讯机制-channel

16.4.3 channel介绍

1. channle本质就是一个数据结构-队列【示意图】
2. 数据是先进先出【FIFO:firstinfirstout】
3. 线程安全，多goroutine访问时，不需要加锁，就是说channel本身就是线程安全的
4. channel有类型的，一个string的channel只能存放string类型数据。
5. 示意图：

• 定义声明channel

  var 变量名 chan 数据类型
  

  • 举例：

  var intChan chan int(intChan用于存放int数据)
  var mapChan chan map[int]string(mapChan用于存放map[int]string类型)
  var perChan chan Person
  var perChan2 chan *Person
  

说明

• channel是引用类型
• channel必须初始化才能写入数据, 即make后才能使用
• 管道是有类型的，intChan 只能写入 整数 int

16.5 管道初始化写入数据读出数据

package main
import (
	"fmt"
)

func main() 

	//演示一下管道的使用
	//1. 创建一个可以存放3个int类型的管道
	var intChan chan int
	intChan = make(chan int, 3)

	//2. 看看intChan是什么
	fmt.Printf("intChan 的值=%v intChan本身的地址=%p\\n", intChan, &intChan)


	//3. 向管道写入数据
	intChan<- 10
	num := 211
	intChan<- num
	intChan<- 50
	// //如果从channel取出数据后，可以继续放入
	<-intChan
	intChan<- 98//注意点, 当我们给管写入数据时，不能超过其容量

	//4. 看看管道的长度和cap(容量)
	fmt.Printf("channel len= %v cap=%v \\n", len(intChan), cap(intChan)) // 3, 3

	//5. 从管道中读取数据

	var num2 int
	num2 = <-intChan 
	fmt.Println("num2=", num2)
	fmt.Printf("channel len= %v cap=%v \\n", len(intChan), cap(intChan))  // 2, 3

	//6. 在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告 deadlock

	num3 := <-intChan
	num4 := <-intChan

	//num5 := <-intChan

	fmt.Println("num3=", num3, "num4=", num4/*, "num5=", num5*/)

16.6 管道阻塞

什么时候阻塞

• 向一个值为nil的管道写或读数据
• 无缓冲区时单独的写或读数据
• 缓冲区为空时进行读数据
• 缓冲区满时进行写数据

常见错误

• 关闭值为nil的管道
• 关闭已经关闭的管道
• 往已经close的管道发送数据会panic

**注意：

从已关闭的通道接收数据时将不会发生阻塞

由此可见通道如果不主动close掉，读出通道全部数据后该协程就会阻塞

从已经关闭的通道接收数据或者正在接收数据时，将会接收到通道类型的零值，然后停止阻塞并返回。

16.7 注意事项

1. channel中只能存放指定的数据类型
2. channle的数据放满后，就不能再放入了
3. 如果从channel取出数据后，可以继续放入
4. 在没有使用协程的情况下，如果channel数据取完了，再取，就会报deadlock

• 使用例子

1）创建一个intChan，最多可以存放3个int，演示存3数据到intChan，然后再取出这三个int

package main

import (
	"fmt"
)

func main() 
	var intChan chan int
	intChan = make(chan int, 3)
	intChan <- 10
	intChan <- 20
	intChan <- 10
	//因为intChan 的容量为3，再存放会报deadlock
	//intChan <- 50
	num1 := <-intChan
	num2 := <-intChan
	num3 := <-intChan
	//因为intChan 这时已经没有数据了，再取就会报deadlock
	//num3 := <- intChan
	fmt.Printf("num1=%v num2=%v num3=%v", num1, num2, num3)

2）创建一个mapChan，最多可以存放10个map[string]string的key-val，演示写入和读取

package main

import (
	"fmt"
)

func main() 
	var mapChan chan map[string]string
	mapChan = make(chan map[string]string, 10)
	m1 := make(map[string]string, 20)
	m1["city1"] = "北京"
	m1["city2"] = "天津"

	m2 := make(map[string]string, 20)
	m2["hero1"] = "宋江"
	m2["hero2"] = "武松"

	mapChan <- m1
	mapChan <- m2

	m11 := <-mapChan
	m22 := <-mapChan

	fmt.Println(m11, m22)

3）创建一个catChan，最多可以存放10个Cat结构体变量

package main

import (
	"fmt"
)

type Cat struct 
	Name string
	Age  byte


func main() 
	var catChan chan Cat
	catChan = make(chan Cat, 10)
	cat1 := CatName: "tom", Age: 18
	cat2 := CatName: "tom~", Age: 180

	catChan <- cat1
	catChan <- cat2

	//取出
	cat11 := <-catChan
	cat22 := <-catChan

	fmt.Println(cat11, cat22)

4）创建一个catChan2，最多可以存放10个*Cat变量，演示写入和读取的方法

package main

import (
	"fmt"
)

type Cat struct 
	Name string
	Age  byte


func main() 
	var catChan chan *Cat
	catChan = make(chan *Cat, 10)
	cat1 := CatName: "tom", Age: 18
	cat2 := CatName: "tom~", Age: 180

	catChan <- &cat1
	catChan <- &cat2

	//取出
	cat11 := <-catChan
	cat22 := <-catChan

	fmt.Println(cat11, cat22)

5）创建一个allChan，最多可以存放10个任意数据类型变量，演示写入和读取的用法

package main

import (
	"fmt"
)

type Cat struct 
	Name string
	Age  byte


func main() 

	var allChan chan interface
	allChan = make(chan interface, 10)

	cat1 := CatName: "tom", Age: 18
	cat2 := CatName: "tom~", Age: 180

	allChan <- cat1
	allChan <- cat2
	allChan <- 10
	allChan <- "jack"

	//取出
	cat11 := <-allChan
	cat22 := <-allChan
	v1 := <-allChan
	v2 := <-allChan

	fmt.Println(cat11, cat22, v1, v2)

6）看下面代码，会输出什么？

package main

import (
	"fmt"
)

type Cat struct 
	Name string
	Age  byte


func main() 

	var allChan chan interface
	allChan = make(chan interface, 10)

	cat1 := CatName: "tom", Age: 18

	allChan <- cat1

	//取出
	newCat := <-allChan //从管道中取出的cat是什么？
	fmt.Printf("newCat=%T,newCat=%v\\n", newCat, newCat)
	//下面的写法是错误的！编译不通过
	//fmt.Printf("newCat.Name=%v",newCat.Name)

	//使用类型断言
	a := newCat.(Cat)
	fmt.Printf("newCat.Name=%v", a.Name)

7. channel可以声明为只读，或者只写性质

   package main
   import (
   	"fmt"
   )
   
   func main() 
   	//管道可以声明为只读或者只写
   
   	//1. 在默认情况下下，管道是双向
   	//var chan1 chan int //可读可写
   	
   	//2 声明为只写
   	var chan2 chan<- int
   	chan2 = make(chan int, 3)
   	chan2<- 20
   	//num := <-chan2 //error
   
   	fmt.Println("chan2=", chan2)
   
   	//3. 声明为只读
   	var chan3 <-chan int
   	num2 := <-chan3
   	//chan3<- 30 //err
   	fmt.Println("num2", num2)
   
   
   

   channel只读和只写的最佳实践案例

   package main
   
   import (
   	"fmt"
   )
   
   // ch chan<- int,这样ch就只能写操作
   func send(ch chan<- int, exitChan chan struct) 
   	for i := 0; i < 10; i++ 
   		ch <- i
   	
   	close(ch)
   	var a struct
   	exitChan <- a
   
   
   // ch <-chan int,这样ch就只能读操作
   func recv(ch <-chan int, exitChan chan struct) 
   	for 
   		v, ok := <-ch
   		if !ok 
   			break
   		
   		fmt.Println(v)
   	
   	var a struct
   	exitChan <- a
   
   
   func main() 
   	var ch chan int
   	ch = make(chan int, 10)
   	exitChan := make(chan struct, 2)
   	go send(ch, exitChan)
   	go recv(ch, exitChan)
   
   	var total = 0
   	for _ = range exitChan 
   		total++
   		if total == 2 
   			break
   		
   	
   	fmt.Println("结束。。。")
   
   

16.7.8 select：可以解决从管道取数据的阻塞问题

select是go语言当中提供的一个选择语句。select的语法类似switch语句，也属于控制语句。

那为什么select语句我们没有放在和if、switch语句一起？

因为select是配合channel通道使用的。每个 case 必须是一个通信操作，要么是发送要么是接收。

select特性

• select只能用于channel操作，每个case都必须是一个channel；

• 如果有多个case可以允许（channel没有阻塞），则随机选择一条case语句执行；

• 如果没有case语句可以执行（channel发生阻塞），切没有default语句，则select语句会阻塞；

• 如果没有case语句可以执行（channel发生阻塞），有default语句，则执行default语句；

• 一般使用超时语句代替default语句；

  func main() 
  	ch1 := make(chan int)
  	ch2 := make(chan int)
   
  	select 
  	case num1 := <-ch1:
  		fmt.Println("ch1中的数据是:", num1)
  	case num2 := <-ch2:
  		fmt.Println("ch2中的数据是:", num2)
  	case <-time.After(3 * time.Second):
  		fmt.Println("timeout...")
  	
  
  

• 如果case语句中的channel为nil，则忽略该分支，相当于从select中删除了该分支；

• 如果select语句在for循环中，一般不使用default语句，因为会引起CPU占用过高问题。

select语法格式

select 
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);

例子：

package main
import (
	"fmt"
	"time"
)

func main() 

	//使用select可以解决从管道取数据的阻塞问题

	//1.定义一个管道 10个数据int
	intChan := make(chan int, 五、程序流程控制 
5.1 单分支控制
 
package main
import (
	"fmt" 
)

func main() 

	//请大家看个案例[ifDemo.go]:
	//编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出 "你年龄大
	//于18,要对自己的行为负责!"

	//分析 
	//1.年龄 ==> var age int 
	//2.从控制台接收一个输入 fmt.Scanln(&age)
	//3.if判断

	var age int
	fmt.Println("请输入年龄:")
	fmt.Scanln(&age)

	if age > 18 
		fmt.Println("你年龄大于18,要对自己的行为负责!")
	

	//golang支持在if中，直接定义一个变量，比如下面
	if age := 20; age > 18 
		fmt.Println("你年龄大于18,要对自己的行为负责!")
		

 
5.2 双分支控制
 
if 条件表达式
	执行代码块1
else
	执行代码块2

 
package main
import (
	"fmt" 
)

func main() 
    var x int = 4
    if x > 2
        fmt.Println("ok")
    else
        fmt.Println("hello")
    
    //编译错误，if没有


 
package main
import (
	"fmt" 
)

func main() 
    var x int = 4
    if x > 2
        fmt.Println("ok")
        
    else
        fmt.Println("hello")
    
    //编译错误，else不能换行

 
5.3 多分支控制
 
if 条件表达式1
	执行代码块1
else if 条件表达式2
	执行代码块2

......
else
	执行代码块n

 
5.4 switch分支控制
 
1 ) switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上到下逐一测 试，直到匹配为止。
 
2 ) 匹配项后面也不需要再加 break
 
switch 表达式
    case 表达式1，表达式2，..:
    	语句块1
    fallthrough//穿透 如果有这个则会继续执行下面的case
    case 表达式3，表达式4，..:
    	语句块2
    ...
    default://没有任何case匹配 折执行default 不是必须的
    	语句块

 
使用细节
 
1 ) case/switch后是一个表达式( 即：常量值、变量、一个有返回值的函数等都可以)
 
2 ) case后的各个表达式的值的数据类型，必须和 switch 的表达式数据类型一致
 
package main
import (
	"fmt" 
)

func main() 
	var n1 int32 = 20
    var n2 int64 = 20
	switch n1  //错误，原因是n2和n1数据类型不一致      
		case n2:
			fmt.Println("ok1")
		default:
			fmt.Println("没有匹配到...")
	

 
3 ) case后面可以带多个表达式，使用逗号间隔。比如 case 表达式 1 , 表达式 2 …
 
package main
import (
	"fmt" 
)

func main() 
	var n1 int32 = 51
	var n2 int32 = 20
	switch n1 
		case n2, 10, 5 :  // case 后面可以有多个表达式
			fmt.Println("ok1")
		case 90 : 
			fmt.Println("ok2~")
		
	

 
4 ) case后面的表达式如果是常量值(字面量)，则要求不能重复
 
package main
import (
	"fmt" 
)

func main() 
	var n1 int32 = 51
	var n2 int32 = 20
	switch n1 
		case n2, 10, 5 :  // case 后面可以有多个表达式
			fmt.Println("ok1")
		case 5 : //错误，前面已经有常量5了，不能重复
			fmt.Println("ok2~")
		default:
			fmt.Println("没有匹配到...")
	

 
5.) case后面不需要带break, 程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行 default
 
6 ) default 语句不是必须的.
 
7 ) switch 后也可以不带表达式，类似 if–else分支来使用。【案例演示】
 
package main
import (
	"fmt" 
)

func main() 
	//switch 后也可以不带表达式，类似 if --else分支来使用。【案例演示】
	var age int = 10
	
	switch 
		case age == 10 :
			fmt.Println("age == 10")
		case age == 20 :
			fmt.Println("age == 20")
		default :
			fmt.Println("没有匹配到")
	
    
    //case 中也可以对 范围进行判断
	var score int = 90
	switch 
		case score > 90 :
			fmt.Println("成绩优秀..")
		case score >=70 && score <= 90 :
			fmt.Println("成绩优良...")
		case score >= 60 && score < 70 :
			fmt.Println("成绩及格...")
		default :
			fmt.Println("不及格")
	

 
8 ) switch 后也可以直接声明/定义一个变量，分号结束，不推荐。 【案例演示】
 
package main
import (
	"fmt" 
)

func main() 
	//switch 后也可以直接声明/定义一个变量，分号结束，不推荐	
	switch grade := 90;  // 在golang中，可以这样写
		case grade > 90 :
			fmt.Println("成绩优秀~..")
		case grade >=70 && grade <= 90 :
			fmt.Println("成绩优良~...")
		case grade >= 60 && grade < 70 :
			fmt.Println("成绩及格~...")
		default :
			fmt.Println("不及格~")
	

 
9 ) switch 穿透-fallthrough ，如果在case语句块后增加fallthrough,则会继续执行下一个case，也 叫switch穿透
 
package main
import (
	"fmt" 
)

func main() 
	//switch 的穿透 fallthrought
	var num int = 10
	switch num 
		case 10:
			fmt.Println("ok1")
			fallthrough //默认只能穿透一层
		case 20:
			fmt.Println("ok2")
			fallthrough
		case 30:
			fmt.Println("ok3")	
		default:
			fmt.Println("没有匹配到..")
	

 
10 ) TypeSwitch：switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型
 
package main
import (
	"fmt" 
)

func main() 
	
    var x interface
    var y = 10.0
    x = y
    switch x := x.(type) 
		case nil:
			fmt.Println("x 的类型：%T",i)
		case int:
			fmt.Println("x 是int型")
		case float64:
			fmt.Println("x 是float型")	
        case func(int) float:
			fmt.Println("x 是func(int) float")	 		case bool, string:
			fmt.Println("x 是bool 或 string型")     		default:
			fmt.Println("未知型..")
	

 
5.5 for循环
 
1）基本语法
 
for 循环变量初始化; 循环条件; 循环变量迭代 
	循环操作(语句)

 
2）for循环的第二种使用方式
 
for 循环判断条件 
	//循环执行语句

 
将变量初始化和变量迭代写到其它位置
 
案例演示：
 
package main
import (
	"fmt"
)
func main()
	//for循环的第二种写法
	j := 1 //循环变量初始化
	for j <= 10  //循环条件
        
		fmt.Println("你好，Golang Roadmap~", j)
		j++ //循环变量迭代
	

 
3 ) for循环的第三种使用方式
 
for 
//循环执行语句

 
上面的写法等价 for;; 是一个无限循环， 通常需要配合 break 语句使用
 
package main
import (
	"fmt"
)
func main()
	//for循环的第三种写法, 这种写法通常会配合break使用
	k := 1
	for   // 这里也等价 for ; ;  
		if k <= 10 
			fmt.Println("你好，Golang Roadmap~", k)
		 else 
			break //break就是跳出这个for循环
		
		k++
	

 
4 ) Golang 提供 for-range的方式，可以方便遍历字符串和数组(注: 数组的遍历，我们放到讲数组 的时候再讲解) ，案例说明如何遍历字符串。 字符串遍历方式 1 - 传统方式
 
package main
import (
	"fmt"
)
func main()
	//字符串遍历方式1-传统方式
	var str string = "hello,world!北京"
	for i := 0; i < len(str); i++ 
		fmt.Printf("%c \\n", str[i]) //使用到下标...
	

 
字符串遍历方式 2 - for-range
 
package main
import (
	"fmt"
)
func main()
	//字符串遍历方式2-for-range
	str = "abc~ok上海"
	for index, val := range str 
		fmt.Printf("index=%d, val=%c \\n", index, val)
	

 
如果我们的字符串含有中文，那么传统的遍历字符串方式，就是错误，会出现乱码。原因是传统的对字符串的遍历是按照字节来遍历，而一个汉字在utf 8 编码是对应 3 个字节。
 
如何解决 需要要将 str 转成 []rune切片
 
package main
import (
	"fmt"
)
func main()
	//字符串遍历方式1-传统方式
	var str string = "hello,world!北京"
	str2 := []rune(str) // 就是把 str 转成 []rune
	for i := 0; i < len(str2); i++ 
		fmt.Printf("%c \\n", str2[i]) //使用到下标...
	

 
对应for-range遍历方式而言，是按照字符方式遍历。因此如果有字符串有中文，也是ok
 
5.6 WHILE和DO…WHILE的实现
 
Go语言没有while和do…while语法，这一点需要同学们注意一下，如果我们需要使用类似其它语言(比如 java/c 的 while 和 do…while)，可以通过 for 循环来实现其使用效果。
 
while循环的实现
 
循环变量初始化
for
    if循环条件表达式
        break//跳出for循环
    
    循环操作语句
    循环变量迭代

 
说明上图
 
1 ) for循环是一个无限循环
 
2 ) break 语句就是跳出for循环
 
使用上面的while实现完成输出 10 句”hello,wrold”
 
package main
import "fmt"

func main()

	//使用while方式输出10句 "hello,world"
	//循环变量初始化
	var i int = 1
	for 
		if i > 10  //循环条件
			break // 跳出for循环,结束for循环
		
		fmt.Println("hello,world", i)
		i++ //循环变量的迭代
	

	fmt.Println("i=", i)

 
do…while的实现
 
循环变量初始化
for
    循环操作语句
    循环变量迭代
    if循环条件表达式
        break//跳出for循环
    

 
对上图的说明
 
1 ) 上面的循环是先执行，在判断，因此至少执行一次。
 
2 ) 当循环条件成立后，就会执行break,break就是跳出for循环，结束循环.
以上是关于Go语言精修（尚硅谷笔记）第十六章的主要内容，如果未能解决你的问题，请参考以下文章
 
 Go语言精修（尚硅谷笔记）第五章
 Golang✔️走进 Go 语言✔️ 第十六课 协程 & 通道
 Golang✔️走进 Go 语言✔️ 第十六课 协程 & 通道
 算法导论第十六章
 Go语言视频免费下载了！尚硅谷韩顺平老师再次发力！
 尚硅谷韩顺平Go语言核心编程