理解Go的Goroutine和channel

原创 2017年04月21日 14:30:39
进程,线程的概念在操作系统的书上已经有详细的介绍。进程是内存资源管理和cpu调度的执行单元。为了有效利用多核处理器的优势,将进程进一步细分,允许一个进程里存在多个线程,这多个线程还是共享同一片内存空间,但cpu调度的最小单元变成了线程。

那协程又是什么东西,以及与线程的差异性??

协程,可以看作是轻量级的线程。但与线程不同的是,线程的切换是由操作系统控制的,而协程的切换则是由用户控制的。

最早支持协程的程序语言应该是lisp方言scheme里的continuation(续延),续延允许scheme保存任意函数调用的现场,保存起来并重新执行。Lua,C#,python等语言也有自己的协程实现。

go的goroutinue

今天要讲的goroutinue,本质上就是协程。但有两点不同:
1. goroutinue可以实现并行,也就是说,多个协程可以在多个处理器同时跑。而协程同一时刻只能在一个处理器上跑(把宿主语言想象成单线程的就好了)。

2. goroutine之间的通信是通过channel,而协程的通信是通过yield和resume()操作。


在Go里实现goroutine非常简单,只需要在函数的调用前面加关键字go即可,

go doSth()

下面的例子演示,启动10个goroutines分别打印索引。

package main
import (
"fmt"
"time"	
)

func main() {
	for i:=1;i<10;i++ {
		go func(i int) {
			fmt.Println(i)
		}(i)
	}
	//暂停一会,保证打印全部结束
	time.Sleep(1e9)
}

在分析goroutine执行的随机性和并发性,把goroutine看作是java的守护线程是完全可以的。上面的例子中,启动了10个goroutine,再加上main函数的主goroutine,总共有11个goroutines。由于goroutine类似于”守护线程“,如果主goroutine不等待片刻,可能程序就没有输出打印了。上面的例子输出如下:(输出的索引是完全随机的)



go的channel

在java的世界里,并发主要是靠锁住临界资源(共享内存)来保证同步的。而channel则是goroutinues之间进行通信的利器

channel可以形象比喻为工厂里的传送带,一头的生产者goroutine往传输带放东西,另一头的消费者goroutinue则从输送带取东西。channel实际上是一个有类型的消息队列,遵循先进先出的特点。

1. channel的操作符号

ch <- ele 表示ele被发送给channel ch;

ele2 <- ch 表示从channel ch取一个值,然后赋给ele2

2. 阻塞式channel

channel默认是没有缓冲区的,也就是说,通信是阻塞的。send操作必须等到有消费者accept才算完成。

举个栗子

package main
import "fmt"

func main() {
	ch1 := make(chan int)
	go pump(ch1) // pump hangs
	fmt.Println(<-ch1) // prints only 0
}

func pump(ch chan int) {
	for i:= 0; ; i++ {
		ch <- i
	}
}

上面代码pump()里的channel在接受到第一个元素后就被阻塞了,直到主goroutinue拿走了数据。最终channel阻塞在接受第二个元素,程序只打印 0

3 带有buff的channel

没有buff的channel只能容纳一个元素,而带有buff的channel则可以非阻塞容纳N个元素。发送数据到buffed channel不会被阻塞,除非channel已满;同样的,从buffed channel取数据也不会被阻塞,除非channel空了。这有点像java的ConcurrentLinkedQueue。


goroutine和channel的应用

结合goroutine和channel,可以模拟出java处理并发情况的若干情景

1. 实现future

package main
import "fmt"
import "time"

func main() {
	future := heavyCalculation()
	fmt.Println(<-future)
}

func heavyCalculation() (chan int) {
	
	future := make(chan int)
	go func() {
		//模拟耗时计算
		time.Sleep(1e9)
		future <- 666
	}()
	
	return future
}

2. 实现CountDownLatch

package main
import "fmt"

func main() {
	nTask := 5
	ch := make(chan int)
	for i:=1;i<=nTask;i++ {
		go doTask(ch)
	}
	for i:=1;i<=nTask;i++ {
		<-ch
	}
	fmt.Println("finished all tasks")
}

func doTask(ch chan<- int) {
	//doSth...
	ch<- 0
}


3. 并发访问对象

Hashtable是线程安全的,意味着多条线程同时操作hashtable对象是不会引起状态不一致的。查看Hashtable源代码可知,其几乎全部方法都添加synchronized关键字,例如put(),remove()操作。在go里,我们可以在对象内部保存一个函数类型的channel,涉及对象状态的操作都放入channel里,对象初始化的时候开启一条goroutinue,不停地执行匿名函数。

package main
import (
"fmt"
"strconv"
"time"	
)

type Person struct {
	Name string
	salary float64
	chF chan func()
}
func NewPerson(name string, salary float64) *Person {
	p := &Person{name, salary, make(chan func())}
	go p.backend()
	return p
}
func (p *Person) backend() {
	for f := range p.chF {
		f()
	}
}

func (p *Person) AddSalary(sal float64) {
	p.chF <- func() { p.salary += sal }  // (ThreadSafe)
	
	// p.salary += sal (NotThreadSafe)
}

func (p *Person) ReduceSalary(sal float64) {
	p.chF <- func() { p.salary -= sal }  // (ThreadSafe)
	
	// p.salary -= sal (NotThreadSafe)
}

func (p *Person) Salary() float64 {
	fChan := make(chan float64)
	p.chF <- func() { fChan <- p.salary }
	return <-fChan
}
func (p *Person) String() string {
	return p.Name + " - salary is: " + 
	strconv.FormatFloat(p.Salary(), 'f', 2, 64)
}

func main() {
	p := NewPerson("Kingston", 8888.8)
	fmt.Println(p)
	for i:=1;i<=500;i++ {
		go func() {
			p.AddSalary(1);
		}()
	}
	for i:=1;i<=500;i++ {
		go func() {
			p.ReduceSalary(1);
		}()
	}
	time.Sleep(3e9)
	fmt.Println("After changed:")
	fmt.Println(p)
}


4. 生产者消费者模式

每次涉及到并发情景,都喜欢用生产者消费者模式,因为它太经典啦

2个面包师同时生产面包,5个顾客同时取面包(尽管以下例子的打印不能说明并发的真实情况,因为channel的操作和打印的组合不是原子操作,但不影响程序的逻辑)

package main
import (
"fmt"
"time"
)


func main() {
	bread := make(chan int,3)
	for i:=1;i<=2;i++ {
		go produce(bread)
	}
	for i:=1;i<=5;i++ {
		go consume(bread)
	}
	time.Sleep(1e9)
}

func produce(ch chan<- int) {
	for {
		ch <- 1
		fmt.Println("produce bread")
		time.Sleep(100 * time.Millisecond)
	}
}

func consume(ch <-chan int) {
	for {
		<-ch
		fmt.Println("take bread")
		time.Sleep(200 * time.Millisecond)
	}
}



版权声明:本文为博主原创文章,未经博主允许不得转载。

Go语言goroutine+channel+select简介

goroutine: Go语言是原生支持语言级并发的,这个并发的最小逻辑单元就是goroutine。goroutine就是Go语言提供的一种用户态线程,这种用户态线程是跑在内核级线程之上的,goro...

Go中的goroutine和channel使用

作为一个go的新手,一开始跟着Go指南进行Go的学习,在完成指南上的Web爬虫练习时遇到了一些goroutine与channel相关的问题。...

golang语言并发与并行——goroutine和channel的详细理解(三)

Go语言并发的设计模式和应用场景 以下设计模式和应用场景来自Google IO上的关于Goroutine的PPT:https://talks.golang.org/2012/concurrenc...

golang语言并发与并行——goroutine和channel的详细理解

转载自: http://blog.csdn.net/skh2015java/article/details/60330785 http://blog.csdn.net/skh2015j...

golang语言并发与并行——goroutine和channel的详细理解(二)

Go语言的并发和并行 不知道你有没有注意到一个现象,还是这段代码,如果我跑在两个goroutines里面的话: var quit chan int = make(chan int) func l...

golang语言并发与并行——goroutine和channel的详细理解(一)

如果不是我对真正并行的线程的追求,就不会认识到Go有多么的迷人。 Go语言从语言层面上就支持了并发,这与其他语言大不一样,不像以前我们要用Thread库 来新建线程,还要用线程安全的队列库来共享数据...

深入理解Go Channel

Golang使用Groutine和channels实现了CSP(Communicating Sequential Processes)模型,channles在goroutine的通信和同步中承担着重要...

go lang学习笔记——channel机理及调度理解

理解goroutine是如何在channel的基础上通信

Goroutine + Channel 实践

背景 在最近开发的项目中,后端需要编写许多提供HTTP接口的API,另外技术选型相对宽松,因此选择Golang + Beego框架进行开发。之所以选择Golang,主要是考虑到开发的模块,都需要接受...

golang使用之使用channel限制goroutine的数量

golang虽然启动一个goroutine很廉价但并不是可以无限制的使用的. 大多数的是用channel来限制goroutine的数量 写了一个测试DEMO如下: package main im...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:理解Go的Goroutine和channel
举报原因:
原因补充:

(最多只允许输入30个字)