风离不摆烂学习日志 Day2

GO 协程

结论：

主线程是一个物理线程，直接作用在cpu上。是重量级的，非常耗费cpu资源。
协程是从主线程开启的，是轻量级的线程，是逻辑态。对资源消耗相对小。
Golang的协程机制是重要的特点，可以轻松地开启上万个协程。其它编程语言的并发机制是一般基于线程的，开启过多的线程，资源耗费大，这里就突显了Golang在并发上的优势了。

go协程的特点：
1）有独立的栈空间
2）共享程序堆空间
3）调度由用户控制
4）协程是轻量级的线程

示例:

package main

import (
	"fmt"
	"strconv"
	"sync"
)

var wg = sync.WaitGroup{}

/**
WaitGroup总共有三个方法：Add(delta int)，Done()，Wait()。简单的说一下这三个方法的作用。
Add：添加或者减少等待goroutine的数量；
Done：相当于Add(-1)；
Wait：执行阻塞，直到所有的WaitGroup数量变成 0；
*/

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

	}
}

func main() {
	wg.Add(10)
	go test() //开启了一个协程，使其同时执行

	wg.Wait()
	for i := 1; i <= 10; i++ {
		fmt.Println("main() hello,world " + strconv.Itoa(i))
	}
}

MPG 模型

M指的是Machine，一个M直接关联了一个内核线程。
P指的是”processor”，代表了M所需的上下文环境，也是处理用户级代码逻辑的处理器。
G指的是Goroutine，其实本质上也是一种轻量级的线程。

分析暂且跳过后面学完再来补

Go Channel

goroutine运行在相同的地址空间，因此访问共享内存必须做好同步。goroutine 奉行通过通信来共享内存，而不是共享内存来通信。

实现数据同步类似于java的锁排队执行

package main

import (
	"fmt"
	"time"
)

/**
  通过channel实现同步。
  person1与person2都有可能先执行，
  因为2在打印之前，添加了一个取数据的管道，而在这个时候管道里边是没有数据的，
  因此会一直阻塞，继而程序会让1先进行打印，等1打印完成，管道有了数据，2自然也就能够执行打印了。
*/

var ch = make(chan int)

// 定义一个打印机

func printer(str string) {

	for _, s := range str {

		fmt.Printf("截取字符串为： %c", s)
		time.Sleep(time.Second)
		println("\n")

	}

}

func person1() {
	printer("person1")

	ch <- 666
}

func person2() {
	<-ch

	printer("person2")

}

func main() {
	go person1()

	go person2()

	for {
	}

}

package main

import "fmt"

func main() {

	ch := make(chan string)

	defer println("主线程结束")

	go func() {
		defer println("子协程")

		for i := 0; i < 3; i++ {
			fmt.Printf("子协程 i = %d\n", i)
		}

		ch <- "我是子协程"
	}()

	str := <-ch

	println(str)
}

无缓冲的 channel

无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。

这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。如果两个goroutine没有同时准备好，通道会导致先执行发送或接收操作的 goroutine 阻塞等待。

这种对通道进行发送和接收的交互行为本身就是同步的。其中任意一个操作都无法离开另一个操作单独存在。

11d62490c0825d22

在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。
在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。
在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。
在第 4 步和第 5 步，进行交换，并最终，在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。

示例

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan int, 0)
	//len(ch)表示缓冲区剩余数据个数，cap(ch)表示缓冲区大小
	fmt.Printf("len(ch) = %d, cap(ch) = %d\n", len(ch), cap(ch))
	//新建协程
	go func() {
		for i := 0; i < 3; i++ {
			fmt.Println("子协程 i = ", i)
			ch <- i //往chan写内容，没有读取之前，阻塞

		}
	}()

	//延时
	time.Sleep(1 * time.Second)

	for i := 0; i < 3; i++ {
		num := <-ch //读管道中的内容，没有内容前，阻塞
		fmt.Println("num = ", num)
	}

}

有缓冲的 channel

有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。

这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同：无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换；有缓冲的通道没有这种保证。

df1abdda3e40649e

在第 1 步，右侧的 goroutine 正在从通道接收一个值。
在第 2 步，右侧的这个 goroutine独立完成了接收值的动作，而左侧的 goroutine 正在发送一个新值到通道里。
在第 3 步，左侧的goroutine 还在向通道发送新值，而右侧的 goroutine 正在从通道接收另外一个值。这个步骤里的两个操作既不是同步的，也不会互相阻塞。
最后，在第 4 步，所有的发送和接收都完成，而通道里还有几个值，也有一些空间可以存更多的值。

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建一个有缓存的channel
	ch := make(chan int, 3)
	//len(ch)表示缓冲区剩余数据个数，cap(ch)表示缓冲区大小
	fmt.Printf("len(ch) = %d, cap(ch) = %d\n", len(ch), cap(ch))
	//新建协程
	go func() {
		for i := 0; i < 10; i++ {
			ch <- i //往chan写内容，没有读取之前，阻塞
			fmt.Printf("子协程[%d]: len(ch) = %d, cap(ch) = %d\n", i, len(ch), cap(ch))
		}
	}()

	//延时
	time.Sleep(2 * time.Second)

	for i := 0; i < 10; i++ {
		num := <-ch //读管道中的内容，没有内容前，阻塞
		fmt.Println("num = ", num)
	}

}

当缓冲区写满的时候，会阻塞，而异步处理的时候，顺序可能随机

close 关闭 channel

如果发送者知道，没有更多的值需要发送到channel的话，那么让接收者也能及时知道没有多余的值可接收将是有用的，因为接收者可以停止不必要的接收等待。这可以通过内置的close函数来关闭channel实现。


package main

import "fmt"

func main() {

	ch := make(chan int)

	go func() {
		for i := 0; i < 5; i++ {
			ch <- i //输出 i 到管道中

		}

		close(ch) // 关闭管道
	}()

	for {
		if num, ok := <-ch; ok {
			fmt.Println("num: ", num, "  ok: ", ok)
		} else {
			break
		}
	}

}

channel不像文件一样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结束range循环之类的，才去关闭channel；
关闭channel后，无法向channel 再发送数据(引发 panic 错误后导致接收立即返回零值)；
关闭channel后，可以继续向channel接收数据；
对于nil channel，无论收发都会被阻塞。