go 协程返回值处理操作

时间:2022-01-05 23:41:34

我就废话不多说了,大家还是直接看代码吧~

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main
import "fmt"
import "sync"
var ch = make(chan int)
func do(lock *sync.Mutex, ct *int) {
 lock.Lock()
 *ct++
 lock.Unlock()
 ch <- 1
}
func main() {
 fmt.Println("hello thread")
 var ct = 0
 lock := &sync.Mutex{}
 for i:=0; i<10; i++ {
  go do(lock, &ct)
 }
 for i:=0; i<10; i++ {
  <- ch
 }
 fmt.Println("ct=", ct)
}

输出: 10

补充:Goroutine协程之间的数据沟通的方式

一个服务器物理线程能够跑多个goroutine,成千上万个goroutine 实际上跑在物理线程上的也就几十个,但是java和c++创建成千上万个线程会使得系统反应更慢,这是为什么goroutine能很快的原因。

那么goroutine协程之间是如何进行通信的呢?有两种方式,

第一使用全局变量和锁同步:读写锁或互斥锁对全局变量进行加锁,实现多个goroute的数据共享。

第二:Channel 管道进行数据同步

1.加锁操作

 

互斥锁就是将公共资源进行加锁操作,以便于goroute对数据进行更改。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package main
import (
 "fmt"
 lock "sync"
 "time"
)
 
type task struct {
 n int
}
 
//通过全局的 map 来通讯
var (
 sum
)
 
func calc(t *task) {
 var sum uint64
 sum = 1
 for i := 1; i < t.n; i++ {
 sum *= uint64(i)
 }
 fmt.Printf("%d! = %v\n", t.n, sum)
 lock.Lock()
 sum++
 lock.Unlock()
}
 
func main() {
 for i := 0; i < 100; i++ {
 var t *task = &task{n: i}
 go calc(t)
 }
 
 time.Sleep(5 * time.Second)
 lock.Lock()
 // for k, v := range m {
 // fmt.Printf("%d! = %v\n", k, v)
 // }
 lock.Unlock()
}

2.channel管道通信

 

单纯地将函数并发执行是没有意义的。函数与函数间需要交换数据才能体现并发执行函数的意义。虽然可以使用共享内存进行数据交换,但是共享内存在不同的 goroutine 中容易发生竞态问题。为了保证数据交换的正确性,必须使用互斥量对内存进行加锁,这种做法势必造成性能问题。

Go 语言提倡使用通信的方法代替共享内存,这里通信的方法就是使用通道(channel)

channel 具有几个特性:

1.类似unix中的管道(pipe)

2.先进先出

3.线程安全,多个goroutine同时访问,不需要加锁

4.channel是有类型的,一个整数的channel 只能存放整

2.1使用通道发送数据

通道创建后,就可以使用通道进行发送和接收操作。

1) 通道发送数据的格式

通道的发送使用特殊的操作符<-,将数据通过通道发送的格式为:

通道变量 <- 值

通道变量:通过make创建好的通道实例。

值:可以是变量、常量、表达式或者函数返回值等。值的类型必须与ch通道的元素类型一致。

2) 通过通道发送数据的例子

使用 make 创建一个通道后,就可以使用<-向通道发送数据,代码如下:

?
1
2
3
4
5
6
// 创建一个空接口通道
ch := make(chan interface{})
// 将0放入通道中
ch <- 0
// 将hello字符串放入通道中
ch <- "hello"

2.2 使用通道接收数据

1)通道接收同样使用<-操作符,通道接收有如下特性:

① 通道的收发操作在不同的两个 goroutine 间进行。

由于通道的数据在没有接收方处理时,数据发送方会持续阻塞,因此通道的接收必定在另外一个 goroutine 中进行。

② 接收将持续阻塞直到发送方发送数据。

如果接收方接收时,通道中没有发送方发送数据,接收方也会发生阻塞,直到发送方发送数据为止

③ 每次接收一个元素。

通道一次只能接收一个数据元素。

通道的数据接收一共有以下 4 种写法。

2) 阻塞接收数据

阻塞模式接收数据时,将接收变量作为<-操作符的左值,格式如下:

data := <-ch

执行该语句时将会阻塞,直到接收到数据并赋值给 data 变量。

3) 非阻塞接收数据

使用非阻塞方式从通道接收数据时,语句不会发生阻塞,格式如下:

data, ok := <-ch

data:表示接收到的数据。未接收到数据时,data 为通道类型的零值。

ok:表示是否接收到数据。

非阻塞的通道接收方法可能造成高的 CPU 占用,因此使用非常少。如果需要实现接收超时检测,可以配合 select 和计时器 channel 进行,可以参见后面的内容。

4) 接收任意数据,忽略接收的数据

阻塞接收数据后,忽略从通道返回的数据,格式如下:

<-ch

执行该语句时将会发生阻塞,直到接收到数据,但接收到的数据会被忽略。这个方式实际上只是通过通道在 goroutine 间阻塞收发实现并发

2.3 发生阻塞的2种情况

1)发送方发送阻塞:在通道数据没有接收方处理时,通道的数据一开始会存放到固定的数据缓冲区内,超出缓冲区的大小将发生持续阻塞。

?
1
2
3
4
5
6
7
8
9
10
11
package main
func main() {
 var ch chan int
 ch = make(chan int, 5) //定义数据缓存区设置为5个大小
 //将数据保存在缓冲区内并不会发生当前线程阻塞
 for i := 0; i < 5; i++ {
 ch <- i
 }
 //但将第6个加入通道(超出缓冲区)就会立即阻塞当前的协程(即main线程) 最后panic
 ch <- 6
}

这个程序的执行结果直接painc 因为在管道加入ch <- 6 的时候因为缓存区没有那么大,并且没有接收方去消化数据,故painc。

2) 数据接收方发生阻塞:如果接收方没有接收到数据,接收方等待发送方发送数据,等待的过程也会使数据接收的协程发生阻塞。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
import (
 "fmt"
 "time"
)
 
func main() {
 var ch chan int
 ch = make(chan int) //无定义数据缓存区
 
 go func() {
 var a = <-ch //执行第一次取出
 fmt.Println(a)
 }()
 time.Sleep(time.Second * 4) //主线程等待4才给管道数据
 ch <- 1 //通道里只入一个数据
 
 //接收方协程是一个并发匿名函数
 time.Sleep(time.Second * 5) //主线程等待5秒让goroute有处理时间然后结束
 }

这个程序的执行结果是延时4秒后控制台打印出通道的值1,5秒后主程序结束。上边的程序是先让接收者协程开启等待接收通道的值,而发送者是主函数延迟4秒后才将值放入通道ch,匿名函数中不得不等待发送者的值,所以造成了匿名并发函数的阻塞。 我们可以思考到,如果去掉4秒等待的时间, 这个程序就是使用channel作为协程之间同步的最简单的例子,我们发现channel同步的特性就是无数据缓存区。

同样一个程序,当你把接受者 go func() 程序放到 ch<-1 的下边,就会painc。 为什么? 以为ch通道并没有缓存区,并且接受者还未执行。导致painc。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main
import (
 "fmt"
 "time"
)
 
func main() {
 var ch chan int
 ch = make(chan int) //无定义数据缓存区
 
 //time.Sleep(time.Second * 4) //主线程等待4才给管道数据
 
 ch <- 1 //通道里只入一个数据
 
 //接收方协程是一个并发匿名函数
 //一个并发执行的协程
 go func() {
 
 var a = <-ch //执行第一次取出
 fmt.Println(a)
 }()
 time.Sleep(time.Second * 5) //主线程等待5秒让goroute有处理时间然后结束
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持服务器之家。如有错误或未考虑完全的地方,望不吝赐教。

原文链接:https://blog.csdn.net/robertkun/article/details/103670973