# gdb 调试工具

调试redis设置:
```c
// 相当于 gcc -g
make CFLAGS="-g -O0"

gdb src/redis-server
```

> gdb 支持tab补全

# 运行程序
- `run` 可指定运行参数
 - `set args` 指定运行是参数
- 运行环境
 - `path` 设定程序的运行路径
 - `set environment varname[=value]` 设置环境变量 ：`set env USER=hchen`

# 设置断点: breakpointer

- 函数断点: `break <function>`
- 行号断点：`break <linenum>`
- 在程序运行内存地址处停止：`break *address`

# 查看断点: info
`info break[n]`

# 设置捕捉点：catchpoint

`cactch event`, event如下:
1. throw 一个 C++抛出的异常(throw 为关键字) ，
2. catch 一个 C++捕捉到的异常(catch 为关键字) ，
3. exec 调用系统调用 exec 时(exec 为关键字， 目前此功能只在HP-UX 下有用) 
4. fork 调用系统调用 fork 时。 (fork 为关键字， 目前此功能只在HP-UX 下有用)
5. vfork 调用系统调用vfork时。(vfork为关键字，目前此功能只在HP-UX下有用)
6. load 或 load <libname> 载入共享库(动态链接库)时。 (load 为关键字，目前此功能只在 HP-UX 下有用)
7. unload 或 unload<libname> 卸载共享库(动态链接库)时。 (unload为关键字，目前此功能只在 HP-UX 下有用)

只设置一次断点，程序停住后，断点自动删除

# 维护断点

- `clear` 清除所有的断点
- `clear <function>` 清除函数断点
- `clear <linenum>` 清除指定行上的断点
- `delete [<breakpointe>][range]` 清除指定断点，范围断点

# 恢复程序运行
- `continue`
- `c`
- `fg`
以上3个是同一个意思

# 单步跟踪
- `step<count>`: 如果有函数会进入函数，count：每次运行几条指令,不加每次运行一条
- `next<count>`: 如果有函数不会进入函数，count：每次运行几条指令,不加每次运行一条
- `finish`: 运行程序，知道函数完成，并打印函数返回时的堆栈地址和返回值及参数值信息
- `until`|`u`:推出循环体

打开单步跟踪模式: `set step-mode [on][off]` 在进行单步跟踪时，程序不会因为没有debug而停住

# 信号
unix定义了很多信号，比如SIGINT表示中断字符信号，可以要求GDB收到你锁指定的信号时，马上挺住正在运行的程序，以供进行调试

`handle <single> <keywords...>`

- single: 信号，all表明要处理的所有信号
- keywords:
 - nostop: 不会停住程序的运行
 - stop: 停住
 - print: 回显示出一条信息
 - noprint: 不会显示信息
 - pass/noignore: GDB不处理信号，交给调试程序处理
 - nopass/ignore: GDB不会让调试程序处理这个信号
 - info singles/info handle: 哪些信号被GDB检测中

# 线程
可以定义断点是否在所有线程上还是某个特定的线程
```gdb
break <linespec> thread <threadno>
break <linespec> thread <threadno> if...

break frik.c:13 thread 28 if bartab>lim
```
- linespec 行号
- threadno 线程id，`info threads`可以查看正在运行中的线程

不指定`threadno`表示断点设在所有的线程上面

# 查看栈信息
当程序被停住了，需要做的第一件事就是查看程序是在哪里停住了，当程序调用了一个函数：函数的地址、参数、局部变量都会被压入“栈中”
- `backtrace<n>`
- `bt<n>`
> n 只打栈顶上n层的信息
> -n 栈底n层的栈信息
打印当前函数调用栈的所有信息

切换当前栈
- `f<n>` | `frame<n>` 打印某一层的栈: 栈的层编号、当前函数名、函数参数值，函数所在的文件及行号
- `up<n>` 向上移动n层
- `down<n>` 移动n层

# 打印函数栈信息

- `info f` 打印更详细的栈层信息，大多是运行内存地址：函数地址、调用函数地址、被调用函数的地址、程序语言、函数参数地址及值、局部变量的地址
- `info args` 打印当前函数的参数名、值
- `info locals` 当前函数中所有局部变量、值
- `info catch` 当前函数中异常处理信息


# 显示源代码
`set listsize <count>` 一次显示源代码的行数

- `list<linenum>` 显示程序第`linenum`行周围的源程序
- `list<function>` 显示函数名为function的函数的源程序
- `list` 当前行后面的源程序
- `list -` 当前行前面的源程序
- `list <first>,<last>` 从first到last行之间的源代码
- `list <last>` 从当前行到last行之间的源代码
- `list +`往后显示源代码

list 后面可以跟的参数:
- `<linenum>`行号。 
- `<+offset>`当前行号的正偏移量。 
- `<-offset>`当前行号的负偏移量。 
- `<filename:linenum>`那个文件的那一行。 
- `<funtion>`函数名 
- `<filename:funtion>`那个文件中的那个函数。 
- `<*address>`程序运行时的语句在内存中的地址。

# 搜索源代码
- 向前搜索
 - `forward-search <regexp>`
 - `search <regexp>` 
- 全部搜索
 - `reverse-search<regexp>`

# 指定源文件的路径
- `directory<dirname...>`加一个源文件路径到当前路径的前面，指定多个路径“:”
- `directory`清除所有的自定义的源文件搜索路径信息
- `show directories`显示定义了的源文件搜索路径

# 打印数据
`print/<f><expr>`

- `@` 一个数组有关的操作符，在后面会有更详细的说明
- `::`指定一个文件中或是一个函数中的变量
- `{<type>}<addr>` 表示一个指向内存地址`<addr>`的类型为type的一个对象

gdb中可以随时查看一下三种变量的值：
- 全局变量（所有文件可见）
- 静态全局变量（当前文件可见）
- 局部变量（当前scope可见的）

数组：
```c
int *array = (int*)malloc(len*sizeof(int))

// 动态数组
(gdb) p *array@len
$1 = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40}

// 静态数组就可以查看
print array
```

# 输出格式
- x 按十六进制格式显示变量。
- d 按十进制格式显示变量。
- u 按十六进制格式显示无符号整型。 o 按八进制格式显示变量。
- t 按二进制格式显示变量。
- a 按十六进制格式显示变量。
- c 按字符格式显示变量。
- f 按浮点数格式显示变量。

# 查看内存
`examine`(简写 x), 查看内存地址中的值

`x<n/f/u><addr>`

n、f、u 是可选参数。
- n 是一个正整数，表示显示内存的长度，也就是说从当前地址向后显示几个地址的内容。 
- f 表示显示格式，参加上面。如果地址所指的是字符串，那么格式是 s，如果地址是指令
地址，那么格式也可以是 i。
- u 表示从当前的地址往后请求的字节数，如果不指定的话，GDB 默认是 4 个 bytes。u 参数可以用下面的字符来代替：
 - b 表示单字节
 - h 表示双字节
 - w 表示四字节
 - g 表示八字节

`x/3uh 0x54320` 表示，从内存地址`0x54320`读取内容

# 自动显示
可以设置一些自动显示的变量，当程序停住时，或是在单步跟踪时，这些变量回自动显示：
- `display<expr>`
- `display<fmt><expr>`
- `display/<fmt><expr>`

> expr: 表达式
> fmt: 显示的格式
> addr: 内存地址

删除自动显示，dnums设置好了的自动显示的编号，同时删除多个，用空格分隔，范围删除，用`-`分隔
- `undisplay<dnums...>`
- `delete display<dnums...>`

`info display` 查看display自动显示的信息

# 设置选项
- `set print address <on/off>` 打开地址输出,系统默认打开，等同于`frame/f`显示地址信息
- `set print array <on/off>` 打开数组显示，每个元素栈占一行，不打开每个以逗号分隔
- `set print elements <on/off>` print elemets的选项信息
- `set print null-stop<on/off>` 显示字符串时，遇到`\0`就停止显示
- `set print pretty <on/off>` gdb显示结构体就比较漂亮
- `set print union <on/off>` 显示结构体时，是否显示其内的联合体数据
- `set listsize <n>` 一次显示源代码的行数
- `set step-mode [on][off]` 在进行单步跟踪时，程序不会因为没有debug而停住
- `set print array-indexes on` 打印数组索引下标


# 修改变量值
`print x=4`

# 跳转执行
`jump<linespect>`执行下一条语句运行点，`file:line`

# 查生信号量
`single 命令`

# 强制函数返回
`return`

# 强制调用函数
`call`

- https://www.kancloud.cn/wizardforcel/gdb-tips-100/146752

# gdb 启动脚本
gdb启动时，会读取HOME目录和当前目录下的的配置文件，执行里面的命令。这个文件通常为“.gdbinit”。

```
# 保存历史命令
set history filename ~/.gdb_history
set history save on

# 退出时不显示提示信息
set confirm off

# 按照派生类型打印对象
set print object on

# 打印数组的索引下标
set print array-indexes on

# 每行打印一个结构体成员
set print pretty on

set step-mode on
```

gdb文档

使用的[frp](https://github.com/fatedier/frp),详情可以去github看，那里有中文文档，可以使用[supervisor管理frp连接进程](/linux/supervisor_安装_进程管理_配置_frp|spiderkeeper|jobs配置.md),以下介绍的是我的使用场景和一些个人理解

需要两台服务器
- 内网服务器(家里或者公司没有公网ip的服务器)
- 有公网ip的服务器，阿里云服务器/腾讯云服务器

# 安装

从[frp github realeas](https://github.com/fatedier/frp/releases)下载最新版，解压安装最新版本, 具体下载哪个文件没搞清，centos7.4,用的是下面的
- centos: frp_*_linux_amd64.tar.gz

# 配置

内网部署 `frpc.ini`
```conf
[common]
# 公网
server_addr = *.*.*.* # 这里是公网ip
server_port = 7000

[mysql]
local_port = 3306
local_ip = 127.0.0.1
local_port = 3306
# 公网服务器： mysql -u root -H 127.0.0.1 -P 3307 -p123456
# 公网服务器的 3307 端口，代理到内网的3306端口
remote_port = 3307

[ssh]
type = tcp
local_ip = 127.0.0.1
local_port = 22
# 如果需要在任何地方可以连接需要暴露公网的6000端口
# 公网服务器的 6000 端口，代理到内网的22端口
# ssh -p 6000 root@【公网ip地址】
remote_port = 6000

[http]
type = tcp
local_ip = 127.0.0.1
local_port = 80
# 需要暴露公网的80端口
# 公网服务器的 80 端口，代理到内网的80端口
remote_port = 80
```

公网部署 `frps.ini`
```conf
[common]
bind_port = 7000
```


# 启动连接

内网
```
./frpc -c frpc.ini
```
```log
2019/01/30 21:53:07 [I] [service.go:124] frps tcp listen on 0.0.0.0:7000
2019/01/30 21:53:07 [I] [root.go:204] Start frps success
2019/01/30 21:53:36 [I] [service.go:317] client login info: ip [139.227.1.5:39536] version [0.23.2] hostname [] os [linux] arch [amd64]
2019/01/30 21:53:36 [I] [tcp.go:66] [604c65b49901ac56] [ssh] tcp proxy listen port [6000]
2019/01/30 21:53:36 [I] [control.go:397] [604c65b49901ac56] new proxy [ssh] success
2019/01/30 21:56:50 [I] [proxy.go:80] [604c65b49901ac56] [ssh] get a new work connection: [139.227.1.5:39536]
```

公网
```
./frps -c frps.ini
```

```log
2019/01/30 21:53:36 [I] [service.go:206] login to server success, get run id [604c65b49901ac56], server udp port [0]
2019/01/30 21:53:36 [I] [proxy_manager.go:137] [604c65b49901ac56] proxy added: [ssh]
2019/01/30 21:53:36 [I] [control.go:143] [ssh] start proxy success
2019/02/01 00:45:53 [I] [service.go:206] login to server success, get run id [c387c847febafa3c], server udp port [0]
2019/02/01 00:45:53 [I] [proxy_manager.go:137] [c387c847febafa3c] proxy added: [mysql ssh]
2019/02/01 00:45:53 [I] [control.go:143] [mysql] start proxy success
2019/02/01 00:45:53 [I] [control.go:143] [ssh] start proxy success
```

[supervisor frp管理配置](/linux/supervisor_安装_进程管理_配置_frp|spiderkeeper|jobs配置.md#frp配置)

通过frp加公网服务器提供mysql，ssh，http服务

frp内网穿透


# 安装
```
yum install sysstat
```

# 实例1：显示所有设备负载情况
```
iostat

Linux 2.6.32-754.2.1.el6.x86_64 (iZ2zej76z8h545jaqmtldsZ) 	2019年01月20日 	_x86_64_	(4 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
          16.00    0.00    4.59    0.03    0.00   79.37

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
vda              13.70         0.66       241.78    5414754 1984862152
vdb               0.00         0.00         0.00       1440          0
```

cpu属性值说明：
- %user：CPU处在用户模式下的时间百分比。
- %nice：CPU处在带NICE值的用户模式下的时间百分比。
- %system：CPU处在系统模式下的时间百分比。
- %iowait：CPU等待输入输出完成时间的百分比。
- %steal：管理程序维护另一个虚拟处理器时，虚拟CPU的无意识等待时间百分比。
- %idle：CPU空闲时间百分比。
> 注：如果%iowait的值过高，表示硬盘存在I/O瓶颈，%idle值高，表示CPU较空闲，如果%idle值高但系统响应慢时，有可能是CPU等待分配内存，此时应加大内存容量。%idle值如果持续低于10，那么系统的CPU处理能力相对较低，表明系统中最需要解决的资源是CPU。

disk属性值说明：
rrqm/s: 每秒进行 merge 的读操作数目。即 rmerge/s
wrqm/s: 每秒进行 merge 的写操作数目。即 wmerge/s
r/s: 每秒完成的读 I/O 设备次数。即 rio/s
w/s: 每秒完成的写 I/O 设备次数。即 wio/s
rsec/s: 每秒读扇区数。即 rsect/s
wsec/s: 每秒写扇区数。即 wsect/s
rkB/s: 每秒读K字节数。是 rsect/s 的一半，因为每扇区大小为512字节。
wkB/s: 每秒写K字节数。是 wsect/s 的一半。
avgrq-sz: 平均每次设备I/O操作的数据大小 (扇区)。
avgqu-sz: 平均I/O队列长度。
await: 平均每次设备I/O操作的等待时间 (毫秒)。
svctm: 平均每次设备I/O操作的服务时间 (毫秒)。
%util: 一秒中有百分之多少的时间用于 I/O 操作，即被io消耗的cpu百分比
备注：如果 %util 接近 100%，说明产生的I/O请求太多，I/O系统已经满负荷，该磁盘可能存在瓶颈。如果 svctm 比较接近 await，说明 I/O 几乎没有等待时间；如果 await 远大于 svctm，说明I/O 队列太长，io响应太慢，则需要进行必要优化。如果avgqu-sz比较大，也表示有当量io在等待。

# 实例2：定时显示所有信息
```
iostat 2 3
Linux 2.6.32-279.el6.x86_64 (colin)   07/16/2014      _x86_64_        (4 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
10.81    0.00   14.11    0.18    0.00   74.90

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               1.95         1.48        70.88    9145160  437106156
dm-0              3.08         0.55        24.34    3392770  150088376
dm-1              5.83         0.93        46.49    5714522  286728384
dm-2              0.01         0.00         0.05      23930     289288

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
22.62    0.00   19.67    0.26    0.00   57.46

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               2.50         0.00        28.00          0         56
dm-0              0.00         0.00         0.00          0          0
dm-1              3.50         0.00        28.00          0         56
dm-2              0.00         0.00         0.00          0          0

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
22.69    0.00   19.62    0.00    0.00   57.69

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               0.00         0.00         0.00          0          0
dm-0              0.00         0.00         0.00          0          0
dm-1              0.00         0.00         0.00          0          0
dm-2              0.00         0.00         0.00          0          0
说明：每隔 2秒刷新显示，且显示3次
```

# 实例3：查看TPS和吞吐量
```
iostat -d -k 1 1
Linux 2.6.32-279.el6.x86_64 (colin)   07/16/2014      _x86_64_        (4 CPU)

Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sda               1.95         0.74        35.44    4572712  218559410
dm-0              3.08         0.28        12.17    1696513   75045968
dm-1              5.83         0.46        23.25    2857265  143368744
dm-2              0.01         0.00         0.02      11965     144644
```
- tps：该设备每秒的传输次数（Indicate the number of transfers per second that were issued to the device.）。“一次传输”意思是“一次I/O请求”。多个逻辑请求可能会被合并为“一次I/O请求”。“一次传输”请求的大小是未知的。
- kB_read/s：每秒从设备（drive expressed）读取的数据量；
- kB_wrtn/s：每秒向设备（drive expressed）写入的数据量；
- kB_read：读取的总数据量；kB_wrtn：写入的总数量数据量；
这些单位都为Kilobytes。

上面的例子中，我们可以看到磁盘sda以及它的各个分区的统计数据，当时统计的磁盘总TPS是1.95，下面是各个分区的TPS。（因为是瞬间值，所以总TPS并不严格等于各个分区TPS的总和）

## 实例4：查看设备使用率（%util）和响应时间（await）
```
iostat -dx 5 
Linux 2.6.32-279.el6.x86_64 (colin)   07/16/2014      _x86_64_        (4 CPU)

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await  svctm  %util
sda               0.02     7.25    0.04    1.90     0.74    35.47    37.15     0.04   19.13   5.58   1.09
dm-0              0.00     0.00    0.04    3.05     0.28    12.18     8.07     0.65  209.01   1.11   0.34
dm-1              0.00     0.00    0.02    5.82     0.46    23.26     8.13     0.43   74.33   1.30   0.76
dm-2              0.00     0.00    0.00    0.01     0.00     0.02     8.00     0.00    5.41   3.28   0.00
```
- rrqm/s： 每秒进行 merge 的读操作数目.即 delta(rmerge)/s
- wrqm/s： 每秒进行 merge 的写操作数目.即 delta(wmerge)/s
- r/s： 每秒完成的读 I/O 设备次数.即 delta(rio)/s
- w/s： 每秒完成的写 I/O 设备次数.即 delta(wio)/s
- rsec/s： 每秒读扇区数.即 delta(rsect)/s
- wsec/s： 每秒写扇区数.即 delta(wsect)/s
- rkB/s： 每秒读K字节数.是 rsect/s 的一半,因为每扇区大小为512字节.(需要计算)
- wkB/s： 每秒写K字节数.是 wsect/s 的一半.(需要计算)
- avgrq-sz：平均每次设备I/O操作的数据大小 (扇区).delta(rsect+wsect)/delta(rio+wio)
- avgqu-sz：平均I/O队列长度.即 delta(aveq)/s/1000 (因为aveq的单位为毫秒).
- await： 平均每次设备I/O操作的等待时间 (毫秒).即 delta(ruse+wuse)/delta(rio+wio)
- svctm： 平均每次设备I/O操作的服务时间 (毫秒).即 delta(use)/delta(rio+wio)
- %util： 一秒中有百分之多少的时间用于 I/O 操作,或者说一秒中有多少时间 I/O 队列是非空的，即 delta(use)/s/1000 (因为use的单位为毫秒)
> 如果 %util 接近 100%，说明产生的I/O请求太多，I/O系统已经满负荷，该磁盘可能存在瓶颈。 idle小于70% IO压力就较大了，一般读取速度有较多的wait。 同时可以结合vmstat 查看查看b参数(等待资源的进程数)和wa参数(IO等待所占用的CPU时间的百分比，高过30%时IO压力高)。

另外 await 的参数也要多和 svctm 来参考。差的过高就一定有 IO 的问题。

avgqu-sz 也是个做 IO 调优时需要注意的地方，这个就是直接每次操作的数据的大小，如果次数多，但数据拿的小的话，其实 IO 也会很小。如果数据拿的大，才IO 的数据会高。也可以通过 avgqu-sz × ( r/s or w/s ) = rsec/s or wsec/s。也就是讲，读定速度是这个来决定的。

svctm 一般要小于 await (因为同时等待的请求的等待时间被重复计算了)，svctm 的大小一般和磁盘性能有关，CPU/内存的负荷也会对其有影响，请求过多也会间接导致 svctm 的增加。await 的大小一般取决于服务时间(svctm) 以及 I/O 队列的长度和 I/O 请求的发出模式。如果 svctm 比较接近 await，说明 I/O 几乎没有等待时间；如果 await 远大于 svctm，说明 I/O 队列太长，应用得到的响应时间变慢，如果响应时间超过了用户可以容许的范围，这时可以考虑更换更快的磁盘，调整内核 elevator 算法，优化应用，或者升级 CPU。

队列长度(avgqu-sz)也可作为衡量系统 I/O 负荷的指标，但由于 avgqu-sz 是按照单位时间的平均值，所以不能反映瞬间的 I/O 洪水。

形象的比喻：
- r/s+w/s 类似于交款人的总数
- 平均队列长度(avgqu-sz)类似于单位时间里平均排队人的个数
- 平均服务时间(svctm)类似于收银员的收款速度
- 平均等待时间(await)类似于平均每人的等待时间
- 平均I/O数据(avgrq-sz)类似于平均每人所买的东西多少
- I/O 操作率 (%util)类似于收款台前有人排队的时间比例
- 设备IO操作:总IO(io)/s = r/s(读) +w/s(写)

平均等待时间=单个I/O服务器时间*(1+2+...+请求总数-1)/请求总数

每秒发出的I/0请求很多,但是平均队列就4,表示这些请求比较均匀,大部分处理还是比较及时。

iostat文档


# mysql用户账户管理
- 授权相当于root权限的账户 liuning 任何地点都可以登录 密码123456 

````
第一种方式:

grant all privileges 
    -> on *.* to 'liuning'@'%'      // on 将数据库中的表授权给刘宁   % 表示任意地点可以登录
    -> identified by '123456'       // 指定密码验证
    -> with grant option            // 授权资源限制
    
第二种方式:

insert into user
->  values('localhost','liuning',password('123456'),'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y');

FLUSH PRIVILEGES;   // 重载授权表
````

-  授权账户访问某个数据库
```
第一种方式:

grant select,update,insert,delete,drop
->  on  demo.*                  # 授权liuning demo数据库中的所有表
->  to  'liuning'@'locahost'    # 只能本机登录
->  identified by '123456'

第二种方式:

insert into user (Host,User,Password)
->  values('douyacun.cn','liuning',password('123456'));
flush privileges;
```
```
grant select,update,insert,delete,drop,create
on `byidb`.`other*`
to "aiqiyi"@"%" identified by '123456';
```



- width 设置资源限制
```
GRANT ALL ON customer.* TO 'francis'@'localhost'
    ->     IDENTIFIED BY 'frank'
    ->     WITH MAX_QUERIES_PER_HOUR 20        // 账户每小时可以发出的查询数
    ->          MAX_UPDATES_PER_HOUR 10        // 账户每小时可以发出的更新数
    ->          MAX_CONNECTIONS_PER_HOUR 5     // 账户每小时可以连接服务器的次数
    ->          MAX_USER_CONNECTIONS 2;        // 表示账户一次可以同时连接的最大连接数
    
要想设置或更改已有账户的限制，在全局级别使用GRANT USAGE语句(在*.*)。下面的语句可以将francis的查询限制更改为100：
    
    mysql> GRANT USAGE ON *.* TO 'francis'@'localhost'
        ->     WITH MAX_QUERIES_PER_HOUR 100;
```
- 设置账户密码
```
mysqladmin -u root -h "%" password "123456"
或者
SET PASSWORD FOR 'jeffrey'@'%' = PASSWORD('biscuit');
```
## mysql服务器授权表
- 权限表
    -  user表范围列决定是否允许或拒绝到来的连接。对于允许的连接，user表授予的权限指出用户的全局(超级用户)权限。这些权限适用于服务器上的all数据库。
    - db表范围列决定用户能从哪个主机存取哪个数据库。权限列决定允许哪个操作。授予的数据库级别的权限适用于数据库和它的表。
    - host表不受GRANT和REVOKE语句的影响。大多数MySQL安装根本不需要使用该表。
    - tables_priv和columns_priv表类似于db表，但是更精致：它们在表和列级应用而非在数据库级。授予表级别的权限适用于表和所有它的列。授予列级别的权限只适用于专用列。
    - procs_priv表适用于保存的程序。授予程序级别的权限只适用于单个程序。

----------------------------

- 当你修改授权表的内容时，确保你按你想要的方式更改权限设置是一个好主意。要检查给定账户的权限，使用SHOW GRANTS语句。例如，要检查Host和User值分别为pc84.example.com和bob的账户所授予的权限，应通过语句：
```
show grants for 'liuning'@'%';
```

## mysql提供的权限

权限|列|上下文 
:-----|:-----|:---- 
create|Create_priv|数据库、表或索引 创建新数据库和表，
drop|DROP|数据库、表  或删除(移掉)已有数据库和表
grant option|Grant_priv|数据库、表或保存的程序 允许你把你自己拥有的那些权限授给其他的用户。可以用于数据库、表和保存的程序。
REFERENCES|References_priv|数据库或表
alter|Alter_priv|表 更改表的结构和重新命名表。
delte|Delete_priv|表
index|INDEX_priv|表  允许创建或删除索引
insert|Insert_priv|表
select|Select_priv|表
update|Update_priv|表
create view|Create_view_priv|视图
show view|Show_view_priv|视图
alter routine|Alter_routine_priv|保存的程序 更改和删除保存的程序
create routine|Create_routine_priv|保存的程序 创建保存的程序（函数和程序）
execute|Execute_priv|保存的程序 执行保存的程序
file|FILE_priv|服务器主机上的文件访问  你用LOAD DATA INFILE和SELECT ... INTO OUTFILE语句读和写服务器上的文件
create temporary tables|Create_tmp_table_priv|服务器管理
lock tables|Lock_tables_priv|服务器管理
create user|Create_user_priv|服务器管理
provess|PROCESS_priv|服务器管理 processlist
relaod|reload_priv|服务器管理  允许执行 flush-hosts, flush-logs, flush-privileges, flush-status, flush-tables, flush-threads, refresh, reload
replication client|Repl_client_priv|服务器管理
replication slave|Repl_slave_priv|服务器管理
show databases|	Show_db_priv|从服务器管理
shutdown|Shutdown_priv|服务器管理  shutdown
super|Super_priv|服务器管理   kill
usage|0| 创建用户不给于任何权限

# 数据库连接,访问控制
服务器基于你的身份以及你是否能通过供应正确的密码验证身份来接受或拒绝连接。如果不是，服务器完全拒绝你的访问，否则，服务器接受连接，然后进入阶段2并且等待请求。
- 你从那个主机连接
- 你的MySQL用户名
- 验证(Host, User和Password)范围列执行
- CURRENT_USER()函数 判断验证连接



# 实际授权 实例
```
mysql> grant select, insert, update, delete, create view, show view
->  on yar.*
->  to 'liuning'@'%'
->  identified by '123456';

mysql> show grants for 'liuning'@'%';

```

# 取消给用户的权限
```
mysql> revoke all
-> on yar.*
-> from 'liuning'@'%';
```



mysql 数据库授权sql


# 聚合函数
- avg(),        求取平均值
- count(),      计算表中的行数
- instr('mysql','sql')       计算子字符在字符串中第一次出现的位置
- sum()         计算总和
- min()         求取最小值
- max()         计算最大值
- group_concat()    函数将组中的字符串连接成为具有各种选项的单个字符串。
    ```
        GROUP_CONCAT(DISTINCT expression
            ORDER BY expression
            SEPARATOR sep);

    mysql> INSERT INTO t(v) VALUES('A'),('B'),('C'),('B');

    mysql> select group_concat(
                distinct v
                order by v desc
                separator ';')
            from t;

    mysql> d;c;b;a
    ```
    + 相当于:select v from t order by v desc;
    + 结果整合成字符串,PHP implode(',',$res);

# 字符串函数
- concat()  不多说
- length() char_length() 以字节或字符 字符串长度
- replace(str,old_string,new_string)     搜索并替换字符串中的子字符串
- substring(string,position)            截取字符串
- trim([{BOTH|LEADING|TRAILING} [removed_str]] FROM str) 和php作用相同
- find_in_set('a','a,b,c')     允许您在逗号分隔的字符串列表中查找指定字符串的位置。
- format(1111.22222,2);         相当于PHP number_format();

# 控制流
- CASE表达式 
```
CASE value
WHEN compare_value_1 THEN result_1
WHEN compare_value_2 THEN result_2
…
ELSE result 
END

CASE
    WHEN state IS NULL THEN country
    ELSE state
END

mysql> select
case phone
when 15258157582 then 1234567
else phone end
from ln_users;
```
- if语句
```
IF expression THEN
   statements;
END IF;
```
- ifnull语句
```
SELECT IFNULL(1,0); -- returns 1

SELECT IFNULL('',1); -- returns ''

select ifnull(email,concat(phone,'@abc.com') as email from ln_users;
```
- nullif语句
    + NULLIF(expression_1,expression_2);
    + 如果expression_1 = expression_2为true，则NULLIF函数返回NULL，否则返回expression_1 。
```
mysql> select nullif(phone,15258157582) as phone from ln_users;
```

# 日期函数
- current_date()    返回当前日期
- datediff()        计算两个日期之间的时间差
- day()             获取指定日期的天数   2017-09-05  5天
- [date_add()](http://www.yiibai.com/mysql/date_add.html)   将时间值添加到日起值
- [date_sub()](http://www.yiibai.com/mysql/date_sub.html)   减日期
- date_format()     格式化日期
```
select date_format(create_at,'%Y-%m-%d') from ln_users;
```
- from_unixtime(unixtime(),'%Y-%m-%d %H:%i:%s')   格式化时间戳
- uninx_timestamp(now());    获取当前时间戳
- now()             获取当前时时间
- month()           获取给定日期的整数月份
- str_to_date()     函数将字符串转换为日期时间值
```
SELECT STR_TO_DATE('21,5,2018','%d,%m,%Y');
```
- timediff()        返回两个TIME或DATETIME值之间的差值。
```
SELECT TIMEDIFF('12:00:00','10:00:00') diff;
```
- timestampdiff()   计算两个DATE或DATETIME值之间的差值。
- week()            返回一个日期的星期数值。
- weekday()         返回一个日期表示为工作日/星期几的索引。
- year()            放回年份


聚合函数、符串函数、控制流、日期函数

mysql函数整理

**mysql支持输入表情符号的问题**

1. 备份,备份所有需要升级的字符串编码的数据库

    - dump出来

2. 升级

    utf8mb4是MySQL5.5.3版本之后支持的字符集

3. 修改

    可以为一个database设置字符编码，可以为一张表设置字符编码，甚至可以为某一个字段设置字符编码

    - 查看当前系统默认的字符集设置

    ```
    mysql> SHOW VARIABLES WHERE Variable_name LIKE 'character\_set\_%' OR Variable_name LIKE 'collation%';
    +--------------------------+-----------------+
    | Variable_name            | Value           |
    +--------------------------+-----------------+
    | character_set_client     | utf8            |
    | character_set_connection | utf8            |
    | character_set_database   | utf8            |
    | character_set_filesystem | binary          |
    | character_set_results    | utf8            |
    | character_set_server     | utf8            |
    | character_set_system     | utf8            |
    | collation_connection     | utf8_general_ci |
    | collation_database       | utf8_general_ci |
    | collation_server         | utf8_general_ci |
    +--------------------------+-----------------+
    10 rows in set (0.01 sec)

    mysql>

    ```

    - 查看database的字符编码

    ```
    mysql> show create database polarsnow;
    +-----------+--------------------------------------------------------------------+
    | Database  | Create Database                                                    |
    +-----------+--------------------------------------------------------------------+
    | polarsnow | CREATE DATABASE `polarsnow` /*!40100 DEFAULT CHARACTER SET utf8 */ |
    +-----------+--------------------------------------------------------------------+
    1 row in set (0.00 sec)

    mysql>
    ```

    - 查看table的字符编码

    ```
    mysql> show create table ps;
    +-------+---------------------------------------------------------------------------------------------+
    | Table | Create Table                                                                                |
    +-------+---------------------------------------------------------------------------------------------+
    | ps    | CREATE TABLE `ps` (
      `name` varchar(100) DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 |
    +-------+---------------------------------------------------------------------------------------------+
    1 row in set (0.00 sec)
    ```

    - 查看column的字符编码

    ```
    mysql> show full columns from ps;
    +-------+--------------+-----------------+------+-----+---------+-------+---------------------------------+---------+
    | Field | Type         | Collation       | Null | Key | Default | Extra | Privileges                      | Comment |
    +-------+--------------+-----------------+------+-----+---------+-------+---------------------------------+---------+
    | name  | varchar(100) | utf8_general_ci | YES  |     | NULL    |       | select,insert,update,references |         |
    +-------+--------------+-----------------+------+-----+---------+-------+---------------------------------+---------+
    1 row in set (0.00 sec)
    ```

    - 修改database默认的字符集
    ```
    ALTER DATABASE database_name CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci;

    mysql> ALTER DATABASE polarsnow CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci;
    Query OK, 1 row affected (0.03 sec)

    mysql> show create database polarsnow;
    +-----------+--------------------------------------------------------------------------------------------------+
    | Database  | Create Database                                                                                  |
    +-----------+--------------------------------------------------------------------------------------------------+
    | polarsnow | CREATE DATABASE `polarsnow` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci */ |
    +-----------+--------------------------------------------------------------------------------------------------+
    1 row in set (0.00 sec)

    mysql> show tables;
    +---------------------+
    | Tables_in_polarsnow |
    +---------------------+
    | ps                  |
    +---------------------+
    1 row in set (0.00 sec)

    mysql> show create table ps;
    +-------+---------------------------------------------------------------------------------------------+
    | Table | Create Table                                                                                |
    +-------+---------------------------------------------------------------------------------------------+
    | ps    | CREATE TABLE `ps` (
      `name` varchar(100) DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 |
    +-------+---------------------------------------------------------------------------------------------+
    1 row in set (0.00 sec)

    mysql> show full columns from ps;
    +-------+--------------+-----------------+------+-----+---------+-------+---------------------------------+---------+
    | Field | Type         | Collation       | Null | Key | Default | Extra | Privileges                      | Comment |
    +-------+--------------+-----------------+------+-----+---------+-------+---------------------------------+---------+
    | name  | varchar(100) | utf8_general_ci | YES  |     | NULL    |       | select,insert,update,references |         |
    +-------+--------------+-----------------+------+-----+---------+-------+---------------------------------+---------+
    1 row in set (0.00 sec)

    mysql> create table test_tb2 (tb2 varchar(100) );
    Query OK, 0 rows affected (0.21 sec)

    mysql> show tables;
    +---------------------+
    | Tables_in_polarsnow |
    +---------------------+
    | ps                  |
    | test_tb2            |
    +---------------------+
    2 rows in set (0.00 sec)

    mysql> show create table test_tb2;
    +----------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
    | Table    | Create Table                                                                                                                                              |
    +----------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
    | test_tb2 | CREATE TABLE `test_tb2` (
      `tb2` varchar(100) COLLATE utf8mb4_unicode_ci DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci |
    +----------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
    1 row in set (0.00 sec)

    mysql>
    ```

    - 修改column默认的字符集

    ` ALTER TABLE table_name CHANGE column_name column_name VARCHAR(191) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci; `

4. 修改配置文件
```
SET NAMES utf8 COLLATE utf8_unicode_ci becomes SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci

> vim /etc/my.cnf
# 对本地的mysql客户端的配置
[client]
default-character-set = utf8mb4

# 对其他远程连接的mysql客户端的配置
[mysql]
default-character-set = utf8mb4

# 本地mysql服务的配置
[mysqld]
character-set-client-handshake = FALSE
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
> service mysqld restart
```

5. 检查修改
    ```
    mysql> SHOW VARIABLES WHERE Variable_name LIKE 'character\_set\_%' OR Variable_name LIKE 'collation%';
    +--------------------------+--------------------+
    | Variable_name            | Value              |
    +--------------------------+--------------------+
    | character_set_client     | utf8mb4            |
    | character_set_connection | utf8mb4            |
    | character_set_database   | utf8mb4            |
    | character_set_filesystem | binary             |
    | character_set_results    | utf8mb4            |
    | character_set_server     | utf8mb4            |
    | character_set_system     | utf8               |
    | collation_connection     | utf8mb4_unicode_ci |
    | collation_database       | utf8mb4_unicode_ci |
    | collation_server         | utf8mb4_unicode_ci |
    +--------------------------+--------------------+
    10 rows in set (0.00 sec)
    ```

6. 修改 & 优化所有数据表

    ```
    mysql> SHOW VARIABLES WHERE Variable_name LIKE 'character\_set\_%' OR Variable_name LIKE 'collation%';
    +--------------------------+--------------------+
    | Variable_name            | Value              |
    +--------------------------+--------------------+
    | character_set_client     | utf8mb4            |
    | character_set_connection | utf8mb4            |
    | character_set_database   | utf8mb4            |
    | character_set_filesystem | binary             |
    | character_set_results    | utf8mb4            |
    | character_set_server     | utf8mb4            |
    | character_set_system     | utf8               |
    | collation_connection     | utf8mb4_unicode_ci |
    | collation_database       | utf8mb4_unicode_ci |
    | collation_server         | utf8mb4_unicode_ci |
    +--------------------------+--------------------+
    10 rows in set (0.00 sec)
    ```

7. 最重要的修改 php 的数据库连接,不用担心, `utf8mb4` 支持 `utf8` 的链接!

    ```
    'mysql' => [
        'driver' => 'mysql',
        'host' => env('DB_HOST'),
        'port' => env('DB_PORT'),
        'database' =>env('BYIDB_DATABASE'),
        'username' => env('DB_USERNAME'),
        'password' => env('DB_PASSWORD'),
        'charset' => 'utf8mb4',
        'collation' => 'utf8mb4_unicode_ci',
        'prefix' => '',
        'strict' => true,
        'engine' => null,
    ],
    ```

utf8mb4格式存储数据

疑问：

1. 系统线程和goroutine有哪些区别？
2. 什么原子操作，系统线程和goroutine是如何进行原子操作？

# 目录

[TOC]

# thread

先说一下线程出现的背景，也就是有了进程为什么还需要多线程的原因，首先在许多应用同时发生着多种活动（并行），某种活动会随着时间推移会被阻塞，将这些应用程序分解成可以准并行运行的多个顺序线程，程序设计模型会变得更简单。其次由于线程比进程更轻量级，它们比进程更容易创建和销毁。第三个就是性能的比较，如果是CPU密集型，多线程并不能获得性能上的提升，但如果是I/O密集型或者计算密集型的，多个线程会允许彼此重叠运行，加快应用程序执行的速度

POSIX（pthread）线程库，C/C++标准线程API,线程比fork新的进程开销更少，是因为系统不会为进程初始化新的虚拟内存空间和环境，进程中所有线程共享相同的地址空间，通过定义一个函数及其将在线程中处理的参数来生成一个线程。在软件中使用POSIX线程库的目的是更快地执行软件。

基础知识:

- 线程操作包括线程创建，终止，同步（连接、阻塞），调度，数据管理和进程交互
- 线程不维护以创建线程的列表，也不知道它创建的线程
- 进程中所有的线程共享相同的地址空间
- 同一进程中的线程共享:
 - 流程
 - 大多数数据
 - 打开的文件描述符
 - 信号和信号处理程序
 - 当前的工作目录
 - 用户和组id
- 每个线程独享：
 - 线程id
 - 寄存器集，堆栈指针
 - 堆栈用于局部变量，返回地址
 - 信号掩码
 - 优先级
 - 返回值：errno（错误码）
- Pthread 函数返回0表示成功

## C - Basic Thread Routines

```c
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
void *print_message_func(void *ptr);
int main()
{
 pthread_t thread1, thread2;//线程id
 int iret1, iret2;
 char *message1 = "Thread 1";
 char *message2 = "Thread 2";

 iret1 = pthread_create(&thread1, NULL, print_message_func, (void *) message1);
 iret2 = pthread_create(&thread2, NULL, print_message_func, (void *) message2);

 pthread_join(thread1, NULL);
 pthread_join(thread2, NULL);
 printf("Thread 1 return %d\n", iret1);
 printf("Thread 2 return %d\n", iret2);
		exit(0);
}
void *print_message_func(void *ptr)
{
 char *message;
 message = (char *)ptr;
 printf("%s\n", message);
}
// 输出
// Thread 2
// Thread 1
// Thread 1 return 0
// Thread 2 return 0

// gdb 调试打印一下thread1、thread2
// (gdb) p thread2
// $5 = 140737337296640
// (gdb) p thread1
// $6 = 140737345689344
// (gdb)
```

### creation

```c
int pthread_create(pthread_t * thread, 
 const pthread_attr_t * attr,
 void * (*start_routine)(void *), 
 void *arg);
```

- pthread_t：在 `/usr/include/bits/pthreadtypes.h` 中定义`typedef unsigned long int pthread_t;`
- pthread_attr_t：

| **属性** | **值** | **结果** |
| -------------- | :----------------------------------------------------------- | :----------------------------------------------------------- |
| __scope | `PTHREAD_SCOPE_SYSTEM`: 与系统中所有线程一起竞争CPU时间 `PTHREAD_SCOPE_PROCESS:` 仅与同进程中的线程竞争CPU | 竞争CPU的范围,缺省值`PTHREAD_SCOPE_SYSTEM` |
| __detachstate | `PTHREAD_CREATE_DETACHED`: 新线程与其他线程脱离同步，不能使用pthread_join来同步 `PTHREAD_CREATE_JOINABLE`: 新线程与其他线程同步，新线程创建后可以使用pthread_detached来脱离同步 | 新线程是否与进程中其他线程脱离同步，缺省值为`PTHREAD_CREATE_JOINABLE` |
| __stackaddr | `NULL` | 新线程具有系统分配的栈地址。 |
| __stacksize | | 新线程具有系统定义的栈大小。默认2M |
| __schedpolicy | `SCHED_OTHER`：正常、非实时 `SCHED_RR`: 实时、轮转法 `SCHED_FIFO`： 实时、先入先出 | 线程的调度策略，缺省值为`SCHED_OTHER` |
| __inheritsched | `PTHREAD_EXPLICIT_SCHED`: 显示式指定调度策略和调度参数 `PTHREAD_INHERIT_SCHED`: 继承调用者线程的值 | 新线程是否继承父线程调度优先级。 |

- `void * (*start_routine)` 指向线程运行的函数，函数有一个参数执行`void *`
- `void *arg`执行函数参数的指针，如果传递多个参数，发送指向结构体的指针

### Termination

```c
void pthread_exit（void *retval）;
```

- retval 函数的返回值

一般情况下，进程中各个线程的运行都是相互独立的，线程的终止并不会通知，也不会影响其他线程，终止线程所占用的资源也并不会随着线程的终止而释放，正如进程之间可以用wait()系统调用来同步终止并释放资源一样，线程就是pthread_join等待并释放

注意pthread_exit只会让主线程自己退出不会让产生的子线程退出；用return则所有的线程退出

使线程退出的方法有：

- 调用`pthread_exit`
- 使调用函数return
- 调用exit会使进程退出，包括已经创建的线程
- 主线程退出

如何让子线程完整执行？

1. 使用pthread_join等待其执行完成
2. 执行时，主线程执行pthread_exit，这样子线程能继续执行
3. 使用pthread_detach使新线程与其他线程脱离同步，要保证主线成不能退出

### detach and join

```c
int pthread_detach(pthread_t thread);
```

- `pthread_t thread` 线程id

线程创建默认是joinable，但如果一个线程结束但没有被join，则他的状态类似于僵尸进程(Zombie Process),还有一部分资源没有被回收，所以创建线程者应该调用pthread_join来等待线程退出，并可得到线程的退出代码，回收其资源，但是调用pthread_join后，线程没有结束，调用者会被阻塞，有些情况我们并不希望如此，比如在web服务器创建一个字线程来处理每一个请求，主线程并不希望因为调用pthread_join而阻塞，这时可以在子线程代码中加入pthread_detach(pthread_self())或是在父线程调用pthread_detach(pthread_t thread_id)非阻塞立即返回，这将使子线程的状态设置为detached,该线程结束后会自动释放所有资源

```c
int pthread_join(pthread_t thread, void **retval);
```

- `pthread_t thread`线程id
- `retval`返回值

调用pthread_join的线程会阻塞，直到指定的线程返回或调用了pthread_exit,如果线程简单的返回，retval会被设置成函数的返回值；如果调用了pthread_exit，那个可以传参给pthread_exit("hello world")当作线程的返回值；如果线程被取消，retval被设置成`PTHREAD_CANCELED`，注意一个线程只允许唯一的一个线程使用pthread_join()等待它的终止，并且被等待线程必须是joinable状态，非Detached状态

## Syncronizing Threads - 线程同步

问题：

```
int bar = 0;
void foo()
{
 if (bar == 0)
			bar = 1;	/* This must only be done once. */
}
这里有一个问题：
 	 Thread 1				 Thread 2
 		if (bar == 0)
 									if (bar == 0)
 						 		bar = 1;
 		bar = 1;
线程1、2会同时设置bar
```

线程库提供了三种线程同步机制：

- mutexes - 互斥锁, 阻止其他线程访问变量，
- join - 等待线程完成
- condition variables - pthread_cond_t

### mutexes - 互斥锁

- 互斥锁用于防止因竞争条件引起的数据不一致。
- 两个或多个线程需要同时在同一块存储区域上执行操作时，通常会发生竞争条件，计算结果取决于执行这些操作的顺序。互斥锁用于序列化共享资源。
- 每当多个线程访问全局资源时，应该有一个与之关联的互斥锁。互斥锁只能用在同一进程的线程，不像信号可以用于多个进程之间的通信。

```c
#include <pthread.h>
#include <stdio.h>

void *foo(void *ptr);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int bar = 0;

int main()
{
 pthread_t t1, t2;
 int rc1, rc2;
 if ((rc1 = pthread_create(&t1, NULL, foo, NULL))) {
 printf("Thread creation failed: %d\n", rc1);
 }
 if ((rc2 = pthread_create(&t2, NULL, foo, NULL))) {
 printf("Thread creation failed: %d\n", rc2);
 }
 pthread_join(t1, NULL);
 pthread_join(t2, NULL);
 printf("Final counter bar is %d\n", bar);
}
void *foo(void *ptr)
{
 printf("Thread number %llu\n", pthread_self());
 pthread_mutex_lock(&mutex1);
 bar++;
 pthread_mutex_unlock(&mutex1);
}
// cc -g -lpthread main.c -o thread
// -g 允许gdb调试
```

### join

通过pthread_join可以等待多个线程执行完成并获取执行结果

```c
#include <pthread.h>
#include <stdio.h>

#define NUM_OF_THREAD 10
void *foo(void *ptr);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int bar = 0;

int main()
{
 pthread_t ts[NUM_OF_THREAD];
 int i,j;
 for (i = 0; i < NUM_OF_THREAD; i++) {
 pthread_create(&ts[i], NULL, foo, NULL);
 }
 for (j = 0; j < NUM_OF_THREAD; j++) {
 pthread_join(ts[j], NULL);
 }
 printf("Final counter bar is %d\n", bar);
}
void *foo(void *ptr)
{
 printf("Thread number %llu\n", pthread_self());
 pthread_mutex_lock(&mutex1);
 bar++;
 pthread_mutex_unlock(&mutex1);
}
```

### condition variables - 条件变量

互斥锁，平时接触的比较多，那条件变量是干啥的？为什么条件变量总是和互斥锁搭配来使用

条件变量，线程可以原子方式阻塞，直到满足某个条件为止，比如：线程A和B存在依赖关系，B要在某个条件发生之后才能继续运行，而这个条件只有A才能完成，这个时候就可以用条件变量来完成

create/destory:

```c
int	pthread_condattr_init(pthread_condattr_t *cattr);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER
int	pthread_condattr_destroy(pthread_condattr_t *cattr);
```

- 动态：需要用pthread_condattr_destroy来释放条件变量的内存空间
- 静态：可以把常量`PTHREAD_COND_INITIALIZER`给静态分配的条件变量

waiting on condition：

```CQL
int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);
int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);
```

这两个函数分别是阻塞等待和超时等待

waking thread based on condition:

```c
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
```

这两个函数通知线程条件已经满足

以下代码就是典型的生产者消费者模型

```c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

#define NUM_OF_THREAD 5
#define QUEUE_CAPACITY 5

struct Queue{
	int ppos;
	int cpos;
	char *data;
	int capacity;
	int len;
}q;
pthread_cond_t cd = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
void *start(void *args);
void producer();
void consumer();

int count = 0;

int main()
{
	pthread_t threads[NUM_OF_THREAD];
	int i, j;
	memset(&q, 0, sizeof(struct Queue));
	q.capacity = QUEUE_CAPACITY;
	q.data = (char *)malloc(sizeof(char) * QUEUE_CAPACITY);
	for(i=0; i<NUM_OF_THREAD;i++) {
		int *n = (int *)malloc(sizeof(int) * 1);
		*n = i;
		pthread_create(&threads[i], NULL, start, n);
	}
	for(j=0;j<NUM_OF_THREAD;j++){
		pthread_join(threads[j], NULL);
	}
	exit(0);
}
void *start(void *args)
{
	int n = *(int *)args;
	if (n==0) {
		producer();// 1个生产者
	} else {
		consumer();// 4个消费者
	}
}
void producer()
{
	char c;
	while(1)
	{
		if ((c = getchar()) == '\n'){
			continue;
		}
		pthread_mutex_lock(&mtx);
		if (q.len >= QUEUE_CAPACITY) {
			printf("Queue is full\n");
		} else {
			q.len++;
			q.ppos = (q.ppos + 1) % q.capacity;
			q.data[q.ppos] = c;
			printf("get a task\n");
		}
		pthread_cond_broadcast(&cd); // 通知消费线程 来活了
		pthread_mutex_unlock(&mtx);
	}
	return;
}

void consumer()
{
	int len, cpos;
	char c;
	while(1)
	{
		pthread_mutex_lock(&mtx);
		while(q.len <= 0) {
			printf("waitting ...\n");
			pthread_cond_wait(&cd, &mtx);
		}
		q.len--;
		len = q.len;
		q.cpos =(q.cpos + 1) % q.capacity;
		cpos = q.cpos;
		c = q.data[q.cpos];
		pthread_mutex_unlock(&mtx); // 这里生产任务已经接到没必要在占用锁了，否则就没有并发了
		sleep(3);
		printf("completed this task from queue: 【%c】, len 【%d】, cpos 【%d】\n", c, len, cpos);
	}
	return;
}
```

## Thread Pitfalls - 线程陷阱

- 竞争条件： 线程由操作系统调度并执行。不能假定线程按创建顺序执行，他们可以以不同的速度执行。当线程正在执行时（竞赛完成），它们可能会产生意外结果（竞争条件）。必须利用mutexes和join来实现可预测的执行顺序和执行结果
- 线程安全（并发安全）：线程必须调用“线程安全”的函数，这意味着没有静态或全局变量，其他线程可能会假设单线程操作而破坏或读取。如果使用静态或全局变量，则必须使用全局变量或重写程序避免使用这些变量。在c语言中，局部变量在堆栈上分配的，因此任何不使用静态数据或其他共享资源的线程都是线程安全的。线程不安全函数程序中一次只能由一个线程使用，必须确保线程的唯一性；
- 互斥锁死锁：当应用锁互斥锁未解锁时会发生此情况，这导致程序执行无限停止。将两个或多个互斥锁用于代码片段时要小心，当线程第一个pthread_mutex_lock已经锁住，而第二个pthread_mutex_lock被其他线程锁住时，那么第一个互斥锁最终可能会锁定其他所有线程访问数据，包括第二个互斥锁的线程。线程无限期地等待资源变得空闲，从而变成死锁。

```c
void * function1（）
{
	...
	pthread_mutex_lock（＆lock1）; - 执行步骤1
	pthread_mutex_lock（＆lock2）; - 执行步骤3 DEADLOCK !!!
	...
	...
	pthread_mutex_lock（＆lock2）;
	pthread_mutex_lock（＆lock1）;
	...
}
void * function2（）
{
	...
	pthread_mutex_lock（＆lock2）; - 执行步骤2
	pthread_mutex_lock（＆lock1）;
	...
	...
	pthread_mutex_lock（＆lock1）;
	pthread_mutex_lock（＆lock2）;
	...
}
int main（）
{
	...
	pthread_create（＆thread1，NULL，function1，NULL）;
	pthread_create（＆thread2，NULL，function1，NULL）;
	...
}
```



# goroutine

```go
import (
	"fmt"
	"sync"
)
func main() {
	wg := sync.WaitGroup{} // 这里waitgroup类似于pthread_join,等待线程运行完成
	wg.Add(2)
	go worker(&wg)
	go worker(&wg)
	wg.Wait()
}
func worker(wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("Hello world")
}
```

Grouting是go语言特有的并发体，是一种轻量级的线程，由go关键字启动，goroutine和系统线程也不是等价的，两者的区	别实际上只是一个量的区别，正是这个量变引发了质变

- 创建线程容易，退出难，创建一个线程虽然参数不少，但是可以接受，但是一旦涉及到退出就要考虑thread是detached还是joinable
- 线程并发单元间通信困难，易错，多个线程之间虽然有多种机制可选，用起来相当复杂，一个设计到共享内存，就绪各种锁，切容易造成死锁
- `__stacksize`的设定，大小难以确定，系统线程默认是2M
- 一个线程代价相对于进程来说已经很小了，但我们依然不能不能大量创建线程，因为除了每个线程占用的资源除外，操作系统切换线程的代价也不小
- 对于网络程序来说，由于不能创建大量的线程，就要在少量的线程中做网络多路复用，使用epoll这套机制，即便有[libevent](https://github.com/libevent/libevent)/[libev](http://software.schmorp.de/pkg/libev.html)，但是使用起来也相对比较复杂

go采用了用户层轻量级thread，goroutine的stack size非常小（默认2k），goroutine调度的切换不会陷入(trap)操作系统内核层完成，代价很低

一个go程序对于一个操作系统来说知识一个用户层程序，对于操作系统而言只有线程没有goroutine，goroutine的调度全靠go自己完成，一个go程序中，除了用户代码，剩下的就是go runtime了；

线程竞争的是真实物理CPU，go程序是用户层程序，本身整体运行在一个或多个操作系统线程，因此goroutine竞争的 *CPU资源* 实际指的是系统线程

## Atomicity - 原子操作

原子操作，并发编程中“最小的且不可并行化”的操作。从线程角度说，在当前线程修改共享资源期间，其他的线程时不能访问改资源的。go语言是使用sync.Mutex来实现，类似于线程的pthread_mutex_t

```go
var total struct {
 sync.Mutex
 value int
}
func worker(wg *sync.WaitGroup) {
 defer wg.Done()
 for i := 0; i <= 100; i++ {
 total.Lock()
 total.value += i
 total.Unlock()
 }
}
func main() {
 var wg sync.WaitGroup
 wg.Add(2)
 go worker(&wg)
 go worker(&wg)
 wg.Wait()
 fmt.Println(total.value)
}
```

使用互斥锁保护一个数值型的共享资源，效率比较低，有点大才小用的感觉，标准库sync/atomic提供了丰富的支持

```go
var total uint64
func worker(wg *sync.WaitGroup) {
 defer wg.Done()
 var i uint64
 for i = 0; i <= 100; i++ {
 atomic.AddUint64(&total, i)
 }
}
func main() {
 var wg sync.WaitGroup
 wg.Add(2)
 go worker(&wg)
 go worker(&wg)
 wg.Wait()
}
```

## channel

无缓存的发送操作总在对应的接收操作完成之前发生

```go
var message string

var done = make(chan struct{})
func main() {
	go worker()
	<-done// 优先执行接收操作，但会被阻塞直到channel被写入，message被正常赋值
	fmt.Println(message)
}
func worker() {
	message = "hello world"
 done <- struct{}{}
}
```

对于无缓存channel进程的接收，发生在对该channel进行的发送完成之前

```go
var message string

var done = make(chan struct{})
func main() {
	go worker() 
	done <- struct{}{}// 
	fmt.Println(message)
}
func worker() {
	message = "hello world"
	<-done
}
```

对于channle的第K个接收操作发生在第K+C个操作完成之前，其中c是channle的capacity

操作系统只认线程调用，goroutine和线程有哪些区别

goroutine和线程的区别

[TOC]

疑问：

1. 为什么append要返回一个切片？

```go
var a = make([]int, 1, 2)
fmt.Printf("%v\t\t%v\n", a, (*reflect.SliceHeader)(unsafe.Pointer(&a)))
a = append(a, 2)
fmt.Printf("%v\t\t%v\n", a, (*reflect.SliceHeader)(unsafe.Pointer(&a)))
a = append(a, 3, 4, 5)
fmt.Printf("%v\t%v\n", a, (*reflect.SliceHeader)(unsafe.Pointer(&a)))
// [0] &{824634327040 1 2}
// [0 2] &{824634327040 2 2}
// [0 2 3 4 5] &{824634368000 5 6}
```

- 如果切片容量不足的话，go扩容切片需要重新申请内存，内存地址会发生变化

- 如果切片容量充足,go不需要扩容，底层数组data内存地址也不会发生变化，`func append(slice []Type, elems ...Type) []Type` 传入的切片也是复制(切片数据结构), 函数的参数是传值, 底层数组部分是通过隐式指针传递(指针本身依然是传值的，但是指针指向的却是同一份的数据)，所以被调用函数是可以通过指针修改掉调用参数切片中的数据。除了数据之外，切片结构还包含了切片长度和切片容量信息，这2个信息也是传值的。如果被调用函数中修改了`Len`或`Cap`信息的话，就无法反映到调用参数的切片中，这时候一般会通过返回修改后的切片来更新之前的切片。

2. 这里注意一下切片a的容量是6，按照我们之前的说法，newcap > 2倍容量时, 取newcap为最终容量，但这里5 > 2 * 2，为什么这里是6呢？内存对齐，最后会解释一下这里的原因

# Go语言程序的初始化

执行从main.main开始，如果main导入了其他的包，会按照顺序将他们包含进mian包里

- 如果某个包被多次导入的话，只会导入的时候只会执行一次
- 当一个包被导入的时候如果还导入了其他的包，则会将其他的包先导入进来，创建和初始化常量和变量，再调用包里的init函数
- 如果一个包里的有多个init函数，调用顺序未定义，同一个文件内的init函数则是以顺序依次调用
- 最后，当main包的所有包级变量、常量创建初始化完成，init函数执行之后才会进入main.main

![](/images/blog/1/golang/assert/数组切片引用.png)

# 函数

```go
// 具名函数
func Add(a, b int) int {
 return a+b
}

// 匿名函数
var Add = func(a, b int) int {
 return a+b
}

func Inc() (v int) {
 // 闭包，什么是闭包
 defer func() {v++}()
 return 42
}
// 43，这里为什么是43而不是42

func main() {
 for i := 0; i < 3; i++ {
 defer func(){ println(i) } ()
 }
}
// Output:
// 3
// 3
// 3
```

- 函数有具名函数和匿名函数之分，包级一般都是具名函数，具名函数是匿名函数的一种特例。
- 当匿名函数引用了外部作用域中的变量时就成了闭包函数，闭包函数是函数式编程语言的核心。
- 函数可以有多个参数和返回值，参数和返回值都是以传值的方式和被调用者交换数据，支持可变参数传值，可变参数必须是最后一个参数，可变数量的参数其实是一个切片类型的参数。
- 函数不仅参数可以有名字，也可以给返回值命名。
- 闭包函数对外部捕获的变量不是以传值方式而是以引用方式传参
- 不建议for循环内部使用defer语句
- 任何可以通过函数参数修改调用参数的情形，是因为函数参数中显式或隐式的传入指针参数

# 方法

```go
// 关闭文件
func (f *File) Close() error {
 // ...
}
// 读文件数据
func (f *File) Read(offset int64, data []byte) int {
 // ...
}
```

- Go语言中，将第一个函数参数移动到函数前面 - 方法
- Go语言中，通过在结构体内置匿名的成员来实现继承
- Go语言中，方法是编译时静态绑定的

# 接口

Go语言在提供严格的类型检查的同时，通过接口类型实现了对鸭子类型的支持，使得安全动态的编程变得相对容易。

> 鸭子类型 - 当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。
>
> 在鸭子类型中，关注点在于对象的行为，能作什么；而不是关注对象所属的类型。例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为"鸭子"的对象，并调用它的"走"和"叫"方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的"走"和"叫"方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的"走"和"叫"方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。- 维基百科



在Go语言中，对于基础类型（非接口类型）不支持隐式转换，无法将一个int类型的值直接赋值给int64类型的变量，也无法将int的值赋值给底层是int类型新定义命名类型的变量，go语言对类型的一致性要求非常严格，但是对接口转化则是非常的灵活，对象和接口之间的转换、接口和接口之间的转换都可能是隐式的转换。

有时候对象和接口之间太灵活了，导致我们需要人为地限制这种无意之间的适配。常见的做法是定义一个含特殊方法来区分接口。比如`runtime`包中的`Error`接口就定义了一个特有的`RuntimeError`方法，用于避免其它类型无意中适配了该接口：

```go
type runtime.Error interface {
 error
 // RuntimeError is a no-op function but
 // serves to distinguish types that are run time
 // errors from ordinary errors: a type is a
 // run time error if it has a RuntimeError method.
 RuntimeError()
}

type testing.TB interface {
 Error(args ...interface{})
 Errorf(format string, args ...interface{})
 ...

 // A private method to prevent users implementing the
 // interface and so future additions to it will not
 // violate Go 1 compatibility.
 private()
}
```

扩容和内存对齐

```go
// 这个例子 讲讲扩容或内存
var a = make([]int, 1, 1)
fmt.Printf("%v\t%v\n", a, (*reflect.SliceHeader)(unsafe.Pointer(&a)))
a = append(a, 2, 3, 4, 5)
fmt.Printf("%v\t%v\n", a, (*reflect.SliceHeader)(unsafe.Pointer(&a)))
// [0] &{824634335232 1 1}
// [0 2 3 4 5] &{824634368000 5 6}
```

按照扩容的第二条，大于两倍旧容量，按理说应该是5但这里是6，那就是接下来的内存对齐了

- capmem = roundupsize(uintptr(newcap) * sys.PtrSize)
- newcap 我们计算出来是5, uintptr(newcap) * sys.PtrSize -> 5 * 8 = 40; roundupsize(40)
- (size+smallSizeDiv-1)/smallSizeDiv] -> (40 + 8 - 1)/8 = 5（这里是因为int存储的，后面小数都是截取）class_to_size[size_to_class8[5]] -> 48 
- 48 / 8 = 6 所以最终cap为6

记一下学习心得，写写来的踏实

go 函数方法接口

go语言提倡的并发模型就是：**不要通过共享内存的方式进行通信，而是应该通过通信的方式共享内存**

# 目录

[TOC]

# mind map

![](/images/blog/1/golang/assert/channel.png)

# 结构体

```go
type hchan struct {
	qcount uint // total data in the queue
	dataqsiz uint // size of the circular queue
 // buf数组，这里存储的就是发送的数据
	buf unsafe.Pointer // points to an array of dataqsiz elements
	elemsize uint16
 // chan是否关闭
	closed uint32
	elemtype *_type // element type
 // 数组写过队列应该明白就是为了让数组能转起来
	sendx uint // send index
	recvx uint // receive index
	// 这里维护等待 发送/接收 goroutine
	recvq waitq // list of recv waiters
	sendq waitq // list of send waiters
	// lock protects all fields in hchan, as well as several
	// fields in sudogs blocked on this channel.
	//
	// Do not change another G's status while holding this lock
	// (in particular, do not ready a G), as this can deadlock
	// with stack shrinking.
	lock mutex // 互斥锁，buf数组并不是线程安全的
}
```
# 调用栈 
下面的内容都是源码分析不想深入的同学，就不要看了。chan有4个动作，相应的**代码位置**：
1. make -> runtime/chan.makechan
2. send -> runtime/chan.chansend
3. recieve -> runtime/chan.chanrecv
4. closed -> runtime/chan.closechan

## make

```go
func makechan(t *chantype, size int) *hchan {
	elem := t.elem
	// compiler checks this but be safe.
 // 这里是编译器检测
	if elem.size >= 1<<16 {
		throw("makechan: invalid channel element type")
	}
	if hchanSize%maxAlign != 0 || elem.align > maxAlign {
		throw("makechan: bad alignment")
	}
	mem, overflow := math.MulUintptr(elem.size, uintptr(size))
	if overflow || mem > maxAlloc-hchanSize || size < 0 {
		panic(plainError("makechan: size out of range"))
	}
	// Hchan does not contain pointers interesting for GC when elements stored in buf do not contain pointers.
	// buf points into the same allocation, elemtype is persistent.
	// SudoG's are referenced from their owning thread so they can't be collected.
	// TODO(dvyukov,rlh): Rethink when collector can move allocated objects.
	var c *hchan
	switch {
	case mem == 0:// 无缓存channel
		// Queue or element size is zero.
		c = (*hchan)(mallocgc(hchanSize, nil, true))// 无缓存channel就没必要申请buf
		// Race detector uses this location for synchronization.
		c.buf = c.raceaddr()
	case elem.kind&kindNoPointers != 0:// 有缓存channel
		// Elements do not contain pointers.
		// Allocate hchan and buf in one call.
 // 这里提到chan最好不要包含指针传递，并发的话会引起race
		c = (*hchan)(mallocgc(hchanSize+mem, nil, true))// 结构体的大小加上buf的大小
		c.buf = add(unsafe.Pointer(c), hchanSize)
 // 这里画一下内存大小,chan struct中的buf指向就是后面多申请的这一块buf内存
 // |chan struct|buf...|
	default:
		// Elements contain pointers.
		c = new(hchan)
		c.buf = mallocgc(mem, elem, true)
	}
	c.elemsize = uint16(elem.size)
	c.elemtype = elem
	c.dataqsiz = uint(size)
	if debugChan {
		print("makechan: chan=", c, "; elemsize=", elem.size, "; elemalg=", elem.alg, "; dataqsiz=", size, "\n")
	}
	return c
}
```

chan通道实际也是通过共享内存和互斥锁实现

chan最好不要传递指针

## send

无缓冲channel send

```go
// entry point for c <- x from compiled code
//go:nosplit
func chansend1(c *hchan, elem unsafe.Pointer) {
	chansend(c, elem, true, getcallerpc())
}

/*
 * generic single channel send/recv
 * If block is not nil,
 * then the protocol will not
 * sleep but return if it could
 * not complete.
 *
 * sleep can wake up with g.param == nil
 * when a channel involved in the sleep has
 * been closed. it is easiest to loop and re-run
 * the operation; we'll see that it's now closed.
 */
func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
 // 内部检查，避免一些低级的错误发生
	if c == nil {
		if !block {
			return false
		}
		gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
		throw("unreachable")
	}
	if debugChan {
		print("chansend: chan=", c, "\n")
	}
	if raceenabled {
		racereadpc(c.raceaddr(), callerpc, funcPC(chansend))
	}

	// Fast path: check for failed non-blocking operation without acquiring the lock.
	//
 // 没有recv goroutine，就无法send
 // channel buf 满了也是无法再次发送 todo::做着的目的是为了啥
	if !block && c.closed == 0 && ((c.dataqsiz == 0 && c.recvq.first == nil) ||
		(c.dataqsiz > 0 && c.qcount == c.dataqsiz)) {
		return false
	}
	var t0 int64
	if blockprofilerate > 0 {
		t0 = cputicks()
	}
 // buf array共享内存，互斥锁来避免数据竞争
	lock(&c.lock)
	// send on closed channel 这句话应该见到的挺多的了
	if c.closed != 0 {
		unlock(&c.lock)
		panic(plainError("send on closed channel"))
	}
 // 有goroutine等待接收channel，不需要进入buf，直接发送给等待接收的goroutine
	if sg := c.recvq.dequeue(); sg != nil {
		send(c, sg, ep, func() { unlock(&c.lock) }, 3) // 这里是真正发送给接收线程的操作
		return true
	}
 // buf不满
	if c.qcount < c.dataqsiz {
		// chanbuf 获取当前，发送索引的内存地址
		qp := chanbuf(c, c.sendx)
		if raceenabled {
			raceacquire(qp)
			racerelease(qp)
		}
 // 这里是memmove(to, from, elem), 就是将ep(elem)数据写入到发送所有的地址
		typedmemmove(c.elemtype, qp, ep)
 // 接下来的操作就是：如何用数组来模拟一个队列
		c.sendx++
		if c.sendx == c.dataqsiz {
			c.sendx = 0
		}
		c.qcount++
 // 释放锁
		unlock(&c.lock)
		return true
	}

	if !block {
		unlock(&c.lock)
		return false
	}
	// buf满了，需要阻塞发送的goroutine
	// Block on the channel. Some receiver will complete our operation for us.
	gp := getg()
	mysg := acquireSudog()
	mysg.releasetime = 0
	if t0 != 0 {
		mysg.releasetime = -1
	}
	// No stack splits between assigning elem and enqueuing mysg
	// on gp.waiting where copystack can find it.
	mysg.elem = ep
	mysg.waitlink = nil
	mysg.g = gp
	mysg.isSelect = false
	mysg.c = c
	gp.waiting = mysg
	gp.param = nil
 // 这上面就是阻塞并序列化当前goroutine，放到等待发送的队列中，并释放锁
	c.sendq.enqueue(mysg)
 // 当前goroutine的运行状态：Grunning -> Gwaiting
	goparkunlock(&c.lock, waitReasonChanSend, traceEvGoBlockSend, 3)
	// Ensure the value being sent is kept alive until the
	// receiver copies it out. The sudog has a pointer to the
	// stack object, but sudogs aren't considered as roots of the
	// stack tracer.
 // keepalive可以确保ep在此之前不会被gc回收
	KeepAlive(ep)
	// someone woke us up.
	if mysg != gp.waiting {
		throw("G waiting list is corrupted")
	}
	gp.waiting = nil
	if gp.param == nil {
		if c.closed == 0 {
			throw("chansend: spurious wakeup")
		}
		panic(plainError("send on closed channel"))
	}
	gp.param = nil
	if mysg.releasetime > 0 {
		blockevent(mysg.releasetime-t0, 2)
	}
	mysg.c = nil
 // 释放goroutine
	releaseSudog(mysg)
	return true
}
```

## close

```go
func closechan(c *hchan) {
	if c == nil {
		panic(plainError("close of nil channel"))
	}
	// channel 加锁
	lock(&c.lock)
	if c.closed != 0 {
		unlock(&c.lock)
		panic(plainError("close of closed channel"))
	}
	if raceenabled {
		callerpc := getcallerpc()
		racewritepc(c.raceaddr(), callerpc, funcPC(closechan))
		racerelease(c.raceaddr())
	}
 // 标记channel已经关闭了
	c.closed = 1
	// 这里声明一个链表，收集send/recv队列中的G，方便
	var glist gList

	// release all readers
	for {
		sg := c.recvq.dequeue()
		if sg == nil {
			break
		}
		if sg.elem != nil {
			typedmemclr(c.elemtype, sg.elem)
			sg.elem = nil
		}
		if sg.releasetime != 0 {
			sg.releasetime = cputicks()
		}
		gp := sg.g
		gp.param = nil
		if raceenabled {
			raceacquireg(gp, c.raceaddr())
		}
 // glist收集所有等待接收的goroutine
		glist.push(gp)
	}

	// release all writers (they will panic)
	for {
		sg := c.sendq.dequeue()
		if sg == nil {
			break
		}
		sg.elem = nil
		if sg.releasetime != 0 {
			sg.releasetime = cputicks()
		}
		gp := sg.g
		gp.param = nil
		if raceenabled {
			raceacquireg(gp, c.raceaddr())
		}
 // // glist收集所有等待发送的goroutine
		glist.push(gp)
	}
 // channel解锁
	unlock(&c.lock)

	// Ready all Gs now that we've dropped the channel lock.
	for !glist.empty() {
		gp := glist.pop()
		gp.schedlink = 0
 // glist中的所有goroutine从Gwaiting -> Grunable 
		goready(gp, 3)
	}
}
```

## receive

```go
// chanrecv receives on channel c and writes the received data to ep.
// ep may be nil, in which case received data is ignored.
// If block == false and no elements are available, returns (false, false).
// Otherwise, if c is closed, zeros *ep and returns (true, false).
// Otherwise, fills in *ep with an element and returns (true, true).
// A non-nil ep must point to the heap or the caller's stack.
func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
	// 这一块和发送的时候是一样的属于编译器的检查
	if debugChan {
		print("chanrecv: chan=", c, "\n")
	}
	if c == nil {
		if !block {
			return
		}
		gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
		throw("unreachable")
	}
	if !block && (c.dataqsiz == 0 && c.sendq.first == nil ||
		c.dataqsiz > 0 && atomic.Loaduint(&c.qcount) == 0) &&
		atomic.Load(&c.closed) == 0 {
		return
	}

	var t0 int64
	if blockprofilerate > 0 {
		t0 = cputicks()
	}
	// channel加锁
	lock(&c.lock)

	if c.closed != 0 && c.qcount == 0 {
		if raceenabled {
			raceacquire(c.raceaddr())
		}
		unlock(&c.lock)
		if ep != nil {
			typedmemclr(c.elemtype, ep)
		}
		return true, false
	}
	// 给接收者发送element
	if sg := c.sendq.dequeue(); sg != nil {
		// Found a waiting sender. If buffer is size 0, receive value
		// directly from sender. Otherwise, receive from head of queue
		// and add sender's value to the tail of the queue (both map to
		// the same buffer slot because the queue is full).
		recv(c, sg, ep, func() { unlock(&c.lock) }, 3)
		return true, true
	}
	// buf不为空
	if c.qcount > 0 {
		// Receive directly from queue
		qp := chanbuf(c, c.recvx)
		if raceenabled {
			raceacquire(qp)
			racerelease(qp)
		}
		if ep != nil {
 // 将buf c.recvx位置的数据copy到ep内存上
			typedmemmove(c.elemtype, ep, qp)
		}
		typedmemclr(c.elemtype, qp)
 // 等价 c.recvx = (c.recvx + 1) % c.dataqsiz
		c.recvx++ 
		if c.recvx == c.dataqsiz {
			c.recvx = 0
		}
		c.qcount--
 // channel解锁
		unlock(&c.lock)
		return true, true
	}

	if !block {
		unlock(&c.lock)
		return false, false
	}

	// no sender available: block on this channel.
 // 没有接收者，阻塞当前goroutine,压入c.recvq
	gp := getg()
	mysg := acquireSudog()
	mysg.releasetime = 0
	if t0 != 0 {
		mysg.releasetime = -1
	}
	// No stack splits between assigning elem and enqueuing mysg
	// on gp.waiting where copystack can find it.
	mysg.elem = ep
	mysg.waitlink = nil
	gp.waiting = mysg
	mysg.g = gp
	mysg.isSelect = false
	mysg.c = c
	gp.param = nil
	c.recvq.enqueue(mysg)
 // 当前goroutine的状态: Grunning -> Gwaiting
	goparkunlock(&c.lock, waitReasonChanReceive, traceEvGoBlockRecv, 3)
	// someone woke us up
	if mysg != gp.waiting {
		throw("G waiting list is corrupted")
	}
	gp.waiting = nil
	if mysg.releasetime > 0 {
		blockevent(mysg.releasetime-t0, 2)
	}
	closed := gp.param == nil
	gp.param = nil
	mysg.c = nil
 // 释放当前groutine
	releaseSudog(mysg)
	return true, !closed
}
```

神秘的channel。源码面前，了无密码

整理一下如何拼接字符串及几种方式的使用场景