GoLang补充提升（六）

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)
	}
}