goland go程 channel select

已于 2023-12-15 14:33:18 修改
阅读量43 收藏
点赞数
分类专栏： golang 文章标签： golang
于 2021-07-28 15:51:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Waller_/article/details/119181777
版权

go程

补充: 每当有一个进程启动时,系统会自动打开三个文件:

标准输入: stdin

标准输出:stdout

标准错误:stderr

当运行结束,操作系统会自动关闭着三个文件

import (
	"fmt"
	"time"
)

func foo()  {
	fmt.Println("foo ")
	time.Sleep(time.Microsecond * 100)
}

func fun()  {
	fmt.Println("fun ")
	time.Sleep(time.Microsecond * 100)
}

func main() {
	go foo()
	go fun()
	// main 为主go程, 若main运行结束,那么其内部产生的子go程也随即结束
	for {
		;
	}
}

runtime.Gosched()

出让go程运行的cpu权限,当下次再拿到cpu执行权限后,接着Gosched出让的位置继续向后执行代码

import (
	"fmt"
	"runtime"
	"time"
)

func foo()  {
	for   {
		fmt.Println("foo ")
	}	//time.Sleep(time.Microsecond * 100)
}

func main() {
	go foo()
	for {
		runtime.Gosched()  // 出让cpu执行权限
		fmt.Println("main")
	}
}

runtime.Goexit()

立即停止当前的go程,调度器确保所有已注册的defe延迟调用被执行

import (
	"fmt"
	"runtime"
	"time"
)

func test()  {
	defer fmt.Println("bbb")
	//return  // 结束函数
	runtime.Goexit()  // 结束go程,这里结束的是 foo() go程
    defer fmt.Println("ddd")  // 与return一样,此处定义的defer不会被执行
}

func foo()  {
	for   {
		fmt.Println("aaa ")
		test()
		fmt.Println("cccc")
	}	//time.Sleep(time.Microsecond * 100)
}

func main() {
	go foo()
	for {
		;
	}
}
>>>:
aaa
bbb

runtime.GOMAXPROCS()

用来设置可以并行计算的cpu核数最大值,并返回之前的值

func main() {
	n := runtime.GOMAXPROCS(1)
	fmt.Println(n)
    n = runtime.GOMAXPROCS(2)
	fmt.Println(n)
	for {
		go fmt.Print(0)
		fmt.Print(1)
		;
	}
}

更多runtime包详情

channel

管道,并发核心单元通过它就可以发送或者接收数据进行通讯,这在一定程度上进一步降低了变成的难度

特点: channel是一种数据类型,用来解决协程的同步问题,以及协程之间的数据共享问题

goroutine运行在相同的地址空间因此访问共享内存必须做好同步,goroutine奉行通过通信来共享内存,而不是共享内存来通信

channel是引用类型,是个队列,可用于多个goroutine通信,其内部实现的同步,确保并发安全

定义

与map类似,channel也对应一个make创建的地城数据结构的引用,和其他引用类型一样,channel的零值也是nil

ch := make(chan channel中传递的数据类型, channel容量)
容量 = 0: 无缓冲channel  特点:具备同步的能力,常用于同步
容量 > 0: 有缓冲channel  特点:channel内可以存储内容,达到容量上限后才阻塞,常用于异步

注意:
channel有读端和写端,少了任何一端都会死锁报错
同一个go程内只能拥有同一个channel的一端(或读端,或写端)

说明:
同步: 在两个过多个携程(线程)间,保持数据内容一致性的机制

无缓冲channel

利用channel 处理go程对于共享数据的同步问题

func main() {
	ch := make(chan string)
    fmt.Println(len(ch), cap(ch))  // len(ch): channel中剩余内容的数量, cap(ch):channel的容量
	go func() {
		for i:=0;i<5;i++{
			fmt.Println(i)
		}
		ch <- "go程结束"  // 写端
	}()
	str := <-ch
	fmt.Println(str)  // 读端
}

案例:

import (
	"fmt"
	"time"
)

func test(str string)  {
	for _, s := range str{
		//fmt.Println(s)  // 打印的是字节
		fmt.Printf("%c",s)
		time.Sleep(time.Millisecond * 100)
	}
}
// c chan <- int :channel的写端
func foo(str string, c chan <- int)  {
	test(str)
	c <- 1  // 当此处的写端写入内容后,对应的读端会立即读到内容,运行起来
}
// c chan <- int : channel的读端
func fun(str string, c <- chan int)  {
	<- c  // 此时channel的读端是阻塞状态,只有写端写入内容,读端才会继续运行
	test(str)
}

func main() {
	// 主go程中定义,子go程中使用
	// 利用channel的阻塞特点,当channel中没有内容时,就发生阻塞
	ch := make(chan int)    // 无缓冲channel
	go foo("hello", ch)
	go fun("world", ch)

	for {
		;
	}
}

有缓冲channel

当容量慢了之后阻塞，多用于并发

func main() {
	ch := make(chan int, 3)
	fmt.Println(len(ch), cap(ch))  // channel 长度和容量
	go func() {
		for i:=0;i<8;i++{
			ch <- i  // 写端
			fmt.Printf("子go程 i=%d \n", i)
		}

	}()
	for i:=0;i<8;i++{
		num := <-ch
		fmt.Printf("main i=%d \n", num)  // 读端
	}
}

关闭channel

确定不再向对端发送或接收数据时,就可关闭channel

close(channel)  // 大多数用来关闭发送端

注意:

channel不像文件一样需要经常去关闭,只有当你确实没有任何发送的数据了,或者你想显式的结束rang循环之类的,才去关不channel

  • 关闭channel后，无法向channel 再发送数据(引发 panic 错误后导致接收立即返回零值)；

  • 关闭channel后，可以继续从channel接收数据；

  • 对于nil channel，无论收发都会被阻塞

  • 已经关闭的channel,不能再向其写数据,否则报错

  • 写端已经关闭的channel,可以从中继续读数据,将数据读出后,再继续读,读到0

对端可以判断channel是否关闭
if num, ok := <- ch ; ok == ture{}
如果对端已经关闭, ok == false num无数据
如果对端没关闭, ok == true num是取到的数据
func main() {
	ch := make(chan int, 2)
	fmt.Println(len(ch), cap(ch))  // channel 长度和容量
	go func() {
		for i:=0;i<5;i++{
			ch <- i  // 写端
			fmt.Printf("子go程 i=%d \n", i)
		}
		close(ch)
	}()
	time.Sleep(time.Millisecond * 100)
	for {
		if num, ok := <-ch; ok==true{
			fmt.Printf("main i=%d \n", num)  // 读端
		} else {
			break
		}
	}
}

可以使用 range 来迭代不断操作channel

package main

import (
    "fmt"
)

func main() {
    c := make(chan int)

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 for data := range c 那一行
        close(c)
    }()
    // 类似循环 <- c ， range能发现对端是否关闭，对端关闭后，退出循环
    for data := range c {
        fmt.Println(data)
    }
    fmt.Println("Finished")
}

单向channel

默认情况下，通道channel是双向的，也就是，既可以往里面发送数据也可以同里面接收数据。

但是，我们经常见一个通道作为参数进行传递而值希望对方是单向使用的，要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向。

// ch1是一个正常的channel，是双向的
var ch1 chan int       ch := make(chan int)
 // ch2是单向channel，只用于写float64数据
var ch2 chan<- float64  ch2 := make(chan <- folat64)
// ch3是单向channel，只用于读int数据
var ch3 <-chan int     ch3 := make(<- chan int)

转换:

双向channel可转换为单向channel, 前提channel内的数据类型要一致

单向channel不能转换为双向channel

    c := make(chan int, 3)
    var send chan<- int = c // send-only
    var recv <-chan int = c // receive-only
    send <- 1
    //<-send //invalid operation: <-send (receive from send-only type chan<- int)
    <-recv
    //recv <- 2 //invalid operation: recv <- 2 (send to receive-only type <-chan int)

    //不能将单向 channel 转换为普通 channel
    d1 := (chan int)(send) //cannot convert send (type chan<- int) to type chan int
    d2 := (chan int)(recv) //cannot convert recv (type <-chan int) to type chan int

channel死锁

  • 单go程死锁: channel至少在两个go程里通信
  • go程间channel访问顺序导致死锁: 读写端要同时有机会运行,并且读端要在写之前运行
  • 多go程交多channel叉死锁:即 互相等待,A go程拿着ch1的时候尝试拿ch2,B go程拿着ch2的时候尝试拿ch1
  •  锁(互斥锁,读写锁)与channel混用, 锁与channel互相等待-----隐性死锁

案例:

var rwMut sync.RWMutex  // 锁只有一把!!!!有读写两种属性

func readGo(in <-chan int, i int)  {
	for{
		rwMut.RLock()  // 加读锁  问题原因: readGo拿到锁, 并等待channel读数据
		num:= <-in
		fmt.Printf("%d th , read %d \n", i, num)
		rwMut.RUnlock()  // 解读锁
	}
}
func writeGo(out chan<- int, i int, qu chan <- int)  {
	for q := 1;q < 500; q++{
		if q == 3{
			qu <- 1
		}
		num := rand.Intn(1000)
		rwMut.Lock()  // 加写锁  问题原因: writeGo等待拿锁后向channel中写入数据 
		out <- num
		fmt.Printf("%d th , write %d \n", i, num)

		time.Sleep(time.Millisecond * 100)
		rwMut.Unlock()  // 解写锁
	}
}

func main() {
	quit := make(chan int)
	ch := make(chan int)

	rand.Seed(time.Now().UnixNano())
	for i:=1;i < 5 ;i++  {
		go readGo(ch, i+1)
	}

	for i:=1;i < 5 ;i++  {
		go writeGo(ch, i+1, quit)
	}
	<- quit
}

select

用来监听channel中的数据流动

select与switch语句相似,select中每个case语句必须是一个IO操作

	select {
	case <- ch1:
		// 如果ch1成功读到数据,则执行case代码块内的代码
	case ch2 <- 5:
		// 如果成功向ch2写数据,则执行case代码块内的代码
	default:
		//如果上面的都没有执行,就进入defer的流程
	}

注意:

  • 如果给出了 default 语句，那么就会执行 default 语句；select本身不带循环机制

  • 如果没有 default 语句，那么 select 语句将被阻塞，直到至少有一个通信可以进行下去；

func main() {
	ch := make(chan int)
	exit := make(chan bool)
	go func() {
		time.Sleep(time.Millisecond * 100)
		ch <- 1
		exit <- true
	}()
	tag:for   {
		select {
		case <- ch:
			fmt.Println("select ch")
		case <- exit:
			fmt.Println("select exit")
			break tag  // 注意: break 跳出的是select,为了跳出for循环,此处设置标签
			// return  也可以属于return整体跳出
		default:
			time.Sleep(time.Millisecond * 50)
			fmt.Println("defer")
			//如果上面的都没有执行,就进入defer的流程
		}
	}
}
>>>:
defer
defer
select ch
select exit

i0208
关注
专栏目录
golang channel和select
firefly
06-10 1万+
Channel 从根本上来说，channel只是一个数据结构，可以被写入数据，也可以被读取数据 所谓的发送数据到channel，或者从channel读取数据，说白了就是对一个数据结构的操作 因为协程原则上不会出现多线程编程中经常遇到的资源竞争问题，所以这个channel的数据结 构甚至在访问的时候都不用加锁 因为Go语言支持多CPU核心并发执行多个goroutine，会造成资 源竞争，所以在必要的位置还是需要加锁的 通道可以传输 int, string, 结构体，甚至是函数 通道传递是
Golang中利用channel和select实现计算目录大小
Arlingtonroad的博客
06-25 417
package main import ( "flag" "fmt" "io/ioutil" "os" "path/filepath" "sync" "time" ) var ( dir *string = flag.String("p", "/Users/xiaoshan02/gopath", "input directory") routineCount *int = flag.Int("c", 10, "concurrency of program") verbose *bo.
goland分段锁
myIddddd的博客
03-19 114
解决方法是：我们注意到哈希表的长度远少于可能的键的数量，反过来说多个键可以共用一个哈希槽。解决这个问题的方式： 我们可以要求有协程都按照相同顺序加锁，若两个协程都想获得键a和键b的锁，那么必须先获取键a的锁后获取键b的锁，这样就可以避免循环等待。在锁定多个key时需要注意，若协程A持有键a的锁试图获得键b的锁，此时协程B持有键b的锁试图获得键a的锁则会形成死锁。2，命令当且仅当所有给定键都不存在时所有给定键设置值, 因此我们需要锁定所有给定的键直到完成所有键的检查和设置。
goland 技巧沉淀
blaze_jack
05-04 399
关于配置读写的一种线程安全实现 type Config struct { Value string Expire int64 rwLock sync.RWMutex } func (config *Config) GetValue() (string, bool) { val := "" ok := false config.rwLock.RLock() if time.Now().Unix()-config.Expire < 5 { ok = true val = c.
golang的time包：秒、毫秒、微秒、纳秒
热门推荐
Mirage
06-26 18万+
golang的time包：纳秒、微秒、毫秒、秒。
go语言 互斥锁 读写锁
Waller_的博客
07-28 667
互斥锁 每个资源都对应于一个可称为"互斥锁"的标记，这个标记用来保证在任意时刻，只能有一个协程（线程）访问该资源。其它的协程只能等待。 互斥锁是传统并发编程对共享资源进行访问控制的主要手段，它由标准库sync中的Mutex结构体类型表示。sync.Mutex类型只有两个公开的指针方法，Lock和Unlock。Lock锁定当前的共享资源，Unlock进行解锁。 在使用互斥锁时，一定要注意：对资源操作完成后，一定要解锁，否则会出现流程执行异常，死锁等问题。通常借助defer。锁定后，立即使用defer..
golang channel select 使用
凄魅旋律
07-10 1007
golang channel select for
GoLang关于channel初始化和使用的一些细节
weixin_42847293的博客
03-29 2541
GoLang关于channel初始化和使用的一些细节前言makechanchanRecv（chanSend）结尾参考 前言 本文主要围绕channel的一些细节上做些总结和分享。主要涉及到两个方面一个是初始化，另外一个就是在数据实际接收和发送的时候的一些细节；这两个离不开golang编译器的协助，所以在了解go源码时，go编译器其实在其中起到了很大的作用。 makechan make 方法 主要是初始化 切片、map和channel 这里主要说make(chan type) 例如：make(chan int
go/goland TCP 服务 源码.zip
06-11
Go语言，也被称为Golang，是Google推出的一种静态类型的、编译型的、并发型且具有垃圾回收功能的编程语言。它特别适合于构建网络服务和高效能的应用程序，包括TCP服务。Goland是JetBrains公司为Go语言开发的一款强大...
Leetcode-Go:Golang练习
04-06
8. **Go语言的最佳实践** - 遵循Golang的代码风格和规范，如使用短变量名、保持函数小且单一职责等。 - 使用`go fmt`工具自动格式化代码，确保代码一致性。 - 利用Golang的内置测试框架进行单元测试和集成测试。 ...
golang中的channel是什么？如何使用channel？channel的原理是什么？
tyxjolin的专栏
03-30 3234
通道是 Go 编程语言的一个基本特性，它提供了协程之间通信和同步的方式。协程是轻量级线程，允许并发执行代码。通道用于在协程之间传递数据和控制流。本文将探讨通道的使用方法、通道的底层实现以及如何使用通道进行高效的并发编程。通道是一种类型，类似于一个队列。通过使用通道，我们可以在协程之间传递数据，协程会在通道上阻塞等待数据的到来，直到数据被发送到通道中，协程才会继续执行。ch := make(chan 数据类型)其中，数据类型指定了通道可以传递的数据类型。通道可以传递任意类型的数据，包括自定义类型。
go语言 rlock() defer runlock()_Golang 语言的内存模型
weixin_35719402的博客
12-21 880
01介绍Go 内存模型可以保证一个 goroutine 可以读取在不同 goroutine 中修改同一指定变量的值。02建议程序中的一个 goroutine 修改的数据，如果同时有其它 goroutine 读取该数据，则需要保证程序串行化执行。为了保证程序串行化执行，我们需要使用 channel 通道操作或其他同步原语(例如 sync 和 sync/atomic 包中的原语)来保护数据。...
Golang 调用 C/C++ 库
Waller_的博客
08-23 4865
参考 目录结构: |-importC | |-lib | | |-libvideo.dll | | |-libvideo.so | |-include | | |-video.h | | |-video.c | |-main.go C的代码如下： 头文件 video.h //video.h #ifndef VIDEO_H #define VIDEO_H void exeFFmpegCmd(); // 声明 int sum(int a,int b); #endif 源文件
golang TCP 实现文件发送接收
Waller_的博客
08-03 2133
首先获取文件名,借助os包中都得stat()函数来获取文件属性信息,在函数返回的文件属性中包含文件名和文件大小,Stat参数中name传入的是文件访问的绝对路径,FileInfo中的Name()函数可以将文件名单独提取出来 os.Stat func (f *File) Stat() (fi FileInfo, err error) Stat返回描述文件f的FileInfo类型值。如果出错，错误底层类型是*PathError。 type FileInfo type FileInfo interf
Go语言 环境搭建
Waller_的博客
09-04 1568
1.先创建你的工作空间(Workspaces)，官方建议目录$HOME/go。三、配置环境 .bashrc。解压版：解压到指定目录下。安装版：双加安装即可。
golang Json 序列化 反序列化
Waller_的博客
07-30 894
序列化 结构体转json package main import ( "encoding/json" "fmt" ) // 注意: 结构体转json, 内部成员变量名一定要大写 type IT struct { // 二次编码 Company string `json:"-"` // 定义json不序列化该字段 Subject []string `json:"subj"` // 定义json序列化后的键名为 subj IsOk bool `json:",string
Go语言 Go的执行原理以及Go的命令
Waller_的博客
09-04 885
比如，本机安装Go语言的版本是1.x，那么go get命令会在该代码包的远程仓库中寻找名为“go1”的标签或者分支。如果不加这个-u标记，执行go get一个已有的代码包，会发现命令什么都不执行。这种情况下，go build 命令只是检查库源码文件的有效性，只会做检查性的编译，而不会输出任何结果文件。注意，go get命令会把当前的代码包下载到$GOPATH中的第一个工作区的src录中，并安装。go build编译命令源码文件，则会在该命令的执行目录中生成一个可执行文件，上面的例子也印证了这个过程。
goland配置go语言
最新发布
07-27
要配置Go语言的开发环境，可以按照以下步骤进行操作： 1. 首先，打开命令提示符(cmd)窗口，输入"go env"命令并回车，查看GOPATH和GOROOT的配置信息是否正确。\[1\] 2. 接下来，前往JetBrains官网下载并安装GoLand ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值