什么是过程、线程

过程就是一个应用程序的工作空间，比方你关上的 QQ, 微信，工作空间蕴含了该程序运行所需的所有资源。而线程是过程中的执行单位，一个过程起码有一个线程。

过程与线程比照

• 过程是零碎资源分配和调度的最小单位
• 线程是程序执行的最小单位
• 一个过程由一个或多个线程组成，线程是过程中代码的不同执行路线
• 过程之间互相独立，过程中的线程共享程序的内存空间及资源
• 线程在工夫效率和空间效率都比过程要高

协程

协程是一种用户态的轻量级线程，线程是 CPU 来调度，而协程的调度齐全是由用户来管制的。

协程与线程比照

• 一个线程能够有多个协程
• 线程、过程都是同步机制，而协程是异步
• 协程能够保留上一次调用时的状态，当过程重入时，相当于进入了上一次的调用状态
• 协程是须要线程来承载运行的，所以协程并不能取代线程，线程是被宰割的 CPU 资源，协程是组织好的代码流程

并发、并行

1. 并发和并行是绝对于过程或者线程来说的。
2. 并发是一个或多个 CPU 对多个过程 / 线程之间的多路复用，艰深讲就是 CPU 轮流执行多个工作，而每个工作都执行一小段，从宏观来看就像在同时执行。
3. 并行必须有多个 CPU 来提供反对，真正意义上的在同一时刻执行多个过程或线程。

Go 语言协程

Go 中没有线程的概念，只有协程（goroutine），协程相比线程更加轻量，上下文切换更快。Goroutine 由 Go 本人来调度，咱们只管启用。
goroutine 通过 go 关键字来启动，非常简单，go 关键字前面加一个办法或函数 go function()

package main

import (
    "fmt"
    "time"
)

func main (){go fmt.Println("微客鸟窝")
    fmt.Println("我是无尘啊")
    time.Sleep(time.Second) // 期待一秒，使 goroutine 执行结束
}

运行后果：

我是无尘啊
微客鸟窝

Channel

channel（通道）是用来解决多个 goroutine 之间通信问题的。

在 Go 语言中，提倡通过通信来共享内存，而不是通过共享内存来通信，其实就是提倡通过 channel 发送接管音讯的形式进行数据传递，而不是通过批改同一个变量。所以在数据流动、传递的场景中要优先应用 channel，它是并发平安的，性能也不错。

channel 申明

ch := make(chan string)

• 应用 make 函数
• chan 是关键字，示意 channel 类型，chan 是一个汇合类型
• string 示意 channel 里存放数据的类型

chan 应用

chan 只有发送和接管两种操作：

1. 发送：<-chan // 向 chan 内发送数据
2. 接管：chan-> // 从 chan 中获取数据

示例：

package main

import ("fmt")

func main() {ch := make(chan string)
    go func(){fmt.Println("微客鸟窝")
        ch <- "执行结束"
    }()

    fmt.Println("我是无尘啊")
    value := <-ch
    fmt.Println("获取的 chan 的值为：",value)
}

运行后果

我是无尘啊
微客鸟窝
获取的 chan 的值为：执行结束

有了 chan 后，咱们能够不应用 Sleep 来等 goroutine 执行完了，因为接管操作 (value := <-ch) 会阻塞期待，直到它获取到值为止。

无缓冲 channel

下面的操作就是一个无缓冲 channel，通道的容量是 0，它不能存储数据，只是起到了传输的作用，所以无缓冲 channel 的发送和接管操作是同时进行的

有缓冲 channel

在申明的时候，咱们能够传入第二个参数，即channel 容量大小，这样就是创立了一个有缓冲 channel。

// 创立一个容量为 3 的 channel，其外部能够寄存 3 个类型为 int 的元素
ch := make(chan int,3)

• 有缓冲 channel 外部有一个队列
• 发送操作是向队列尾部追加元素，如果队列满了，则阻塞期待，直到接管操作从队列中取走元素。
• 接管操作是从队列头部取走元素，如果队列为空，则阻塞期待，直到发送操作向队列追加了元素。
• 能够通过内置函数 cap 来获取 channel 的容量，通过内置函数 len 获取 channel 中元素个数。

ch := make(chan int,3)
ch <- 1
ch <- 2
fmt.Println("容量为",cap(ch),"元素个数为：",len(ch))
// 打印后果：容量为 3 元素个数为：2

敞开 channel

应用内置函数 close :close(ch)

• channel 敞开了就不能再向其发送数据了，否则会引起 panic 异样。
• 能够从敞开了的 channel 中接收数据，如果没数据，则接管到的是元素类型的零值。

单向 channel

只能发送或者只能接管的 channel 为单向 channel。

单向 channel 申明

只须要在根底申明中减少操作符即可：

send := make(ch<- int) // 只能发送数据给 channel
receive := make(<-ch int) // 只能从 channel 中接收数据

示例：

package main

import ("fmt")
// 只能发送通道
func send(s chan<- string){s <- "微客鸟窝"}
// 只能接管通道
func receive(r <-chan string){
    str := <-r
    fmt.Println("str:",str)
}
func main() {
    // 创立一个双向通道
    ch := make(chan string)
    go send(ch)
    receive(ch)
}

// 运行后果: str: 微客鸟窝

select+channel

select 能够实现多路复用，即同时监听多个 channel。

• 发现哪个 channel 有数据产生，就执行相应的 case 分支
• 如果同时有多个 case 分支能够执行，则会随机抉择一个
• 如果一个 case 分支都不可执行，则 select 会始终期待

示例：

package main

import ("fmt")

func main() {ch := make(chan int, 1)
    for i := 0; i < 10; i++ {
        select {
        case x := <-ch:
            fmt.Println(x)
        case ch <- i:
            fmt.Println("--", i)
        }
    }
}

运行后果：

-- 0
0
-- 2
2
-- 4
4
-- 6
6
-- 8
8

此处留作思考题，为何会这样输入呢？