线程与go协程的区别

1. 进程和线程

1）进程是程序在操作系统中依次执行的过程，是系统进行资源分配和调度的基本单位；

2）线程是进程的一个执行实例，是程序执行的最小单元，它是比进程更小的能独立运行的基本单位；

3）一个进程可以创建和销毁多个线程，同时一个进程中的多个线程可以并发执行；

4）一个程序至少有一个进程，一个进程至少有一个线程；

2. 并发和并行

并发：多线程程序在单核上运行

并行：多线程程序在多核上运行

图解1:

图解2：

3. 协程

3.1 概念

在go程序中，由轻量级线程实现，由Go运行时（runtime）管理。

3.2 与进程、线程的区别

1）进程拥有自己独立的堆栈，既不共享堆，也不共享栈。是由操作系统调度的。

2）线程拥有自己独立的栈和共享的堆，共享堆，不共享栈，是由操作系统调度。

2）协程共享堆，不共享栈，协程是由程序员在协程的代码中显示调度。

3.3 主线程和协程的关系

3.4 协程比线程轻量的原因

3.4.1 线程并发的流程

线程是内核对外提供的服务，应用程序可以通过系统调用让内核启动线程，由内核来负责线程的调度和切换。线程在等待I/O操作时线程变为unrunnable状态会触发上下文切换。现代操作系统一般都采用抢占式调度，上下文切换一般发生在时钟中断和系统调用返回前，调度器计算当前线程的时间片，如果需要切换就从队列中选出一个目标线程，保存当前线程的环境，并且恢复目标线程的运行环境，最典型的就是切换ESP指向目标线程内核堆栈，将EIP指向目标线程上次被调度出时的指令地址。

3.4.2 协程并发的流程

不依赖操作系统和其提供的线程，golang自己实现的CSP并发模型:M,P,G

go协程也叫用户态线程，协程之间的切换发生在用户态。在用户态没有时钟中断、系统调用等机制，因此效率高。

3.5 go协程占用内存少的原因

执行go协程只需要极少的栈内存（大概4~5KB），默认情况下，线程栈的大小为1MB。

goroutine就是一段代码，一个函数入口，以及在堆上分配的一个堆栈。所以我们可以轻松创建上万个goroutine，但他们并不是被操作系统调度执行的。

3.6 几个简单实例

3.6.1 Goroutine的使用

go关键字创建一个协程。

/*
协程的创建: go关键字 创建新协程
*/

package main

import (
	"fmt"
	"time"
)

func NewTask() {
	for {
		fmt.Println("This is a new task")
		time.Sleep(time.Second)
	}
}

func main() {
	go NewTask() //新建一个协程(子协程) 新建一个任务

	for {
		fmt.Println("This is a main goroutine")
		time.Sleep(time.Second)
	}
}

3.6.2 主协程先退出

如果主协程先退出，子协程也会退出。

/*
重点: 主协程退出了，其他子协程也会跟着退出
*/
package main

import (
	"fmt"
	"time"
)

func main() {
	go func() { //调用匿名函数
		j := 0
		for {
			j++
			fmt.Println("j = ", j)
			time.Sleep(time.Second)
		}
	}()

	i := 0
	for {
		i++
		fmt.Println("i = ", i)
		time.Sleep(time.Second)

		if i == 5 {
			break
		}
	}
}

3.6.3 主协程退出导致子协程没来得及退出

package main

import (
	"fmt"
	"time"
)

func main() {
	go func() { //调用匿名函数
		j := 0
		for {
			j++
			fmt.Println("j = ", j)
			time.Sleep(time.Second)
		}
	}()
}

3.6.4 Gosched

/*
针对的问题: 主协程由于执行的快,导致主协程执行完了,子协程还没来得及执行
*/
package main

import (
	"fmt"
	"runtime"
)

func main() {
	go func() {
		for i := 0; i < 5; i++ {
			fmt.Println("Hello")
		}
	}()

	for i := 0; i < 2; i++ {
		//让出时间片 先让别的协程执行 别的协程执行完 再来执行此协程
		runtime.Gosched()

		fmt.Println("Hello Go")
	}
}

3.6.5 Goexit

/*
GoExit: 终止当前协程
*/
package main

import (
	"fmt"
	"runtime"
)

func test1() {
	defer fmt.Println("test1 end")

	//return
	runtime.Goexit() //终止所在的协程

	fmt.Println("test1 begin")
}

func main() {
	//创建新的协程
	go func() { //匿名函数
		fmt.Println("test begin")

		test1()

		fmt.Println("test end")
	}()

	for {

	}
}

3.6.6 GOMAXPROCS

/*
GOMAXPROCS: 用来设置可以并行计算的CPU核数的最大值
会影响运行的速度
*/
package main

import (
	"fmt"
	"runtime"
)

func main() {
	num := runtime.GOMAXPROCS(2) //指定单核运算
	fmt.Println("num = ", num)
	
	for {
		gp fmt.Print(1)
		
		fmt.Print(0)
	}
}

4. 后续将更新的内容

1）Goroutine为什么能处理高并发

2）Goroutine的系统实现

3）Go的CSP并发模型实现：M，P，G