并发指的是同时进行多个任务的程序，Web处理请求，读写处理操作，I/O操作都可以充分利用并发增长处理速度，随着网络的普及，并发操作逐渐不可或缺 

一、goroutine简述

     在Golang中一个goroutines就是一个执行单元，而每个程序都应该有一个主函数main也就是主Goroutines。

        协程也叫轻量级线程，为什么说是一个轻量级的线程呢？协程可以轻松创建上百万个而不会导致系统资源衰竭，而线程和进程通常不能超过1万个。在Go语言提供所有系统调用操作，都会出让CPU给其他goroutine，让轻量级线程的切换管理不依赖于系统的线程和进程，也不依赖CPU的核心数量。

线程和协程的概念

线程（Thread）：有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。

线程拥有自己独立的栈和共享的堆，共享堆，不共享栈，线程的切换一般也由操作系统调度。

协程（coroutine）：又称微线程与子例程（或者称为函数）一样，协程（coroutine）也是一种程序组件。相对子例程而言，协程更为一般和灵活，但在实践中使用没有子例程那样广泛。

和线程类似，共享堆，不共享栈，协程的切换一般由程序员在代码中显式控制。它避免了上下文切换的额外耗费，兼顾了多线程的优点，简化了高并发程序的复杂。

两者的区别：

相同点：

1、一个程序可以包含多个协程，可以对比于一个进程包含多个线程。

2、和线程类似，共享堆，不共享栈

不同点：线程切换受系统控制，协程切换由自己控制：

我们知道多个线程相对独立，有自己的上下文，切换受系统控制；而协程也相对独立，有自己的上下文，但是其切换由自己控制，由当前协程切换到其他协程，由当前协程来控制。

Goroutine和其他语言的协程（coroutine）在使用方式上类似，但从字面意义上来看不同（一个是Goroutine，一个是coroutine），再就是协程是一种协作任务控制机制，在最简单的意义上，协程不是并发的，而Goroutine支持并发的。因此Goroutine可以理解为一种Go语言的协程。同时它可以运行在一个或多个线程上。

goroutine是Go语言轻量级线程实现，由Go运行时（runtime）管理的：goroutine 是Go语言中并发的执行单位。有点抽象，其实就是和传统概念上的”线程“类似，可以理解为”线程“。

Go语言中使用 goroutine 非常简单，只需要在函数或方法调用前加上go关键字就可以创建一个 goroutine，从而让该函数或方法在新创建的 goroutine 中执行。
go func

func sum(x, y int) {
	z := x + y
	fmt.Println(z)
}

让这个函数并发执行非常简单:

go sum(1,1)

在一个函数调哦那个前面加上go关键字，这次调用就会在一个新的goroutine中并发执行。如果调用返回时，那么goroutine也自动结束了。（如该函数有返回值，那么这个返回值会被丢弃）

 2、goroutine协程执行机制

goroutine协程执行机制：在主Goroutine结束之后其他的所有Goroutine都会直接退出。

Go程序从初始化main package并执行main()函数开始，当main()函数返回时，程序退出， 且程序并不等待其他goroutine（非主goroutine）结束。

func sum(x, y int) {
	z := x + y
	fmt.Println(z)
}
func main() {
	for i := 0; i < 10; i++ {
		go sum(i,i)
	}
}

，我们使用for循环中调用10次sum()函数，它们是并发执行，但是发现运行后，控制台啥也没有输出。

让主goroutine等待其它 goroutine:

for i := 0; i < 10; i++ {
	go sum(i,i)
}
time.Sleep(time.Millisecond * 1000)
//goroutine 完成的时间极可能小于设置的等待时间,那么这就会形成多余的等待时间

主要特点：

• 是一种轻量级“线程”
• 最重要的是非抢占式多任务处理，有协程主动交出控制权。（非抢占就是正在执行的不允许中断）
• 编译器/解析器/虚拟机层面的多任务
• 多个协程肯在一个多个线程上运行

goroutine可能的切换点

• I/O，select
• channel
• 等待锁
• 函数调用（有时）
• runtime.Gosched()
• 只是参考，不能保证切换，不能保证在其他地方不切换。

3、WaitGroup：多个goroutine并发执行

WaitGroup让goroutine执行完后马上执行下一个goroutine

WaitGroup翻译为等待组，其实就是计数器，只要计数器中有内容将一直阻塞。

Go语言标准库中WaitGroup只有三个方法

    Add(delta int)表示向内部计数器添加增量(delta)其中参数delta可以是负数
    Done()表示减少WaitGroup计数器的值，应当在程序最后执行，相当于Add(-1)
    Wait()表示阻塞直到WaitGroup计数器为
 

// 声明全局等待组变量
var wg sync.WaitGroup

func demo(count int) {
	fmt.Println(count)
}
func main() {
	//wg.Add(5) 如果不在for里面写，可以直接添加5个。
	for i := 0; i < 5; i++ {
        wg.Add(1) // //每启动一个协程增长一个等待
		go demo(i)
        wg.Done()  // 告知当前goroutine完成,释放资源
	}
  //time.Sleep(time.Millisecond)//不使用
	wg.Wait() // 阻塞等待登记的goroutine完成，不然主Go结束了就都退出了
	fmt.Println("ok")
}

WaitGroup类似java的CountDownLatch工具，保证线程1、线程2....执行完之后再接着执行。

二、GO并发的实现原理

Go实现了两种并发形式：多线程共享内存和CSP（communicating sequential processes）并发模型。

第一种是大家普遍认知的：多线程共享内存。其实就是Java或者C++等语言中的多线程开发。

另外一种是Go语言特有的，也是Go语言推荐的：CSP（communicating sequential processes）并发模型。

CSP并发模型是在1970年左右提出的概念，属于比较新的概念，不同于传统的多线程通过共享内存来通信，CSP讲究的是“以通信的方式来共享内存”。

请记住下面这句话： DO NOT COMMUNICATE BY SHARING MEMORY; INSTEAD, SHARE MEMORY BY COMMUNICATING. “不要以共享内存的方式来通信，相反，要通过通信来共享内存。”

普通的线程并发模型，就是像Java、C++、或者Python，他们线程间通信都是通过共享内存的方式来进行的。非常典型的方式就是，在访问共享数据（例如数组、Map、或者某个结构体或对象）的时候，通过锁来访问，因此，在很多时候，衍生出一种方便操作的数据结构，叫做“线程安全的数据结构”。例如Java提供的包”java.util.concurrent”中的数据结构。Go中也实现了传统的线程并发模型。

Go的CSP并发模型，是通过goroutine和channel来实现的。

1、传统的线程并发模型：多线程共享内存

共享内存：线程不安全

func TestCounter(t *testing.T) {
	counter := 0
	for i := 0; i < 5000; i++ {
		go func() {
			counter++
		}()
	}
	time.Sleep(1 * time.Second)
	t.Logf("counter = %d", counter)
}

//执行结果会小于5000， 出现了线程安全的问题，因为在并发的过程有可能会出现多个go同时执行counter++,这样只会有一个是有效的。

当多个协程操作一个变量时可能会出现冲突问题，也许会导致程序出异常也许不会，我们可以使用go run -race查看是否有竞争。

和大多数语言同样go也支持加锁保证线程的安全。

使用sync.Mutex对内容加锁：

var tex sync.Mutex
tex.Lock(）
tex.Unlock()

当一个 goroutine 获取互斥锁之后，其他的 goroutine 将等待直至解锁。 

 1、互斥锁Mutex使用

var (
	num = 100
	wg sync.WaitGroup
	m sync.Mutex
)
func demo1() {
	m.Lock()
	for i := 0; i < 10; i++ {
		num = num - i
	}
	m.Unlock()
	wg.Done()
}
func main() {
	wg.Add(10)
	for i := 0; i < 10; i++ {
		go demo1()
	}
	wg.Wait()
	fmt.Println(num)
	fmt.Println("ok")
}

2、读写锁(RWMutex)

先看Go语言标准库中的API

type{
  func (rw *RWMutex) Lock() //禁止其他协程读
  func (rw *RWMutex) Unlock()
  func (rw *RWMutex) RLock() //禁止其他协程写入，只能读取
  func (rw *RWMutex) RUnlock()
  func (rw *RWMutex) RLocker()
}

var tex sync.RWMutex
tex.Lock(）
tex.Unlock()

    读写锁分为两种：读锁和写锁。
    当一个 goroutine 获取到读锁之后，其他的 goroutine如果是获取读锁会继续获得锁，如果是获取写锁就会等待；

互斥锁的锁事同一时间只能一个goroutine运行，而读写锁表示在锁范围内数据的读写操作   

 共享内存：线程安全：回到上面的例子，通过加锁方式实现共享内存线程安全：

func TestCounterWaitGroup(t *testing.T) {
	var mut sync.Mutex//建立锁对象
	var wg sync.WaitGroup
	counter := 0
	for i := 0; i < 5000; i++ {
		wg.Add(1)//每启动一个协程增长一个等待
		go func() {
			defer func() {
				mut.Unlock()//释放锁
			}()
			mut.Lock()//开启锁
			counter++
			wg.Done()//告诉协成等待的事务已经完成
		}()
	}
	wg.Wait()//等待协程
	t.Logf("counter = %d", counter)

}

读写锁使用场景

如果并发过程中绝大部分都是读操作，那么使用读写锁将会优于互斥锁，如果读操作并不是特别多那将不会有太大差别

读写锁使用原因

var ch chan int
fmt.Println(ch) // <nil>

channel <- 1 //向channel添加一个值为1
<- channel //从channel取出一个值
a := <- channel //从channel取出一个值并赋值给a
a,b := <- channel //从channel取出一个值赋值给a，如果channel已经关闭或channel没有值，b为false

func main(){
    ch := make(chan int)
    go func() {
        ch <- 996 //向ch添加元素
    }()
    a := <- ch
    fmt.Println(a)
    fmt.Println("程序结束！")
}

func two() {
    tc := make(chan string)
    ch := make(chan int)
    // 第一个协程
    go func() {
        tc <- "协程A，我在添加数据"
        ch <- 1
    }()
    // 第二个协程
    go func() {
        content := <- tc
        fmt.Printf("协程B，我在读取数据:%s\n",content)
        ch <- 2
    }()
    <- ch
    <- ch
    fmt.Println("程序结素！")
}
func main(){
    two()
}

package main
import (
    "fmt"
    "time"
)
func goRoutineA(a <-chan int) {
    val := <-a
    fmt.Println("goRoutineA received the data", val)
}
func goRoutineB(b chan int) {
    val := <-b
    fmt.Println("goRoutineB  received the data", val)
}
func main() {
    ch := make(chan int, 3)
    go goRoutineA(ch)
    go goRoutineB(ch)
    ch <- 3
    time.Sleep(time.Second * 1)
}