GoLang补充提升(六)
1.strconv标准库
func main() {
//str := "1000"
//int(str)这种转换是错误的方式
//i := string(1000)这种转换是错误的方式
//1.可以使用strconv包中的ParseInt方法
i1, err := strconv.ParseInt("1000", 10, 64) //10进制,64位
if err != nil {
fmt.Println(err)
return
}
fmt.Println(i1)
//2.可以使用strconv包中的Atoi()方法,直接转换为int类型的值
i2, err := strconv.Atoi("1000")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(i2)
str1 := strconv.FormatInt(989, 16)
fmt.Println(str1)
}
2.sync.WaitGroup
- 当我们想知道多个Goroutine执行完毕时就可以使用
sync.WaitGroup
var wg sync.WaitGroup
func hello(i int) {
defer wg.Done()
fmt.Println(i)
}
func main() {
for i := 0; i < 10; i++ {
wg.Add(1)
go hello(i)
}
wg.Wait()
fmt.Println("完成!")
}
3.GOMAXPROCS
Go运行时的调度器使用GOMAXPROCS参数来确定需要使用多少个 OS 线程来同时执行 Go 代码。默认值是机器上的 CPU 核心数。例如在一个 8 核心的机器上,GOMAXPROCS 默认为 8。Go语言中可以通过runtime.GOMAXPROCS函数设置当前程序并发时占用的 CPU逻辑核心数。(Go1.5版本之前,默认使用的是单核心执行。Go1.5 版本之后,默认使用全部的CPU 逻辑核心数。)
func main() {
//设置核心数,1.5版本后默认使用全部的CPU 逻辑核心数
runtime.GOMAXPROCS(1)
//获取cpu核心数
runtime.NumCPU()
}
4.通道
(1)初识通道
func main() {
c := make(chan int)
go func() {
c <- 10
}()
fmt.Println(<-c)
fmt.Println("完成")
}
(2)练习通道
- 主Goroutine向第一个子Goroutine中写数据
- 当第一个子Goroutine接收到数据后向第二个子Goroutine中写数据
- 第二个子Goroutine接收到了数据后打印输出,告知主Goroutine结束
func main() {
c := make(chan int)
c1 := make(chan int)
var wg sync.WaitGroup
wg.Add(1)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c1)
}
wg.Done()
}()
go func() {
for i := 0; i < 10; i++ {
val := <-c
c1 <- val * val
}
}()
for i := 0; i < 10; i++ {
c <- i
}
wg.Wait()
fmt.Println("完成!")
}
5.select
- 可处理一个或多个 channel 的发送/接收操作。
- 如果多个 case 同时满足,select 会随机选择一个执行。
- 对于没有 case 的 select 会一直阻塞,可用于阻塞 main 函数,防止退出。
func main() {
c := make(chan int, 1)
for i := 1; i <= 10; i++ {
select {
case x := <-c:
fmt.Println(x)
case c <- i:
}
}
}
6.workPool
Goroutine 虽然只占用2k的内存,且效率很高,但是也要进行控制,不能无止境的创建下去,可以使用工作池模式对Goroutine的数量进行限制
- 一个Goroutine去创建随机数
- 创建24个Goroutine去计算,会随机分配Goroutine去计算,最后返回值到主Goroutine中
type job struct {
x int64
}
type result struct {
job *job
sum int64
}
var jobChan = make(chan *job, 100)
var resultChan = make(chan *result, 100)
func random(jobC chan<- *job) {
rand.Seed(time.Now().UnixNano())
for {
num := rand.Int63()
j := &job{
x: num,
}
jobC <- j
time.Sleep(time.Millisecond * 500)
}
}
func calculate(jobC <-chan *job, resultC chan<- *result) {
for true {
val := <-jobC
sum := int64(0)
n := val.x
for n > 0 {
sum += n % 10
n /= 10
}
newResult := &result{
job: val,
sum: sum,
}
resultC <- newResult
}
}
func main() {
go random(jobChan)
for i := 0; i < 24; i++ {
go calculate(jobChan, resultChan)
}
for {
res := <-resultChan
fmt.Println(res.job.x, res.sum)
}
}