go语言多线程与并发编程

go语言并发编程

在了解go语言的并发编程之前，我们必须先了解并发和并行的概念。我们知道，当启动一个应用的时候实际上是启动了一个进程，通过该进程实现资源的调度和分配，并且多个进程之间是相互隔离的，所以我们运行其中一个应用不会对其他应用造成影响。

默认情况下一个进程只有一个线程，也就是单线程应用，这种模式下所有的操作都是同步的，处理完A事件以后才能接着处理B事件再接着处理C事件。

那么，单线程模式下能否进行并发编成，当然可以。我们设想一下，我有A、B、C三件事情要做，但是我又不想一个一个同步的去做，这时候我们可以使用并发模式，我先做A的一部分，接着做B的一部分，然后是C的一部分，通过这种不停切换的方式可以保证三件事情同时推进，这就算并发。

在多核处理器之前，也就是单核时代，我们只能在一个线程之间进行多任务的调度，这种调度方式也就算并发，随之技术的进步，现在已经进入了多核时代，为计算机的并行开发提供了条件。

我们在设想一下，以前就只有自己一个人，现在我又多个几个双胞胎兄弟（多核），那我是不是可以再请两个兄弟帮着做B、C事情，我自己做A事情，这样同时推进A、B、C事情，是的，这就是并行。

有时候并发和并行是同时的，比如多个线程同时处理数百件任务，多个线程并行的执行任务，一个线程又并发的执行多个任务。

言归正传，接下来我们开始分析go语言的并发编程。

1、goroutine

package main

import (

"fmt"

"time"

)

func printString(value string) {

for i := 0; i < 10; i++ {

fmt.Println(value)

time.Sleep(time.Second) //0.1 second

}

}

func main() {

go printString("A")

go printString("B")


time.Sleep(time.Second * 10)//暂时挂起主线程，让goroutine的两个线程跑完

}

输出结果：ABABBAABABBABABAABAB

两个线程交叉输出，说明是以并发形式执行，这里为什么说是并发而不是并行，因为go语言默认是单核执行线程。如果想要多核并行执行，需要在启动goroutine之前首先调用以下语句配置cpu核数：

runtime.GOMAXPROCS()

自从Go 1.5开始， Go的GOMAXPROCS默认值已经设置为 CPU的核数，我们不用手动设置这个参数。

2、go语言的线程通信

无论是哪种编程语言，实现多线程之间的通信方式无非是共享数据和消息两种方式。

1）我们先看下go语言是如何通过共享数据实现线程通信。

package main

import (

"fmt"

"sync"

"time"

)

var counter int = 0

func Count(lock *sync.Mutex) {

lock.Lock()

counter++

fmt.Println(counter)

lock.Unlock()

}

func main() {

lock := &sync.Mutex{}

for i := 0; i < 5; i++ {

go Count(lock)

}

time.Sleep(time.Second * 5)

}

输出结果：1 2 3 4 5

此时，多个线程共享数据counter，实际上当业务逻辑比较复杂并且共享数据比较多的情况下，使用这种方式是一件十分头疼的事情。我们这里暂且不提这些。

2）消息机制实现多线程通信

go语言使用channel在两个或多个线程之间传递消息。channel翻译成中文就算通道的意思，我们直接看代码：

package main

import (

"fmt"

"sync"

"time"

)

func WriteIn(ch chan int) {

for i := 0; i < 10; i++ {

ch <- i

}

}

func ReadOut(ch chan int) {

for i := 0; i < 10; i++ {

value := <-ch

fmt.Println(value)

}

}

func main() {

ch := make(chan int)

go WriteIn(ch)

go ReadOut(ch)

time.Sleep(time.Second * 5)

}

输出：1 2 3 4 5 6 7 8 9，通过chanel在不需要锁的情况下实现了数据的共享，chanel的用法中，常见的操作包括写入和读出，写入和读出都会导致线程的阻塞，也就是说数据写入后线程会等待另一个线程的读取，而读取之前如果没有数据写入也会进入阻塞状态等待数据写入。

3、go语言的线程同步

1）使用互斥锁实现线程同步

互斥锁是最简单的一种锁类型，同时也比较暴力，当一个goroutine获得了锁之后，其他goroutine就只能乖乖等到这个goroutine释放该锁。go语言使用sync.Mutex实现互斥锁。

代码如下：

package main

import (

"fmt"

"sync"

"time"

)

type MutexInfo struct {

mutex sync.Mutex

infos []int

}

func (m *MutexInfo) addInfo(value int) {

m.mutex.Lock()

m.infos = append(m.infos, value)

m.mutex.Unlock()

}

func main() {

m := MutexInfo{}

for i := 0; i < 10; i++ {

go m.addInfo(i)

}

time.Sleep(time.Second * 5)

fmt.Println(m.infos)

}

输出：[0 1 2 3 4 5 6 7 8 9]

我们通过多次运行发现，输出的结果并不总是从0到9按顺序输出，说明创建的10个goroutine并不是有序的抢占线程的执行权，也就是说这种同步并不是有序的同步，我们可以让10个goroutine一个一个的同步执行，但是并不能安排执行次序。

运行到这里，假如我们注释掉同步锁的代码为发生什么？

我们将addInfo方法修改如下：

func (m *MutexInfo) addInfo(value int) {

//m.mutex.Lock()

m.infos = append(m.infos, value)

//m.mutex.Unlock()

}

运行代码，输出：[1 0 2]

结果是不是出乎意料？为什么写了10个输入，只有3个值输入成功？这时候我们不得不解释线程的另一个概念，那就是线程安全。

我们先看下go语言中slice的append过程，使用append添加一个元素时，可能会有两步来完成：先获取当前切片数组的容量，比如当前容量是2，然后在新的存储区开辟一块新的存储单元，容量为2+1，并将原来的值和新的值存入新的存储单元。在没有同步锁的情况下，如果两个线程同时执行添加元素的操作，这时候可能只有一个被写入成功。这种情况就是非线程安全，相比之下，如果同时对一个int类型数据进行操作，就不会出现这种非线程安全的情况。

2）读写锁实现线程同步

go语言提供了另一种更加友好的线程同步的方式：sync.RWMutex。相对于互斥锁的简单暴力，读写锁更加人性化，是经典的单写多读模式。在读锁占用的情况下，会阻止写，但不阻止读，也就是多个goroutine可同时获取读锁，而写锁会阻止其他线程的读写操作。

代码如下：

package main

import (

"fmt"

"sync"

"time"

)

type MutexInfo struct {

mutex sync.RWMutex

infos []int

}

func (m *MutexInfo) addInfo(value int) {

m.mutex.Lock()

defer m.mutex.Unlock()

fmt.Println("write start", value)

m.infos = append(m.infos, value)

fmt.Println("write start end", value)

}

func (m *MutexInfo) readInfo(value int) {

m.mutex.RLock()

defer m.mutex.RUnlock()

fmt.Println("read start", value)

fmt.Println("read end", value)

}

func main() {

m := MutexInfo{}

for i := 0; i < 10; i++ {

go m.addInfo(i)

go m.readInfo(i)

}

time.Sleep(time.Second * 3)

fmt.Println(m.infos)

}

输出结果：

read start 0

read end 0

write start 1

write start end 1

read start 4

read end 4

read start 9

read end 9

read start 3

read start 1

read start 7

read end 7

read start 2

read start 8

read end 8

read end 1

read start 6

read end 6

read start 5

read end 5

read end 3

read end 2

write start 0

write start end 0

write start 2

write start end 2

write start 3

write start end 3

write start 4

write start end 4

write start 5

write start end 5

write start 6

write start end 6

write start 7

write start end 7

write start 8

write start end 8

write start 9

write start end 9

[1 0 2 3 4 5 6 7 8 9]

从结果我们可以看出，开始的时候读线程占用读锁，并且多个线程可以同时开始读操作，但是写操作只能单个进行。

3)使用条件变量实现线程同步

go语言提供了条件变量sync.Cond，sync.Cond方法如下：

Wait，Signal，Broadcast。
Wait添加一个计数，也就是添加一个阻塞的goroutine。
Signal解除一个goroutine的阻塞，计数减一。
Broadcast接触所有wait goroutine的阻塞。

代码如下：

func printIntValue(value int, cond *sync.Cond) {
	cond.L.Lock()
	if value < 5 {
		//value小于5时，进入等待状态
		cond.Wait()
	}
	//大于5的正常输出
	fmt.Println(value)
	cond.L.Unlock()
}

func main() {

	//条件等待
	mutex := sync.Mutex{}
	//使用锁创建一个条件等待
	cond := sync.NewCond(&mutex)

	for i := 0; i < 10; i++ {
		go printIntValue(i, cond)
	}

	time.Sleep(time.Second * 1)
	cond.Signal()//解除一个阻塞
	time.Sleep(time.Second * 1)
	cond.Broadcast()//解除全部阻塞
	time.Sleep(time.Second * 1)
}

运行后先输出满足条件的值：5 6 7 8 9

解除一个阻塞，输出0，解除全部阻塞，输出1 2 3 4

go语言多线程支持全局唯一性操作，即一个只允许goruntine调用一次，重复调用无效。

go语言还支持sync.WaitGroup实现多个线程同步的操作。