Golang 引用类型 channel 是 CSP 模式的具体实现，用于多个 goroutine 通讯。其内部实现了同步，确保并发安全。
channel概念
~~~
a. 类似unix中管道（pipe）
b. 先进先出
c. 线程安全，多个goroutine同时访问，不需要加锁
d. channel是有类型的，一个整数的channel只能存放整数
~~~
channel声明
var 变量名 chan 类型
~~~
package main
var ch0 chan int
var ch1 chan string
var ch2 chan map[string]string
type stu struct{}
var ch3 chan stu
var ch4 chan *stu
func main() {
}
~~~
channel初始化
使用make进行初始化，比如：
~~~
package main
import (
"fmt"
)
var ch0 chan int = make(chan int)
var ch1 chan int = make(chan int, 10)
func main() {
var ch2 chan string
ch2 = make(chan string)
var ch3 chan string
ch3 = make(chan string, 1)
ch4 := make(chan float32)
ch5 := make(chan float64, 2)
fmt.Printf("无缓冲 全局变量 chan ch0 : %v\n", ch0)
fmt.Printf("有缓冲 全局变量 chan ch1 : %v\n", ch1)
fmt.Printf("无缓冲 局部变量 chan ch2 : %v\n", ch2)
fmt.Printf("有缓冲 局部变量 chan ch3 : %v\n", ch3)
fmt.Printf("无缓冲 局部变量 chan ch4 : %v\n", ch4)
fmt.Printf("有缓冲 局部变量 chan ch5 : %v\n", ch5)
}
~~~
输出结果：
~~~
无缓冲 全局变量 chan ch0 : 0xc420070060
有缓冲 全局变量 chan ch1 : 0xc42001c0b0
无缓冲 局部变量 chan ch2 : 0xc4200700c0
有缓冲 局部变量 chan ch3 : 0xc420054060
无缓冲 局部变量 chan ch4 : 0xc420070120
有缓冲 局部变量 chan ch5 : 0xc420050070
~~~
无缓冲的与有缓冲channel有着重大差别，那就是一个是同步的 一个是非同步的。
比如
c1:=make(chan int) 无缓冲
c2:=make(chan int,1) 有缓冲
c1<-1
无缓冲： 不仅仅是向 c1 通道放 1，而是一直要等有别的携程 <-c1 接手了这个参数，那么c1<-1才会继续下去，要不然就一直阻塞着。
有缓冲： c2<-1 则不会阻塞，因为缓冲大小是1(其实是缓冲大小为0)，只有当放第二个值的时候，第一个还没被人拿走，这时候才会阻塞。
缓冲区是内部属性，并非类型构成要素。
~~~
var a, b chan int = make(chan int), make(chan int, 3)
~~~
channel基本操作
不同类型channel写入、读取
~~~
package main
import (
"fmt"
)
type Stu struct {
name string
}
func main() {
//int类型
var intChan chan int
intChan = make(chan int, 10)
intChan <- 10
a := <-intChan
fmt.Printf("int 类型 chan : %v\n", a)
//map类型
var mapChan chan map[string]string
mapChan = make(chan map[string]string, 10)
m := make(map[string]string, 16)
m["stu01"] = "001"
m["stu02"] = "002"
m["stu03"] = "003"
mapChan <- m
b := <-mapChan
fmt.Printf("map 类型 chan : %v\n", b)
//结构体
var stuChan chan Stu
stuChan = make(chan Stu, 10)
stu := Stu{
name: "Murphy",
}
stuChan <- stu
tempStu := <-stuChan
fmt.Printf("struct 类型 chan : %v\n", tempStu)
//结构体内存地址值
var stuChanId chan *Stu
stuChanId = make(chan *Stu, 10)
stuId := &Stu{
name: "Murphy",
}
stuChanId <- stuId
tempStuId := <-stuChanId
fmt.Printf("*struct 类型 chan : %v\n", tempStuId)
fmt.Printf("*struct 类型 chan 取值 : %v\n", *(tempStuId))
//接口
var StuInterChain chan interface{}
StuInterChain = make(chan interface{}, 10)
stuInit := Stu{
name: "Murphy",
}
//存
StuInterChain <- &stuInit
//取
mFetchStu := <-StuInterChain
fmt.Printf("interface 类型 chan : %v\n", mFetchStu)
//转
var mStuConvert *Stu
mStuConvert, ok := mFetchStu.(*Stu)
if !ok {
fmt.Println("cannot convert")
return
}
fmt.Printf("interface chan转 *struct chan : %v\n", mStuConvert)
fmt.Printf("interface chan转 *struct chan 取值 : %v\n", *(mStuConvert))
}
~~~
输出结果：
~~~
int 类型 chan : 10
map 类型 chan : map[stu02:002 stu03:003 stu01:001]
struct 类型 chan : {Murphy}
*struct 类型 chan : &{Murphy}
*struct 类型 chan 取值 : {Murphy}
interface 类型 chan : &{Murphy}
interface chan转 *struct chan : &{Murphy}
interface chan转 *struct chan 取值 : {Murphy}
~~~
channel 写入、读取、遍历、关闭:
~~~
package main
import (
"fmt"
)
func main() {
ch := make(chan int, 11)
//写入chan
ch <- 99
for i := 0; i < 10; i++ {
ch <- i
}
fmt.Printf("writed chan ch : %v\n", ch)
//读取chan
first_chan, ok := <-ch
if ok {
fmt.Printf("first chan is %v\n", first_chan)
}
ch <- 10
//遍历chan
for value := range ch {
fmt.Println(value)
if value == 10 {
// 关闭chan
close(ch)
//break // 在这里break循环也可以
}
}
fmt.Println("after range or close ch!")
}
~~~
输出结果：
~~~
first chan is 99
0
1
2
3
4
5
6
7
8
9
10
after range or close ch!
~~~
channel关闭
channel关闭后，就不能取出数据了
1. 使用内置函数close进行关闭，chan关闭之后，for range遍历chan中已经存在的元素后结束
2. 使用内置函数close进行关闭，chan关闭之后，没有使用for range的写法需要使用，v, ok := <- ch进行判断chan是否关闭
~~~
package main
import "fmt"
func main() {
var ch chan int
ch = make(chan int, 5)
for i := 0; i < 5; i++ {
ch <- i
}
close(ch)
for {
var b int
b, ok := <-ch
if ok == false {
fmt.Println("chan is close")
break
}
fmt.Println(b)
}
}
~~~
输出结果：
~~~
0
1
2
3
4
chan is close
~~~
如果将close(ch)注释掉，意思是不关闭管道，那么会出现dead lock死锁
因为存入管道5个数字，然后无限取数据，会出现死锁。
~~~
package main
import "fmt"
func main() {
var ch chan int
ch = make(chan int, 5)
for i := 0; i < 5; i++ {
ch <- i
}
// close(ch)
for {
var b int
b, ok := <-ch
if ok == false {
fmt.Println("chan is close")
break
}
fmt.Println(b)
}
}
~~~
输出结果：
~~~
0
1
2
3
4
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive]:
main.main()
/Users/***/Desktop/go/src/main.go:16 +0xfb
exit status 2
~~~
range 遍历 chan
~~~
package main
import "fmt"
func main() {
var ch chan int
ch = make(chan int, 10)
for i := 0; i < 10; i++ {
ch <- i
}
close(ch)
for v := range ch {
fmt.Println(v)
}
}
~~~
输出结果：
~~~
0
1
2
3
4
5
6
7
8
9
~~~
同样如果将close(ch)注释掉，意思是不关闭管道，那么会出现dead lock死锁
因为存入管道10个数字，然后无限取数据，在取出来第10个数据，在次range管道，会dead lock。
~~~
package main
import "fmt"
func main() {
var ch chan int
ch = make(chan int, 10)
for i := 0; i < 10; i++ {
ch <- i
}
// close(ch)
for v := range ch {
fmt.Println(v)
}
}
~~~
输出结果：
~~~
0
1
2
3
4
5
6
7
8
9
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive]:
main.main()
/Users/***/Desktop/go/src/main.go:14 +0x106
exit status 2
~~~
除用 range 外，还可用 ok-idiom 模式判断 channel 是否关闭。
~~~
package main
import "fmt"
func main() {
var ch chan int
ch = make(chan int, 10)
for i := 0; i < 10; i++ {
ch <- i
}
close(ch)
for {
if d, ok := <-ch; ok {
fmt.Println(d)
} else {
break
}
}
}
~~~
输出结果：
~~~
0
1
2
3
4
5
6
7
8
9
~~~
向 closed channel 发送数据引发 panic 错误，接收立即返回零值。而 nil channel， 无论收发都会被阻塞。
~~~
package main
func main() {
ch := make(chan int, 1)
close(ch)
ch <- 2
}
~~~
输出结果：
~~~
panic: send on closed channel
goroutine 1 [running]:
main.main()
/Users/***/Desktop/go/src/main.go:6 +0x63
exit status 2
~~~
内置函数 len 返回未被读取的缓冲元素数量，cap 返回缓冲区大小。
~~~
package main
import "fmt"
func main() {
ch1 := make(chan int)
ch2 := make(chan int, 3)
ch2 <- 1
fmt.Println(len(ch1), cap(ch1))
fmt.Println(len(ch2), cap(ch2))
}
~~~
输出结果：
~~~
0 0
1 3
~~~
对chan进行select操作
select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。
~~~
package main
import (
"fmt"
)
func main() {
ch1 := make(chan int, 1)
ch1 <- 1
ch2 := make(chan int, 1)
ch2 <- 2
select {
case k1 := <-ch1:
fmt.Println(k1)
case k2 := <-ch2:
fmt.Println(k2)
default:
fmt.Println("chan")
}
}
~~~
输出结果：
~~~
//结果1,2随机
~~~
chan的只读和只写
a. 只读chan的声明
var 变量名 <-chan 类型
~~~
package main
var ch0 <-chan int
var ch1 <-chan string
var ch2 <-chan map[string]string
type stu struct{}
var ch3 <-chan stu
var ch4 <-chan *stu
func main() {
}
~~~
b. 只写chan的声明
var 变量名 chan<- 类型
~~~
package main
var ch0 chan<- int
var ch1 chan<- string
var ch2 chan<- map[string]string
type stu struct{}
var ch3 chan<- stu
var ch4 chan<- *stu
func main() {
}
~~~
channel单向 ：可以将 channel 隐式转换为单向队列，只收或只发。
~~~
package main
import (
"fmt"
)
func main() {
c := make(chan int, 3)
var send chan<- int = c // send-only
var recv <-chan int = c // receive-only
send <- 1
// <-send // Error: receive from send-only type chan<- int
val, ok := <-recv
if ok {
fmt.Println(val)
}
// recv <- 2 // Error: send to receive-only type <-chan int
}
~~~
输出结果：
~~~
1
~~~
不能将单向 channel 转换为普通 channel。
~~~
package main
func main() {
c := make(chan int, 3)
var send chan<- int = c // send-only
var recv <-chan int = c // receive-only
ch1 := (chan int)(send)
// Error: cannot convert type chan<- int to type chan int
ch2 := (chan int)(recv)
// Error: cannot convert type <-chan int to type chan int
}
~~~
输出结果：
~~~
./main.go:8:19: cannot convert send (type chan<- int) to type chan int
./main.go:9:19: cannot convert recv (type <-chan int) to type chan int
~~~
channel 是第一类对象，可传参 (内部实现为指针) 或者作为结构成员。
~~~
package main
import "fmt"
type Request struct {
data []int
ret chan int
}
func NewRequest(data ...int) *Request {
return &Request{data, make(chan int, 1)}
}
func Process(req *Request) {
x := 0
for _, i := range req.data {
x += i
}
req.ret <- x
}
func main() {
req := NewRequest(10, 20, 30)
Process(req)
fmt.Println(<-req.ret)
}
~~~
输出结果：
~~~
60
~~~
- 序言
- 目录
- 环境搭建
- Linux搭建golang环境
- Windows搭建golang环境
- Mac搭建golang环境
- 介绍
- 1.Go语言的主要特征
- 2.golang内置类型和函数
- 3.init函数和main函数
- 4.包
- 1.工作空间
- 2.源文件
- 3.包结构
- 4.文档
- 5.编写 Hello World
- 6.Go语言 “ _ ”（下划线）
- 7.运算符
- 8.命令
- 类型
- 1.变量
- 2.常量
- 3.基本类型
- 1.基本类型介绍
- 2.字符串String
- 3.数组Array
- 4.类型转换
- 4.引用类型
- 1.引用类型介绍
- 2.切片Slice
- 3.容器Map
- 4.管道Channel
- 5.指针
- 6.自定义类型Struct
- 编码格式转换
- 流程控制
- 1.条件语句（if）
- 2.条件语句 （switch）
- 3.条件语句 （select）
- 4.循环语句 （for）
- 5.循环语句 （range）
- 6.循环控制Goto、Break、Continue
- 函数
- 1.函数定义
- 2.参数
- 3.返回值
- 4.匿名函数
- 5.闭包、递归
- 6.延迟调用 （defer）
- 7.异常处理
- 8.单元测试
- 压力测试
- 方法
- 1.方法定义
- 2.匿名字段
- 3.方法集
- 4.表达式
- 5.自定义error
- 接口
- 1.接口定义
- 2.执行机制
- 3.接口转换
- 4.接口技巧
- 面向对象特性
- 并发
- 1.并发介绍
- 2.Goroutine
- 3.Chan
- 4.WaitGroup
- 5.Context
- 应用
- 反射reflection
- 1.获取基本类型
- 2.获取结构体
- 3.Elem反射操作基本类型
- 4.反射调用结构体方法
- 5.Elem反射操作结构体
- 6.Elem反射获取tag
- 7.应用
- json协议
- 1.结构体转json
- 2.map转json
- 3.int转json
- 4.slice转json
- 5.json反序列化为结构体
- 6.json反序列化为map
- 终端读取
- 1.键盘（控制台）输入fmt
- 2.命令行参数os.Args
- 3.命令行参数flag
- 文件操作
- 1.文件创建
- 2.文件写入
- 3.文件读取
- 4.文件删除
- 5.压缩文件读写
- 6.判断文件或文件夹是否存在
- 7.从一个文件拷贝到另一个文件
- 8.写入内容到Excel
- 9.日志（log）文件
- server服务
- 1.服务端
- 2.客户端
- 3.tcp获取网页数据
- 4.http初识-浏览器访问服务器
- 5.客户端访问服务器
- 6.访问延迟处理
- 7.form表单提交
- web模板
- 1.渲染终端
- 2.渲染浏览器
- 3.渲染存储文件
- 4.自定义io.Writer渲染
- 5.模板语法
- 时间处理
- 1.格式化
- 2.运行时间
- 3.定时器
- 锁机制
- 互斥锁
- 读写锁
- 性能比较
- sync.Map
- 原子操作
- 1.原子增(减)值
- 2.比较并交换
- 3.导入、导出、交换
- 加密解密
- 1.md5
- 2.base64
- 3.sha
- 4.hmac
- 常用算法
- 1.冒泡排序
- 2.选择排序
- 3.快速排序
- 4.插入排序
- 5.睡眠排序
- 设计模式
- 创建型模式
- 单例模式
- 抽象工厂模式
- 工厂方法模式
- 原型模式
- 结构型模式
- 适配器模式
- 桥接模式
- 合成/组合模式
- 装饰模式
- 外观模式
- 享元模式
- 代理模式
- 行为性模式
- 职责链模式
- 命令模式
- 解释器模式
- 迭代器模式
- 中介者模式
- 备忘录模式
- 观察者模式
- 状态模式
- 策略模式
- 模板模式
- 访问者模式
- 数据库操作
- golang操作MySQL
- 1.mysql使用
- 2.insert操作
- 3.select 操作
- 4.update 操作
- 5.delete 操作
- 6.MySQL事务
- golang操作Redis
- 1.redis介绍
- 2.golang链接redis
- 3.String类型 Set、Get操作
- 4.String 批量操作
- 5.设置过期时间
- 6.list队列操作
- 7.Hash表
- 8.Redis连接池
- golang操作ETCD
- 1.etcd介绍
- 2.链接etcd
- 3.etcd存取
- 4.etcd监听Watch
- golang操作kafka
- 1.kafka介绍
- 2.写入kafka
- 3.kafka消费
- golang操作ElasticSearch
- 1.ElasticSearch介绍
- 2.kibana介绍
- 3.写入ElasticSearch
- NSQ
- 安装
- 生产者
- 消费者
- beego框架
- 1.beego框架环境搭建
- 2.参数配置
- 1.默认参数
- 2.自定义配置
- 3.config包使用
- 3.路由设置
- 1.自动匹配
- 2.固定路由
- 3.正则路由
- 4.注解路由
- 5.namespace
- 4.多种数据格式输出
- 1.直接输出字符串
- 2.模板数据输出
- 3.json格式数据输出
- 4.xml格式数据输出
- 5.jsonp调用
- 5.模板处理
- 1.模板语法
- 2.基本函数
- 3.模板函数
- 6.请求处理
- 1.GET请求
- 2.POST请求
- 3.文件上传
- 7.表单验证
- 1.表单验证
- 2.定制错误信息
- 3.struct tag 验证
- 4.XSRF过滤
- 8.静态文件处理
- 1.layout设计
- 9.日志处理
- 1.日志处理
- 2.logs 模块
- 10.会话控制
- 1.会话控制
- 2.session 包使用
- 11.ORM 使用
- 1.链接数据库
- 2. CRUD 操作
- 3.原生 SQL 操作
- 4.构造查询
- 5.事务处理
- 6.自动建表
- 12.beego 验证码
- 1.验证码插件
- 2.验证码使用
- beego admin
- 1.admin安装
- 2.admin开发
- beego 热升级
- gin框架
- 安装使用
- 项目
- 秒杀项目
- 日志收集
- 面试题
- 面试题一
- 面试题二
- 错题集
- Go语言陷阱和常见错误
- 常见语法错误
- 初级
- 中级
- 高级
- Go高级应用
- goim
- goim 启动流程
- goim 工作流程
- goim 结构体
- gopush
- gopush工作流程
- gopush启动流程
- gopush业务流程
- gopush应用
- gopush新添功能
- rpc
- HTTP RPC
- TCP RPC
- JSON RPC
- 常见RPC开源框架
- pprof
- pprof介绍
- pprof应用
- 封装 websocket
- zookeeper
- 基本操作测试
- 简单的分布式server
- Zookeeper命令行使用
- cgo
- Go语言 demo
- 用Go语言计算一个人的年龄，生肖，星座
- 超简易Go语言实现的留言板代码
- 信号处理模块，可用于在线加载配置，配置动态加载的信号为SIGHUP
- 阳历和阴历相互转化的工具类 golang版本
- 错误总结