Go---Go并发编程（详细）（一）

`单个 goroutine`
func main() {
   //hello()
   go hello()
   // 有时 hello() 并不执行，因为程序会为main函数创建一个默认的goroutine，
   // 当main里的语句执行完goroutine也就结束了，没有 go hello() 执行的时间
   fmt.Println("main hello")
   // 为了确保go hello() 的goroutine能够执行可以延缓程序结束时间
   time.Sleep(time.Second)
}
func hello() {
   fmt.Println("hello")
}

var wg sync.WaitGroup
func main() {
   for i := 0; i < 10; i++ {
      // 每添加一个 goroutine wg + 1
      wg.Add(1)
      go sayNum(i)
   }
   // 等待 wg = 0 在执行后面的代码
   wg.Wait()
   fmt.Println("end")
}
func sayNum(i int) {
   // 当一个 goroutine 结束就 - 1
   defer wg.Done()
   fmt.Println(i)
}

package main
import (
    "fmt"
    "math/rand"
)
type Job struct {
    // id
    Id int
    // 需要计算的随机数
    RandNum int
}
type Result struct {
    // 这里必须传对象实例
    job *Job
    // 求和
    sum int
}
func main() {
    // 需要2个管道
    // 1.job管道
    jobChan := make(chan *Job, 128)
    // 2.结果管道
    resultChan := make(chan *Result, 128)
    // 3.创建工作池
    createPool(64, jobChan, resultChan)
    // 4.开个打印的协程
    go func(resultChan chan *Result) {
        // 遍历结果管道打印
        for result := range resultChan {
            fmt.Printf("job id:%v randnum:%v result:%d
", result.job.Id,
                result.job.RandNum, result.sum)
        }
    }(resultChan)
    var id int
    // 循环创建job，输入到管道
    for {
        id++
        // 生成随机数
        r_num := rand.Int()
        job := &Job{
            Id:      id,
            RandNum: r_num,
        }
        jobChan <- job
    }
}
// 创建工作池
// 参数1：开几个协程
func createPool(num int, jobChan chan *Job, resultChan chan *Result) {
    // 根据开协程个数，去跑运行
    for i := 0; i < num; i++ {
        go func(jobChan chan *Job, resultChan chan *Result) {
            // 执行运算
            // 遍历job管道所有数据，进行相加
            for job := range jobChan {
                // 随机数接过来
                r_num := job.RandNum
                // 随机数每一位相加
                // 定义返回值
                var sum int
                for r_num != 0 {
                    tmp := r_num % 10
                    sum += tmp
                    r_num /= 10
                }
                // 想要的结果是Result
                r := &Result{
                    job: job,
                    sum: sum,
                }
                //运算结果扔到管道
                resultChan <- r
            }
        }(jobChan, resultChan)
    }
}

package main
import (
    "fmt"
    "runtime"
)
func main() {
    // 让所有协程在一个核上执行
    runtime.GOMAXPROCS(1)
    go func(s string) {
        for i := 0; i < 2; i++ {
            fmt.Println(s,i)
        }
    }("协程运行中：")
    // 主协程
    for i := 0; i < 2; i++ {
        fmt.Println("hello")
        // 停一下，再次分配任务
        runtime.Gosched()
        fmt.Println("world",i)
    }
}

package main
import (
    "fmt"
    "runtime"
)
func main() {
    go func() {
        defer fmt.Println("A.defer")
        func() {
            defer fmt.Println("B.defer")
            // 结束协程
            runtime.Goexit()
            defer fmt.Println("C.defer")
            fmt.Println("B")
        }()
        fmt.Println("A")
    }()
    for {
    }
}

func a() {
    for i := 1; i < 10; i++ {
        fmt.Println("A:", i)
    }
}
func b() {
    for i := 1; i < 10; i++ {
        fmt.Println("B:", i)
    }
}
func main() {
    // 设定为单核执行
    runtime.GOMAXPROCS(1)
    go a()
    go b()
    time.Sleep(time.Second)
}  

func a() {
    for i := 1; i < 10; i++ {
        fmt.Println("A:", i)
    }
}
func b() {
    for i := 1; i < 10; i++ {
        fmt.Println("B:", i)
    }
}
func main() {
    // 设定为双核执行
    runtime.GOMAXPROCS(2)
    go a()
    go b()
    time.Sleep(time.Second)
}  

`每个通道都是特定类型的，在声明时需要指明通道里传输的元素类型`
var 变量 chan 元素类型
`例`
var ch chan int
println(ch)         // 0x0   空值为 nil

`在不进行初始化的情况下使用通道会报 deadlock`
`其中缓存大小是可选项`
make(chan 元素类型, [缓冲大小])
`例`
var ch1,ch2 chan int
ch1 = make(chan int)    // 无缓存的通道ch1
ch2 = make(chan int,20) // 缓存大小为20的通道ch2

ch3 := make(chan int)