go语言并发编程

<h3>一、goroutine</h3> <blockquote>

与传统的系统级线程和进程相比，协程的大优势在于其“轻量级”，可以轻松创建上百万个而不会导致系统资源衰竭，而线程和进程通常多也不能超过1万个。这也是协程也叫轻量级线程的原因。
golang原生支持并发编程
轻量级线程
非抢占式多任务处理，由协程主动交出控制权
编译器/解释器/虚拟机层面的多任务
多个协程可能在一个或多个线程上运行

</blockquote>

---

<h4>1.1 go对协程的实现</h4> <blockquote>

goroutine--Go对协程的实现
go 函数名：启动一个协程执行函数体

</blockquote> <pre><code class="lang-go hljs">package main import ( "fmt" "time" ) func test_Routine() { fmt.Println("This is one routine!!!") } func Add(x, y int) { z := x y fmt.Println(z) } func main() { for i := 1; i < 10; i { //启动一个协程执行函数体 go Add(i, i) } //为避免并发执行后程序立即退出，先sleep 2秒 time.Sleep(2) }</code></code></pre>

---

<pre><code class="lang-go hljs">package main import ( "fmt" "runtime" "time" ) func main() { //定义一个数组 var a [10]int //循环并发执行匿名函数，实现 for i := 0; i < 10; i { go func(i int) { for { a[i] //主动让go协程让出时间片 runtime.Gosched() } }(i) } time.Sleep(time.Millisecond) fmt.Println(a) }</code></code></pre> <h3>二、channel</h3> <blockquote>

Go语言在语言级别提供的goroutine间的通信方式
不要通过共享来通信，而要通过通信来共享。
channel的读写默认是阻塞的，除非有goroutine对其进行操作。

</blockquote>

<pre><code class="lang-go hljs">package main import ( "fmt" "strconv" ) //定义一个加法函数，传入x，y整型参数，quit整型通道 func Add(x, y int, quit chan int) { z := x y fmt.Println(z) //发送 1 到channel quit quit <- 1 } //读取channel中的数据 func Read(ch chan int) { //将channel中数据发送出去，赋值给value value := <-ch fmt.Println("value:" strconv.Itoa(value)) } //写数据到channel中 func Write(ch chan int) { //ch <- 10 } func main() { //ch := make(chan int) //go Read(ch) //go Write(ch) //time.Sleep(10) //fmt.Println("end of code") //定义一个容量为10的非阻塞整型通道切片，变 量名为chs chs := make([]chan int, 10) //循环地给channel切片chs初始化 for i := 0; i < 10; i { chs[i] = make(chan int) go Add(i, i, chs[i]) } //遍历channel切片chs,并从channel中发出数据，留空 for _, v := range chs { <-v } }</code></code></pre> <h3>三、缓冲channel</h3> <blockquote>

定义: c = make(chan int, n) n为缓冲区的大小，代表channel可以存储多少个元素，这几个元素可以无阻塞的写入，缓存的元素写满之后阻塞，除非有goroutine操作。

</blockquote>

---

<blockquote>

例子中定义一个容量为2的channel,

</blockquote>

---

<pre><code class="lang-go hljs">// 缓冲channel package main import ( "fmt" "time" ) // 定义一个chnnel类型变量 ch var ch chan int //测试buffered channel函数 func test_channel() { // 第一次发送常量1到channel ch ch <- 1 fmt.Println("ch 1") // 第二次发送常量1到channel ch ch <- 1 fmt.Println("ch 2") // 第三次发送常量1到channel ch ch <- 1 fmt.Println("come to end goroutine 1") } func main() { ch = make(chan int, 0) // 等价于 ch = make(chan int) 都是不带缓冲的channel ch = make(chan int, 2) // 是带缓冲的channel go test_channel() time.Sleep(2 * time.Second) fmt.Println("running end!") <-ch time.Sleep(time.Second) } output: ch 1 ch 2 running end! come to end goroutine 1</code></code></pre>

---

<pre><code class="lang-go hljs">package main import "fmt" func main() { c := make(chan int, 3 )//修改2为1就报错，修改2为3可以正常运行 c <- 1 c <- 2 fmt.Println(<-c) fmt.Println(<-c) }</code></code></pre> <h3>四、select</h3> <blockquote>

Linux很早就引入的函数，用来实现非阻塞的一种方式。Go语言直接在语言级别支持select关键字，用于处理异步IO 问题。我们上面介绍的都是只有一个channel的情况，那么如果存在多个channel的时候，我们该如何操作呢，Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。
select默认是阻塞的，只有当监听的channel中有发送或接收可以进行时才会运行，当多个channel都准备好的时候，select是随机的选择一个执行的。

</blockquote> <pre><code class="lang-go hljs">package main import ( "fmt" "time" ) func main() { ch := make(chan int) //匿名函数，传入一个参数整型channel类型ch go func(ch chan int) { ch <- 1 }(ch) time.Sleep(time.Second) select { //如果ch成功读到数据，则执行下面的语句 case <-ch: fmt.Print("come to read ch!") default: fmt.Print("come to default!") } }</code></code></pre>

---

<pre><code class="lang-go hljs">// 实现超时控制 package main import ( "fmt" "time" ) func main() { ch := make(chan int) //定义一个channel timeout timeout := make(chan int, 1) //定义一个匿名函数，用来实现超时控制 go func() { time.Sleep( time.Second) timeout <- 1 }() select { case <-ch: fmt.Print("come to read ch!\n") case <-timeout: fmt.Print("come to timeout!\n") } fmt.Print("end of code!") }</code></code></pre>

---

<pre><code class="lang-go hljs">// 使用time.After(time.Second)实现控制 package main import ( "fmt" "time" ) func main() { ch := make(chan int) select { case <-ch: fmt.Print("come to read ch!\n") case <-time.After(time.Second): fmt.Print("come to timeout!\n") } fmt.Print("end of code!") }</code></code></pre>

---

<pre><code class="lang-go hljs">// goroutine_2.go package main import ( "fmt" "runtime" "strconv" "time" ) func main() { //协程1 go func() { for i := 1; i < 100; i { if i == 10 { //主动出让cpu 使用的话 需要 导入 runtime包 runtime.Gosched() } fmt.Println("routine 1:" strconv.Itoa(i)) } }() //协程2 go func() { for i := 100; i < 200; i { fmt.Println("routine 2:" strconv.Itoa(i)) } }() time.Sleep(time.Second) }</code></code></pre>

---

到此这篇关于“go语言并发编程”的文章就介绍到这了,更多文章或继续浏览下面的相关文章，希望大家以后多多支持JQ教程网！

您可能感兴趣的文章：
想系统学习GO语言(Golang
Go 语言一本通
go语言和php的区别是什么？
go语言和python哪个难
Go语言发展历史、核心、特性及学习路线
关于Golang的介绍
Go语言学习3----Go语言特色
初识 Go 语言
go run main.go 参数_Go语言入门：Hello world
初识GO语言以及GO语言安装及环境搭建