一、goroutine

1、并发和并行：

多线程程序在单核上运行就是并发。

多线程程序在多核上运行就是并行。

2、Go协程和Go主线程

Go主线程(有人直接称为线程/也可以理解成进程):一个Go线程上，可以起多个协程，协程是轻量级的线程[编译器做优化]。

Go协程的特点：有独立的栈空间；共享程序堆空间；调度由用户控制；协程是轻量级的线程。

请编写一个程序，完成如下功能:
在主线程(可以理解成进程)中，开启一个goroutine, 该协程每隔1秒输出 "hello,world"
在主线程中也每隔一秒输出"hello,golang", 输出10次后，退出程序
要求主线程和goroutine同时执行.
画出主线程和协程执行流程图

package main

import (
	"fmt"
	"strconv"
	"time"
)

func test() {
	for i := 1; i <= 10; i++ {
		fmt.Println("test() hello,world " + strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}

func main() {
	go test() //开协启一个协程

	for i := 1; i <= 10; i++ {
		fmt.Println("  main() hello,golang " + strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}

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

3、goroutine的调度模型MPG

M指的是Machine，一个M直接关联了一个内核线程。由操作系统管理。 P指的是”processor”，代表了M所需的上下文环境，也是处理用户级代码逻辑的处理器。它负责衔接M和G的调度上下文，将等待执行的G与M对接。 G指的是Goroutine，其实本质上也是一种轻量级的线程。包括了调用栈，重要的调度信息，例如channel等。
P的数量由环境变量中的GOMAXPROCS决定，通常来说它是和核心数对应，例如在4Core的服务器上回启动4个线程。G会有很多个，每个P会将Goroutine从一个就绪的队列中做Pop操作，为了减小锁的竞争，通常情况下每个P会负责一个队列。
三者关系如下图所示：

以上这个图讲的是两个线程(内核线程)的情况。一个M会对应一个内核线程，一个M也会连接一个上下文P，一个上下文P相当于一个“处理器”，一个上下文连接一个或者多个Goroutine。为了运行goroutine，线程必须保存上下文。
上下文P(Processor)的数量在启动时设置为GOMAXPROCS环境变量的值或通过运行时函数GOMAXPROCS()。通常情况下，在程序执行期间不会更改。上下文数量固定意味着只有固定数量的线程在任何时候运行Go代码。可以使用它来调整Go进程到个人计算机的调用，例如4核PC在4个线程上运行Go代码。
图中P正在执行的Goroutine为蓝色的；处于待执行状态的Goroutine为灰色的，灰色的Goroutine形成了一个队列runqueues。
Go语言里，启动一个goroutine很容易：go function就行，所以每有一个go语句被执行，runqueue队列就在其末尾加入一个goroutine，一旦上下文运行goroutine直到调度点，它会从其runqueue中弹出goroutine，设置堆栈和指令指针并开始运行goroutine。

能否抛弃P(Processor)，让Goroutine的runqueues挂到M上呢？答案是不行，需要上下文的目的是：当遇到内核线程阻塞的时候可以直接放开其他线程。

一个很简单的例子就是系统调用sysall，一个线程肯定不能同时执行代码和系统调用被阻塞，这个时候，此线程M需要放弃当前的上下文环境P，以便可以让其他的Goroutine被调度执行。

如上图左图所示，M0中的G0执行了syscall，然后就创建了一个M1(也有可能来自线程缓存)，（转向右图）然后M0丢弃了P，等待syscall的返回值，M1接受了P，将继续执行Goroutine队列中的其他Goroutine。
当系统调用syscall结束后，M0会“偷”一个上下文，如果不成功，M0就把它的Gouroutine G0放到一个全局的runqueue中，将自己置于线程缓存中并进入休眠状态。全局runqueue是各个P在运行完自己的本地的Goroutine runqueue后用来拉取新goroutine的地方。P也会周期性的检查这个全局runqueue上的goroutine，否则，全局runqueue上的goroutines可能得不到执行而饿死。
均衡的分配工作：按照以上的说法，上下文P会定期的检查全局的goroutine队列中的goroutine，以便自己在消费掉自身Goroutine队列的时候有事可做。假如全局goroutine队列中的goroutine也没了呢？就从其他运行的中的P的runqueue里偷。
每个P中的Goroutine不同导致他们运行的效率和时间也不同，在一个有很多P和M的环境中，不能让一个P跑完自身的Goroutine就没事可做了，因为或许其他的P有很长的goroutine队列要跑，得需要均衡。该如何解决呢？Go的做法倒也直接，从其他P中偷一半！

4、设置golang运行的cpu数

为了充分利用多cpu的优势，在golang程序中可以设置运行cpu数目。 go1.8后，默认让程序运行在多个核上，可以不用设置。go1.8之前，需要设置一下，可以更高效的利用cpu。

package main

import (
	"fmt"
	"runtime"
)

func main() {
	//获取当前系统cpu的数量
	num := runtime.NumCPU()

	//设置运行go程序的cpu数量
	runtime.GOMAXPROCS(num)
	fmt.Println("cpu number = ", num)
}

二、channel

计算1-200的各个数的阶乘，并且把各个数的阶乘放入到map中。最后显示出来。要求使用goroutine完成。

goroutine和channel