Go语言学习笔记part6

strconv标准库介绍

strconv包实现了基本数据类型与其字符串表示的转换，主要有以下常用函数： Atoi()、Itia()、parse系列、format系列、append系列。

string与int类型转换

Atoi()

Atoi()函数用于将字符串类型的整数转换为int类型，函数签名如下。

  1. func Atoi(s string) (i int, err error)

Itoa()

Itoa()函数用于将int类型数据转换为对应的字符串表示，具体的函数签名如下。

  1. func Itoa(i int) string

Parse系列函数

Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

ParseBool()

  1. func ParseBool(str string) (value bool, err error)

返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误。

ParseInt()

  1. func ParseInt(s string, base int, bitSize int) (i int64, err error)

返回字符串表示的整数值，接受正负号。

base指定进制（2到36），如果base为0，则会从字符串前置判断，”0x”是16进制，”0”是8进制，否则是10进制；

bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64；

返回的err是*NumErr类型的，如果语法有误，err.Error = ErrSyntax；如果结果超出类型范围err.Error = ErrRange。

ParseFloat()

  1. func ParseFloat(s string, bitSize int) (f float64, err error)

解析一个表示浮点数的字符串并返回其值。

如果s合乎语法规则，函数会返回最为接近s表示值的一个浮点数（使用IEEE754规范舍入）。

bitSize指定了期望的接收类型，32是float32（返回值可以不改变精确值的赋值给float32），64是float64；

返回值err是*NumErr类型的，语法有误的，err.Error=ErrSyntax；结果超出表示范围的，返回值f为±Inf，err.Error= ErrRange。

Format系列

Format系列函数实现了将给定类型数据格式化为string类型数据的功能。

FormatBool()

  1. func FormatBool(b bool) string

根据b的值返回”true”或”false”。

FormatInt()

  1. func FormatInt(i int64, base int) string

返回i的base进制的字符串表示。base 必须在2到36之间，结果中会使用小写字母’a’到’z’表示大于10的数字。

FormatUint()

  1. func FormatUint(i uint64, base int) string

是FormatInt的无符号整数版本。

FormatFloat()

  1. func FormatFloat(f float64, fmt byte, prec, bitSize int) string

函数将浮点数表示为字符串并返回。

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

fmt表示格式：’f’（-ddd.dddd）、’b’（-ddddp±ddd，指数为二进制）、’e’（-d.dddde±dd，十进制指数）、’E’（-d.ddddE±dd，十进制指数）、’g’（指数很大时用’e’格式，否则’f’格式）、’G’（指数很大时用’E’格式，否则’f’格式）。

prec控制精度（排除指数部分）：对’f’、’e’、’E’，它表示小数点后的数字个数；对’g’、’G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。

其他

isPrint()

  1. func IsPrint(r rune) bool

返回一个字符是否是可打印的，和unicode.IsPrint一样，r必须是：字母（广义）、数字、标点、符号、ASCII空格。

CanBackquote()

  1. func CanBackquote(s string) bool

返回字符串s是否可以不被修改的表示为一个单行的、没有空格和tab之外控制字符的反引号字符串。

并发1

Go语言的并发通过goroutine实现。goroutine类似于线程，属于用户态的线程，我们可以根据需要创建成千上万个goroutine并发工作。goroutine是由Go语言的运行时（runtime）调度完成，而线程是由操作系统调度完成。

Go语言还提供channel在多个goroutine间进行通信。goroutine和channel是 Go 语言秉承的 CSP（Communicating Sequential Process）并发模式的重要实现基础。

goroutine

Go语言中的goroutine就是这样一种机制，goroutine的概念类似于线程，但 goroutine是由Go的运行时（runtime）调度和管理的。Go程序会智能地将 goroutine 中的任务合理地分配给每个CPU。Go语言之所以被称为现代化的编程语言，就是因为它在语言层面已经内置了调度和上下文切换的机制。

使用goroutine

Go语言中使用goroutine非常简单，只需要在调用函数的时候在前面加上go关键字，就可以为一个函数创建一个goroutine。

一个goroutine必定对应一个函数，可以创建多个goroutine去执行相同的函数。

启动多个goroutine

在Go语言中实现并发就是这样简单，我们还可以启动多个goroutine。让我们再来一个例子： （这里使用了sync.WaitGroup来实现goroutine的同步）

  1. var wg sync.WaitGroup
  3. func hello(i int) {
  4.     defer wg.Done() // goroutine结束就登记-1
  5.     fmt.Println("Hello Goroutine!", i)
  6. }
  7. func main() {
  9.     for i := 0; i < 10; i++ {
  10.         wg.Add(1) // 启动一个goroutine就登记+1
  11.         go hello(i)
  12.     }
  13.     wg.Wait() // 等待所有登记的goroutine都结束
  14. }

多次执行上面的代码，会发现每次打印的数字的顺序都不一致。这是因为10个goroutine是并发执行的，而goroutine的调度是随机的。

goroutine的一些理论知识

goroutine与线程

goroutine是用户态的线程，OS线程（操作系统线程）一般都有固定的栈内存（通常为2MB）,一个goroutine的栈在其生命周期开始时只有很小的栈（典型情况下2KB），goroutine的栈不是固定的，他可以按需增大和缩小，goroutine的栈大小限制可以达到1GB，虽然极少会用到这么大。所以在Go语言中一次创建十万左右的goroutine也是可以的。

goroutine调度模型

GPM是Go语言运行时（runtime）层面的实现，是go语言自己实现的一套调度系统。区别于操作系统调度OS线程。

  • G很好理解，就是个goroutine的，里面除了存放本goroutine信息外 还有与所在P的绑定等信息。
  • P管理着一组goroutine队列，P里面会存储当前goroutine运行的上下文环境（函数指针，堆栈地址及地址边界），P会对自己管理的goroutine队列做一些调度（比如把占用CPU时间较长的goroutine暂停、运行后续的goroutine等等）当自己的队列消费完了就去全局队列里取，如果全局队列里也消费完了会去其他P的队列里抢任务。
  • M（machine）是Go运行时（runtime）对操作系统内核线程的虚拟， M与内核线程一般是一一映射的关系， 一个groutine最终是要放到M上执行的；

P与M一般也是一一对应的。他们关系是： P管理着一组G挂载在M上运行。当一个G长久阻塞在一个M上时，runtime会新建一个M，阻塞G所在的P会把其他的G 挂载在新建的M上。当旧的G阻塞完成或者认为其已经死掉时 回收旧的M。

P的个数是通过runtime.GOMAXPROCS设定（最大256），Go1.5版本之后默认为物理线程数。 在并发量大的时候会增加一些P和M，但不会太多，切换太频繁的话得不偿失。

GOMAXPROCS

Go运行时的调度器使用GOMAXPROCS参数来确定需要使用多少个OS线程来同时执行Go代码。默认值是机器上的CPU核心数。例如在一个8核心的机器上，调度器会把Go代码同时调度到8个OS线程上（GOMAXPROCS是m:n调度中的n）。

Go语言中可以通过runtime.GOMAXPROCS()函数设置当前程序并发时占用的CPU逻辑核心数。

Go1.5版本之前，默认使用的是单核心执行。Go1.5版本之后，默认使用全部的CPU逻辑核心数。

Go语言中的操作系统线程和goroutine的关系：

  1. 一个操作系统线程对应用户态多个goroutine。
  2. go程序可以同时使用多个操作系统线程。
  3. goroutine和OS线程是多对多的关系，即m:n。

channel

虽然可以使用共享内存进行数据交换，但是共享内存在不同的goroutine中容易发生竞态问题。为了保证数据交换的正确性，必须使用互斥量对内存进行加锁，这种做法势必造成性能问题。

Go语言的并发模型是CSP（Communicating Sequential Processes），提倡通过通信共享内存而不是通过共享内存而实现通信。

如果说goroutine是Go程序并发的执行体，channel就是它们之间的连接。channel是可以让一个goroutine发送特定值到另一个goroutine的通信机制。

Go 语言中的通道（channel）是一种特殊的类型。通道像一个传送带或者队列，总是遵循先入先出（First In First Out）的规则，保证收发数据的顺序。每一个通道都是一个具体类型的导管，也就是声明channel的时候需要为其指定元素类型。

channel类型

channel是一种类型，一种引用类型。声明通道类型的格式如下：

  1. var 变量 chan 元素类型

创建channel

通道是引用类型，通道类型的空值是nil。

  1. var ch chan int
  2. fmt.Println(ch) // <nil>

声明的通道后需要使用make函数初始化之后才能使用。

创建channel的格式如下：

  1. make(chan 元素类型, [缓冲大小])

举几个例子：

  1. //无缓冲区的通道
  2. ch4 := make(chan int)
  3. ch5 := make(chan bool)
  4. ch6 := make(chan []int)

缓冲区

  1. 无缓冲区的通道，又称阻塞的通道，代码会阻塞在发送这一行，必须有另外一个goroutine接收通道中的值，代码才可以继续执行下去。使用无缓冲通道进行通信将导致发送和接收的goroutine同步化。因此，无缓冲通道也被称为同步通道。
  2. 有缓冲区的通道，只要通道的没有占满，代码就不会阻塞。

channel操作

通道有发送（send）、接收(receive）和关闭（close）三种操作。

发送和接收都使用<-符号。

现在我们先使用以下语句定义一个通道：

  1. ch := make(chan int)
  • 发送：将一个值发送到通道中。
    1. ch <- 10 // 把10发送到ch中
  • 接收：从一个通道中接收值。
    1. x := <- ch // 从ch中接收值并赋值给变量x
    2. <-ch       // 从ch中接收值，忽略结果
  • 关闭：我们通过调用内置的close函数来关闭通道。
    1. close(ch)

单向通道

有的时候我们会将通道作为参数在多个任务函数间传递，很多时候我们在不同的任务函数中使用通道都会对其进行限制，比如限制通道在函数中只能发送或只能接收。

  • chan<- int是一个只写单向通道（只能对其写入int类型值），可以对其执行发送操作但是不能执行接收操作；
  • <-chan int是一个只读单向通道（只能从其读取int类型值），可以对其执行接收操作但是不能执行发送操作。
  1. func counter(out chan<- int) {
  2.     for i := 0; i < 100; i++ {
  3.         out <- i
  4.     }
  5.     close(out)
  6. }
  8. func squarer(out chan<- int, in <-chan int) {
  9.     for i := range in {
  10.         out <- i * i
  11.     }
  12.     close(out)
  13. }
  14. func printer(in <-chan int) {
  15.     for i := range in {
  16.         fmt.Println(i)
  17.     }
  18. }
  20. func main() {
  21.     ch1 := make(chan int)
  22.     ch2 := make(chan int)
  23.     go counter(ch1)
  24.     go squarer(ch2, ch1)
  25.     printer(ch2)
  26. }

通道总结

channel常见的异常总结，如下图：

Go_part06 - 图1

worker pool(goroutine池)

在工作中我们通常会使用可以指定启动的goroutine数量–worker pool模式，控制goroutine的数量，防止goroutine泄漏和暴涨。

一个简易的work pool示例代码如下：

  1. func worker(id int, jobs <-chan int, results chan<- int) {
  2.     for j := range jobs {
  3.         fmt.Printf("worker:%d start job:%d\n", id, j)
  4.         time.Sleep(time.Second)
  5.         fmt.Printf("worker:%d end job:%d\n", id, j)
  6.         results <- j * 2
  7.     }
  8. }
  11. func main() {
  12.     jobs := make(chan int, 100)
  13.     results := make(chan int, 100)
  14.     // 开启3个goroutine
  15.     for w := 1; w <= 3; w++ {
  16.         go worker(w, jobs, results)
  17.     }
  18.     // 5个任务
  19.     for j := 1; j <= 5; j++ {
  20.         jobs <- j
  21.     }
  22.     close(jobs)
  23.     // 输出结果
  24.     for a := 1; a <= 5; a++ {
  25.         <-results
  26.     }
  27. }

select多路复用

在某些场景下我们需要同时从多个通道接收数据。通道在接收数据时，如果没有数据可以接收将会发生阻塞。为了应对这种场景，Go内置了select关键字，可以同时响应多个通道的操作。

select的使用类似于switch语句，它有一系列case分支和一个默认的分支。每个case会对应一个通道的通信（接收或发送）过程。select会一直等待，直到某个case的通信操作完成时，就会执行case分支对应的语句。具体格式如下：

  1. select{
  2.     case <-ch1:
  3.         ...
  4.     case data := <-ch2:
  5.         ...
  6.     case ch3<-data:
  7.         ...
  8.     default:
  9.         默认操作
  10. }

使用select语句能提高代码的可读性。

  • 可处理一个或多个channel的发送/接收操作。
  • 如果多个case同时满足，select会随机选择一个。
  • 对于没有case的select{}会一直等待，可用于阻塞main函数。