【Go学习笔记11】并发（一）

并发模型

go语言中的并发是指，可以让一个函数独立于其他函数单独运行的能力。当一个函数创建为一个goroutine时，go语言会把这个函数当作一个可以独立运行的单元。 go语言中的并发模型是一种消息传递模型。不像java中的内存模型，需要通过加锁来实现同步。在go语言中，每一个goroutine之间同步和传递数据是通过通道来实现的。

创建goroutine

package main

import (
	"fmt"
)


func main(){
	//声明一个匿名函数，并创建一个goroutine
	go func(){
		fmt.Println("来自goroutine。。。")
	}()

	fmt.Println("来自main函数")
}
//来自main函数
或
//来自goroutine。。。
//来自main函数
复制代码

多次运行上面的代码，会发现有时能够输出“来自goroutine。。。”这句，而有时只会输出“来自main函数”，这是因为如果main函数先执行完成，程序就会退出，那么gorouthine就无法继续执行了，导致没有输出。

看下面的例子：

package main

import (
	"time"
	"fmt"

)


func main(){
	//声明一个匿名函数，并创建一个goroutine
	go func(){
		fmt.Println("来自goroutine。。。")
	}()
	//暂停2秒
	time.Sleep( 2 * time.Second)
	fmt.Println("来自main函数")
}
//来自goroutine。。。
//来自main函数
复制代码

上面的代码通过调用time.Sleep方法来让程序暂停执行2秒，这样，goroutine中的代码才能够执行，并且输出。

package main

import (
	"runtime"
	"time"
	"fmt"
)
var num int = 10

func A(){
	for i:=1 ; i<=5 ; i++{
		temp := num
		runtime.Gosched()
		temp--
		num = temp
	}
}

func B(){
	for i:=1 ; i<=5 ; i++{
		temp := num
    //让出当前处理器
		runtime.Gosched()
		temp--
		num = temp
	}
}

func main(){
  //分配一个逻辑处理器给调度器使用
	runtime.GOMAXPROCS(1)
	go A()
	go B()
	//暂停1秒,让gorouthine运行完
	time.Sleep( 100 * time.Millisecond)
	fmt.Println("num=",num)
	fmt.Println("main函数执行完成")
}
//num= 5
//main函数执行完成
复制代码

上面的代码执行完成之后，结果是5。这是因为在每一次执行num-1的时候，调用了runtime.Gosched()方法，让当前的goroutine退出当前线程给其他goroutine运行的机会。这样是为了让数据争用的问题更加明显。

解决数据争用问题

package main

import (
	"runtime"
	"time"
	"fmt"
	"sync/atomic"
)
var num int64 = 10

func A(){
	for i:=1 ; i<=5 ; i++{
		//使用原子操作对num减1
		atomic.AddInt64(&num,-1)
		runtime.Gosched()
	}
}

func B(){
	for i:=1 ; i<=5 ; i++{
		//使用原子操作对num减1
		atomic.AddInt64(&num,-1)
		runtime.Gosched()
	}
}

func main(){
	runtime.GOMAXPROCS(1)
	go A()
	go B()
	//暂停1秒,让gorouthine运行完
	time.Sleep( 100 * time.Millisecond)
	fmt.Println("num=",num)
	fmt.Println("main函数执行完成")
}
//num= 0
//main函数执行完成
复制代码

上面的代码使用atomic包下面的原子操作来解决数据争用的问题。除了使用原子操作来解决数据争用问题之外，我们还可以使用锁来解决。看下面的代码：

package main

import (
	"sync"
	"runtime"
	"time"
	"fmt"
)
var num int = 10
var mutex sync.Mutex

func A(){
	for i:=1 ; i<=5 ; i++{
    //锁住
		mutex.Lock()
		temp := num
		runtime.Gosched()
		temp--
		num = temp
    //解锁
		mutex.Unlock()
	}
}

func B(){
	for i:=1 ; i<=5 ; i++{
    //锁住
		mutex.Lock()
		temp := num
		runtime.Gosched()
		temp--
		num = temp
    //解锁
		mutex.Unlock()
	}
}

func main(){
	runtime.GOMAXPROCS(1)
	go A()
	go B()
	//暂停1秒,让gorouthine运行完
	time.Sleep( 100 * time.Millisecond)
	fmt.Println("num=",num)
	fmt.Println("main函数执行完成")
}
复制代码

上面的代码我们使用了互斥锁来解决了数据争用的问题。

转载于:https://juejin.im/post/5a2b4dee6fb9a0450b664f9e