疑问：

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]

通过数据结构、实现原理、读写操作来了解go hashmap

# 数据结构

![](/images/blog/1/golang/assert/go-map.jpg)

hash有2个关键数据结构: `hmap` `bmap`

**hmap:  `runtime/map.go`**

```go
type hmap struct {
	count     	int 
	flags     	uint8
	B         	uint8  
	noverflow 	uint16 
	hash0     	uint32 
	buckets    	unsafe.Pointer 
	oldbuckets 	unsafe.Pointer
	nevacuate  	uintptr
	extra 		*mapextra 
}
```

-   `count`  元素数量
-   `B`  2^B个buckets桶
-   `noverflow` buckets溢出桶的数量，近似值
-   `buckets` 桶
-   `oldbuckets` 扩容时指向原buckets桶

**bmap: `runtime/map.go`  `cmd/compile/internal/gc/reflect.go`**

```go
type bmap struct {
    topbits 	[8]uint8
    keys 		[8]keytype
    elems 		[8]elemtype
    pad 		uintptr
    overflow	uintptr
}
```

哈希表中桶的真正结构其实是在编译期间运行的函数 `bmap` 中被『动态』创建的， 代码在`cmd/compile/internal/gc/reflect.go`

-   `topbits` 存储hash值的高8位，通过比对高8位减少键值对访问次数以提高性能
-   `keys` / `elems` 数组

-   `pad` 内存对齐
-   `overflow` 溢出桶，map存储数据过多时使用

# 实现原理

时间复杂度: O(1)

hash函数和hash冲突解决方法

**hash函数**

实现哈希表的关键点在于如何选择哈希函数，哈希函数的选择在很大程度上能够决定哈希表的读写性能，在理想情况下，哈希函数应该能够将不同键映射到不同的索引上，这要求**哈希函数输出范围大于输入范围**，但是由于键的数量会远远大于映射的范围，所以在实际使用时，这个理想的结果是不可能实现的。

**hash冲突**

开放寻址法：对数组中的元素依次比较键值对是否存在于数组

拉链法： 使用数组加上链表

![](/images/blog/1/golang/assert/hashmap-拉链法.png)

# 读写操作

**读**

![](/images/blog/1/golang/assert/go-map-get.jpg)

-   计算出key的hash
-   用最后的“B”位来确定在哪个桶（“B”就是前面说的那个，B为4，就有16个桶，0101用十进制表示为5，所以在5号桶）
-   根据key的前8位快速确定是在哪个格子（额外说明一下，在bmap中存放了每个key对应的tophash，是key的前8位）
-   最终还是需要比对key完整的hash是否匹配，如果匹配则获取对应value
-   如果都没有找到，就去下一个overflow找

**写**

-   通过key的后“B”位确定是哪一个桶
-   通过key的前8位快速确定是否已经存在
-   最终确定存放位置，如果8个格子已经满了，没地方放了，那么就重新创建一个bmap作为溢出桶连接在overflow

**扩容**

条件：

-   装载因子大于6.5
-   溢出桶 大于15个

```go
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
	...
	if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
		hashGrow(t, h)
		goto again
	}
	...
}
```

方式：

-   等量扩容
-   翻倍扩容



知道map数据结构长什么样才能知道是怎么访问的, 冲突时如何解决的

go基础数据结构 hashmap数据结构与实现原理

[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。源码面前，了无密码

1. struct支持导出为excel, 2. excel导入为struct, 3.表头支持扩展，如：日期表头不确定长度, 4. excel第一行为备注, 5. excel表头进行汇总, 6. 标记某行为特殊颜色, 7. 如果字段为空，就不生成该表头

go语言struct结构体支持导入导出excel

1. `omitempty` 字段为空时( 空指针, 空接口, 空数组, slice, map, or string.)，json encode时不返回该字段

```go
type person struct {
	Name string `json:"name,omitempty"`
	Age int `json:"age"`
}

var p = person{
 Name: "",
 Age: 18,
}
if res, err := json.Marshal(&p); err != nil {
 fmt.Println(err)
	return
} else {
 fmt.Println(string(res))
}
// {"age":18}
```

2. `string` 字符串和数字类型转换，对于php和js这类弱类型语言字符串和数字很容易就混

```go
type person struct {
	Name string `json:"name,omitempty"`
	Age int `json:"age,string"`
}

var p1 person
str := `{"name":"douyacun", "age": "18"}`
if err := json.Unmarshal([]byte(str), &p1); err != nil {
 fmt.Println(err)
 return
}
fmt.Println(p1)
// {douyacun 18}
```

如果age 没有string tag的话，会报错 `json: cannot unmarshal string into Go struct field person.age of type int`

3. `-` 忽略字段

```go
type person struct {
	Name string `json:"name,omitempty"`
	Age int `json:"age,string"`
	Height int `json:"-"`
}
var p = person{
 Name: "",
 Age: 18,
 Height: 180,
}
if res, err := json.Marshal(&p); err != nil {
 fmt.Println(err)
 return
} else {
 fmt.Println(string(res))
}
// {"age":"18"}
var p1 person
str := `{"name":"douyacun", "age": "18", "height": 180}`
if err := json.Unmarshal([]byte(str), &p1); err != nil {
 fmt.Println(err)
 return
}
fmt.Println(p1)
// {douyacun 18 0}
```

4. 判断json字符串是否有效

```json
fmt.Println(json.Valid([]byte(`{"name":"douyacun", "age": "18", "height": 180}`)))
// true
```

5. 从数据流读取字符串并解码

```go
var jsonStream = `
	{"Message": "Hello", "Array": [1, 2, 3], "Null": null, "Number": 1.234}
`
des := json.NewDecoder(strings.NewReader(jsonStream))
for{
 t, err := des.Token()
 if err == io.EOF {
 break
 }
 if err != nil {
 fmt.Printf("%v\n", err)
 return
 }
 if _, ok := t.(json.Delim); !ok {
 fmt.Printf("%T: %v\n", t, t)
 }
}
// string: Hello
// string: Array
// float64: 1
// float64: 2
// float64: 3
// string: Null
// <nil>: <nil>
// string: Number
// float64: 1.234
```

6. 对于不确定是int或者float的字段，可以使用json.Number

```go
type person struct {
	Weight json.Number `json:"weight"`
}

var p person
str := `{"weight": 19}`
if err := json.Unmarshal([]byte(str), &p); err != nil {
 fmt.Println(err)
 return
}
fmt.Println(p.Weight.Int64())
// 19 <nil>
```

7. 可以像orm一样写原生sql。像es的查询结果如何定义结构体：

**编码**

```go
type person struct {
	Weight json.Number `json:"weight"`
	Skill json.RawMessage `json:"skill"`
}

skill := map[string]interface{}{
 "language": []string{"c", "php", "js", "golang"},
 "js": []string{"react"},
 "php": []string{"Laravel", "ThinkPHP"},
 "golang": []string{"gin"},
}
res, err := json.Marshal(skill)
if err != nil {
 fmt.Println(err)
}
p := person{
 Weight: "89",
 Skill: json.RawMessage(res),
}
if res, err := json.MarshalIndent(p, "", "\t"); err != nil {
 fmt.Println(err)
 return
} else {
 fmt.Println(string(res))
}
```

输出

```json
{
 "weight": 89,
 "skill": {
 "golang": [
 "gin"
 ],
 "js": [
 "react"
 ],
 "language": [
 "c",
 "php",
 "js",
 "golang"
 ],
 "php": [
 "Laravel",
 "ThinkPHP"
 ]
 }
}
```

**解码**

像ES search结果集，外层有公共的数据结构

```json
{
 "took" : 0,
 "timed_out" : false,
 "_shards" : {
 "total" : 1,
 "successful" : 1,
 "skipped" : 0,
 "failed" : 0
 },
 "hits" : {
 "total" : {
 "value" : 12,
 "relation" : "eq"
 },
 "max_score" : 1.0,
 "hits" : []
 }
}
fmt.Println(p1)
// {douyacun 18}
// 如何不加string，会报错: json: cannot unmarshal string into Go struct field person.age of type int
```

结构体

```go
type ESListResponse struct {
	Took int `json:"took"`
	Timeout bool `json:"timed_out"`
	Shards struct {
		Total int `json:"total"`
		Successful int `json:"successful"`
		Skipped int `json:"skipped"`
		Failed int `json:"failed"`
	} `json:"_shards"`
	Hits struct {
		Total struct {
			Value int `json:"value"`
			Relation string `json:"relation"`
		} `json:"total"`
		MaxScore float64 `json:"max_score"`
		Hits []json.RawMessage `json:"hits"`
	} `json:"hits"`
}
type ESItemResponse struct {
	Index string `json:"_index"`
	Type string `json:"_type"`
	Id string `json:"_id"`
	Score float64 `json:"_score"`
	Source json.RawMessage `json:"_source"`
}
```

这个有点复杂，写个简单的例子：

```go
type person struct {
	Weight json.Number `json:"weight"`
	Skill json.RawMessage `json:"skill"`
}


str := `{
	"weight": 180,
	"skill": {
		"language": ["php", "golang", "c", "python"],
		"database": ["elasticsearch", "mysql", "redis"]
	}
}`
var p person
if err := json.Unmarshal([]byte(str), &p); err != nil {
 fmt.Println(err)
 return
}
fmt.Printf("weight: %s\nskill: %s\n", p.Weight, p.Skill)

type _skill struct {
 Language []string `json:"language"`
 Database []string `json:"database"`
}

var skill _skill
if err := json.Unmarshal(p.Skill, &skill); err != nil {
 fmt.Println(err)
 return
}
fmt.Printf("%+v\n", skill)
```

输出：

```
weight: 180
skill: {
 "language": ["php", "golang", "c", "python"],
 "database": ["elasticsearch", "mysql", "redis"]
 }
{Language:[php golang c python] Database:[elasticsearch mysql redis]}
```

其实 p.Skill 还是 []byte,可以再次被 Unmarshal

json包的使用不是像php那样json_encode/json_decode,有更大操作空间

go json 解析小技巧

**go连接mysql为什么需要 import _ "github.com/go-sql-driver/mysql"**

go中import _的作用只执行引入包的init函数，那么go-sql-driver/mysql 的init函数又做了什么，在`database/sql` 中的`drivers map[string]driver.Driver`注册引擎 mysql => MySQLDriver{}

```go
// go-sql-driver/mysql/driver.go
func init() {
	sql.Register("mysql", &MySQLDriver{})
}
```


**SetMaxIdleConns/SetMaxOpenConns/SetConnMaxLifetime 设置的值有什么用呢？**

- db.maxLifetime 连接从创建开始存活的时间，mysql默认tcp连接的超时时间 8h
- db.maxOpen 打开的连接最大数量，超过该数量后，query会被阻塞等待可用连接
- db.maxIdle 空闲池维持的最大连接数量

**sql.Open为什么只需要一次调用即可?**

1. 加载驱动程序 go-sql-driver/mysql
2. 初始化DB数据结构
3. 构造创建连接channel/重置连接channel

这里并有实际去和数据建立连接，也没有对数据库连接的参数校验，只是初始化了DB结构体，DB结构体中已经包含了连接池 freeConn []*driverConn, 没有必要多次调用open，全局维护一个DB即可，如果需要验证 账户密码/网络是否能通信，需要调用ping来检测。

```go
type DB struct {
	waitDuration int64 // 统计每次链接的等待时间

	connector driver.Connector

	// 已经关闭的连接数量
	numClosed uint64

	mu sync.Mutex

	freeConn []*driverConn // 空闲池
	connRequests map[uint64]chan connRequest // 等待连接队列，当前连接达到maxOpen时，就无法不在创建连接，创建一个请求的channel入队列并等待并阻塞当前goroutine
	nextRequest uint64 // connRequests[] 指向下一个坑位
	numOpen int // 正在使用的连接数量

	// channel 通过此channel来接受建立新的session连接
	// DB.connectionOpener for select 接收channel
	openerCh chan struct{}
	resetterCh chan *driverConn // 重置session以便其他query复用当前session
	closed bool // 标记是否已经关闭链接
	dep map[finalCloser]depSet //
	lastPut map[*driverConn]string // 调试用
	maxIdle int // 维持的最大空闲连接数，小于等于0使用defaultMaxIdleConns（2)
	maxOpen int // 维持的最大连接数，0无限制
	maxLifetime time.Duration // 连接可以重用的最长时间
	cleanerCh chan struct{}
	waitCount int64 // 等待连接的总数
	maxIdleClosed int64 // 由于空闲而连接的总数
	maxLifetimeClosed int64 // 连接存活时间超过maxLifetime而关闭的时间

	stop func() // 取消接收 建立连接channel(openerCh)/重置session channel(resetterCh)
}
```



**如果获取数据连接池的状态？当前的连接总数，SetMaxOpenConns/SetMaxIdleConns的数量是否合适。**

使用db.Stats可以查看当前连接池的一些状态,这边返回了一个DBStats结构体，一起看下:

```go
type DBStats struct {
	MaxOpenConnections int // 打开的最大连接数，包含已经关闭了的连接

	// 连接池状态
	OpenConnections int // 当前建立连接的数量，包括正在使用和空闲的数量
	InUse int // 正在使用的连接数
	Idle int // 已建立连接，空闲中的连接数

	// 统计
	WaitCount int64 // 等待连接的总数，这里需要着重关注一下
	WaitDuration time.Duration // query持续等待连接的总时长
	MaxIdleClosed int64 // 达到SetMaxIdleConns，而关闭的连接数量
	MaxLifetimeClosed int64 // 达到SetConnMaxLifetime. 而关闭的连接数量
}
```

- WaitCount 着重关注一下，看下是不是有慢查询阻塞了可用的连接数量
- MaxIdleConns设置的过小，而请求数过多导致，会导致MaxIdleClosed比较大，WaitCount也会比较大

注意：db.Stats不要调用过于频繁，它会对整个DB连接池加锁，过于频繁有一定开销。



**DB.Ping()做了哪些事情？DB是如何从连接池中获取一个可用的连接的？**

1. 获取连接，可以复用连接 （cachedOrNewConn）
2. 获取一个可用的连接 driverConn
 1. 复用空闲池中freeConn已有的连接
 1. 从空闲池中移除第一个连接conn
 2. 这期间都是有锁的，freeConn是一个切片，是并发不安全的
 3. 该连接是否在生命周期内 lifetime -- db.SetLifeTime设置的tcp连接存活时间
 - 本连接过了生命周期，返回 driver.ErrBadConn
 4. 返回此conn
 2. db.SetMaxOpenConns设置了最大打开的连接数，且当前打开的连接已经达到最大数
 1. 创建一个等待请求，放入等待队列，阻塞当前goroutine
 2. 等待超时使用context取消，或者等待直到获取可用的连接
 - ctx取消后还是获取到了连接，放回空闲池
 3. 获取到可用连接，统计本次阻塞时长，可以注意到如果DB.Stats().WaitDuration大了以后问题就很严重了
 - 如果本连接过了生命周期，返回 driver.ErrBadConn
 4. 返回此Conn
 3. 封装driver返回的connect到driverConn
 1. 标记driverConn inUse使用中
 2. 记录连接创建时间createdAt
 3. db指向连接池
 4. 真正底层的连接

源码小细节：

- 移除切片第一个元素：`copy(db.freeConn, db.freeConn[1:])`
- 删除map中的元素: delete(db.connRequests, reqKey)
- map[key]interface: 也可以使用channel做为key
- 生命周期判断：createdAt.Add(lifetime).Before(time.now()) 

- 参观一下context的用法

```go
select {
// 这里留取消的口
case <-ctx.Done():
 select {
 // 之前我们分析过select尽量不要加default，单那是for select结构，会造成自旋锁，长期占用M不释放
 // 如果这里不用default它就阻塞一直等待req channel中有connect，这里并不是为了等待，只是为了清理一下channel的connect，防止孤儿connect
 default:
	case ret, ok := <-req:
		//...
 }
 return nil, ctx.Err()
case ret, ok := <-req:
 // ...
 return ret.conn, ret.err
}

// 我们在外面如何控制超时呢？
fun bar(){
 t := time.After(10)
 ctx := context.Background()
 res := make(chan struct{})
 go func() {
 ci, _ := conn(ctx)
 res<-ci
 }()
 select {
 case <-t:
 ctx.Done()
 case ci := <-res:
 if ci != nil {

 }
 }
}
```

go数据库连接池

go单词命名很痛苦,单词太长想用简写

通用简写表

[toc]

# 疑惑

1. 如何区分变量是数组还是切片
2. 数组复制是否像c语言一样，只复制数组开始的地址
3. 为什么字符串（"hello world"）计算大小unsafe.Sizeof()是16

# 数组

### 定义方式：

```go
var a [3]int // 定义长度为3的int型数组, 数组中的每个元素都以零值初始化
var b = [...]int{1, 2, 3} // 定义长度为3的int型数组, 长度根据初始化元素的数目自动计算
var c = [...]int{2: 3, 1: 2} // 定义长度为3的int型数组, 索引的方式来初始化数组的元素
var d = [...]int{1, 2, 4: 5, 6} // 定义长度为6的int型数组, 元素为 1, 2, 0, 0, 5, 6
```

### 概念： 数组是一个固定长度的特定类型元素组成的序列，长度/类型

- 不同长度和类型数据组成数组类型是不同的
- 不同长度的数组因为长度不同无法直接赋值

- 不同于切片，数组的长度是明确指定的
- 不同于c语言数组，go语言数组是值语义，并不是隐式指向第一个元素指针，当一个数组被复制和传递是，实际会复制整个数组
- len 和 cap 返回的结果始终是对应数组的长度
- 数组可以用于数值、字符串、结构体、函数、接口、管道数组

### 内存结构：在内存中连续存储

```
| 1 | 2 | 3 | 4 | 5 |
```

```go
var a = [...]int{1, 2, 3, 4, 5}
fmt.Println(unsafe.Sizeof(a))
// 40
```

Sizeof(a)大小是40，我这系统是64位的所以int位64位,8个字节， 8*5 = 40

# 字符串

### 概念： 一个字符串是一个不可改变的字节序列

- 字符串是一个只读的字节数组，长度是固定的
- 字符串长度并不是字符串类型的一部分，不同长度的字符串可以等值比较
- 字符串是一个结构体，因此字符串赋值操作也就是reflect.StringHeader复制操作，不会涉及到底层数组的复制
- 字符串是只读的，相同字符串常量，通常是对应同一个字符串常量
- 字符串和数组类似也可以通过len获取字符串长度，StringHeader也可以获取

```go
var a = "Hello world"
fmt.Println(len(a))
fmt.Println((*reflect.StringHeader)(unsafe.Pointer(&a)).Len)、
fmt.Println(unsafe.Sizeof(a))
// 11
// 11
// 16
```

a内存的数据，使用reflect.StringHeader类型来解释，类型强制转换, unsafe.Sizeof(a)其实计算的是，下面reflect.StringHeader结构的大小，unitptr 8字节 + int 8字节 = 16字节，因此可以称呼go字符串为字符串结构体

### 数据结构在reflect.StringHeader定义：

```go
type StringHeader struct {
 Data uintptr
 Len int
}
```

字符串的内存结构：

![](/images/blog/1/golang/assert/ch1-8-string-1.ditaa.png)

# 切片

### 概念：切片就是一种简化版的动态数组，动态数组的长度不固定，切片相对于数组更具有灵活性#

- 切片的长度不是类型的组成部分，数组的长度需要计算得出
- 容量必须大于或等于切片的长度
- 在对切片本身赋值或参数传递时，和数组指针的操作方式类似，只是复制切片头信息（`reflect.SliceHeader`）

结构体定义：

```go
type SliceHeader struct {
 Data uintptr
 Len int
 Cap int
}
```

 内存布局：x := []int{2,3,5,7,11}

![](/images/blog/1/golang/assert/ch1-10-slice-1.ditaa.png)

切片声明：

```go
var a []int // 这里只是声明类型，结构体还没有初始化，所以为nil
b := []int{} // 结构体已经初始化了
fmt.Println(a == nil, b == nil)
fmt.Println(unsafe.Sizeof(a))// 8 + 8 + 8 = 24
// true false
// 24
g := make([]int, 3) // 有3个元素的切片, len和cap都为3
```

### 切片新增和删除：

增加元素：

```go
var a = []int{1, 2, 3, 4}
fmt.Println(a, len(a), cap(a))
// [1 2 3 4] 4 4

a = append(a, 5)
fmt.Println(a, len(a), cap(a))
// [1 2 3 4 5] 5 8

var b = make([]int, 0, 1)
b = append(b, 1, 2, 3, 4, 5, 6)
fmt.Println(b, len(b), cap(b))
// [1 2 3 4 5 6] 6 6

var c = make([]int, 1023, 1024)
c = append(c, 1, 3)
fmt.Println(c, len(c), cap(c))
// [0 0 0 0 ...] 1025 1280
```

扩容：

在容量不足的情况下，`append`的操作会导致重新分配内存，可能导致巨大的内存分配和复制数据代价，目的是为了减少向操作malloc申请堆内存的次数，重复的申请代价也是昂贵的

- 期望容量大于当前容量的2倍，使用期望容量
- 当前容量小于1024会将容量翻倍
- 当前容量大于1024，每次增加25%直到大于期望容量

```go
// runtime/slice.go/func growslice(et *_type, old slice, cap int) slice {}
newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
 newcap = cap
} else {
 if old.len < 1024 {
 newcap = doublecap
 } else {
 // Check 0 < newcap to detect overflow
 // and prevent an infinite loop.
 for 0 < newcap && newcap < cap {
 newcap += newcap / 4
 }
 // Set newcap to the requested cap when
 // the newcap calculation overflowed.
 if newcap <= 0 {
 newcap = cap
 }
 }
}

capmem = roundupsize(uintptr(newcap) * sys.PtrSize)
// uintptr: 能存储指针的整型,也能存储int，官方解释：uintptr is an integer type that is large enough to hold the bit pattern of any pointer.
// sys.PtrSize 64位系统是8

// 内存对齐
// Returns size of the memory block that mallocgc will allocate if you ask for the size.
func roundupsize(size uintptr) uintptr {
 // _MaxSmallSize: 32768
	if size < _MaxSmallSize {
		if size <= smallSizeMax-8 {
			return uintptr(class_to_size[size_to_class8[(size+smallSizeDiv-1)/smallSizeDiv]])
		} else {
			return uintptr(class_to_size[size_to_class128[(size-smallSizeMax+largeSizeDiv-1)/largeSizeDiv]])
		}
	}
	if size+_PageSize < size {
		return size
	}
	return round(size, _PageSize)
}

// size_to_class8: 0, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9......
// class_to_size: 0, 8, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160......
```

扩容和内存对齐

```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
a = []int{1, 2, 3}
a = a[1:] // 删除开头1个元素
a = a[N:] // 删除开头N个元素
a = append(a[:0], a[1:]...) // 删除开头1个元素
a = a[:copy(a, a[1:])] // 删除开头1个元素
a = append(a[:i], a[i+1:]...) // 删除中间1个元素
```

### 切片使用技巧

0长切片特性（长度为0，容量不为0），应用场景：过滤掉字符串中的某些字符， 切片高效操作的要点是要降低内存分配的次数

```go
func Filter(s []byte, f func(x byte) bool) []byte {
	b := s[:0] // 这里b的长度是0，容量是s容量等价于 var b = make([]byte, 0, cap(s))
	for _, x := range s {
		if !f(x) {
			b = append(b, x)
		}
	}
	return b
}
```

切片避免内存泄漏, FindPhoneNumber会加载整个文件到内存中，搜索第一个出现的号码，最终结构以切片方式返回，返回结果指向保存整个文件的数组，因为切片引用了整个原始数组，导致垃圾回收器不能及时释放底层的空间

```go
func FindPhoneNumber(filename string) []byte {
 b, _ := ioutil.ReadFile(filename)
 return regexp.MustCompile("[0-9]+").Find(b)
}
```



类似的问题，在删除切片元素时可能会遇到。假设切片里存放的是指针对象，那么下面删除末尾的元素后，被删除的元素依然被切片底层数组引用，从而导致不能及时被自动垃圾回收器回收

```go
var a []*int{ ... }
a = a[:len(a)-1] // 被删除的最后一个元素依然被引用, 可能导致GC操作被阻碍

var a []*int{ ... }
a[len(a)-1] = nil // GC回收最后一个元素内存
a = a[:len(a)-1] // 从切片删除最后一个元素
```

go 类型定义,内存布局,底层数据结构,切片扩容规则

[TOC]

# 	时间格式常量

## 标准

```go
const (
 ANSIC = "Mon Jan _2 15:04:05 2006"
 UnixDate = "Mon Jan _2 15:04:05 MST 2006"
 RubyDate = "Mon Jan 02 15:04:05 -0700 2006"
 RFC822 = "02 Jan 06 15:04 MST"
 RFC822Z = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
 RFC850 = "Monday, 02-Jan-06 15:04:05 MST"
 RFC1123 = "Mon, 02 Jan 2006 15:04:05 MST"
 RFC1123Z = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
 RFC3339 = "2006-01-02T15:04:05Z07:00"
 RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
 Kitchen = "3:04PM"
 // Handy time stamps.
 Stamp = "Jan _2 15:04:05"
 StampMilli = "Jan _2 15:04:05.000"
 StampMicro = "Jan _2 15:04:05.000000"
 StampNano = "Jan _2 15:04:05.000000000"
)
```

## 时/分/秒/毫秒/微妙/纳秒

```go
const (
 Nanosecond Duration = 1
 Microsecond = 1000 * Nanosecond
 Millisecond = 1000 * Microsecond
 Second = 1000 * Millisecond
 Minute = 60 * Second
 Hour = 60 * Minute
)
```

## 月份

```go
const (
	January Month = 1 + iota
	February
	March
	April
	May
	June
	July
	August
	September
	October
	November
	December
)
```

## 星期几

```go
const (
	Sunday Weekday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)
```

# 超时控制 After

```go
var c chan int

func handle(int) {}

func main() {
	select {
	case m := <-c:
		handle(m)
	case <-time.After(10 * time.Second):
		fmt.Println("timed out")gg
	}
}
```

# 时间间隔 Duration

time.Add(t Duration)传参需要使用Durtaion 

## time.Sub

计算两个时间差，返回duration

```go
func expensiveCall() {}

func main() {
	t0 := time.Now()
	expensiveCall()
	t1 := time.Now()
	fmt.Printf("The call took %v to run.\n", t1.Sub(t0))
}
```

## ParseDuration

有效符号："ns", "us" (or "µs"), "ms", "s", "m", "h".

```go
func main() {
	hours, _ := time.ParseDuration("10h")
	complex, _ := time.ParseDuration("1h10m10s")
	micro, _ := time.ParseDuration("1µs")
	// The package also accepts the incorrect but common prefix u for micro.
	micro2, _ := time.ParseDuration("1us")

	fmt.Println(hours)
	fmt.Println(complex)
	fmt.Printf("There are %.0f seconds in %v.\n", complex.Seconds(), complex)
	fmt.Printf("There are %d nanoseconds in %v.\n", micro.Nanoseconds(), micro)
	fmt.Printf("There are %6.2e seconds in %v.\n", micro2.Seconds(), micro)
}
```

# 时间 Time

基础结构体:

```go
type Time struct {
	wall uint64
	ext int64
	loc *Location
}
```

## Date

返回指定日期的time

```go
func main() {
	t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
	fmt.Printf("Go launched at %s\n", t.Local())
}
// Go launched at 2009-11-11 07:00:00 +0800 CST
```

## 当前时间 Now

返回当前时间,这个用的最多

## 时间解析 Parse & ParseInLocation

```go
func Parse(layout, value string) (Time, error)
```

Layout 时间格式，value时间值，解析时间返回time

```go
func main() {
	t, _ := time.Parse("2006-01-02", "2020-12-05")
	fmt.Println(t)
 m, _ := time.Parse("2006-01-02 15:04:05", "2020-12-05 11:23:08")
	fmt.Println(m)
}
// 2020-12-05 00:00:00 +0000 UTC
// 2020-12-05 11:23:00 +0000 UTC
```

上面的用法其实是错误的，没有时区，正确的做法是：

```go
func main() {
	t, _ := time.ParseInLocation("2006-01-02", "2020-12-05")
	fmt.Println(t)
 m, _ := time.ParseInLocation("2006-01-02 15:04:05", "2020-12-05 11:23:08")
	fmt.Println(m)
}
// 2020-12-05 00:00:00 +0800 CST
// 2020-12-05 11:23:00 +0800 CST
```

## 时间戳 Unix

解析时间戳为time

```go
func main() {
	t := time.Unix(1576053402, 100000000)
	fmt.Print(t)
}
// 2019-12-11 16:36:42.01 +0800 CST
```

## 格式化 Format

时间格式化

默认输出格式：`2006-01-02 15:04:05.999999999 -0700 MST`

```go
func main() {
	fmt.Printf("当前时间: %s\n", time.Now())
	fmt.Printf("RFC1123Z: %s\n", time.Now().Format(time.RFC1123Z))
	fmt.Printf("RFC3339: %s\n", time.Now().Format(time.RFC3339))
}

// 当前时间: 2019-12-11 16:25:53.987141 +0800 CST m=+0.000513629
// RFC1123Z: Wed, 11 Dec 2019 16:25:53 +0800
// RFC3339: 2019-12-11T16:25:53+08:00
```

## 时间加减 Add

当前时间加上 ？

```go
func main() {
	start := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
	afterTenSeconds := start.Add(time.Second * 10)
	afterTenMinutes := start.Add(time.Minute * 10)
	afterTenHours := start.Add(time.Hour * 10)
	afterTenDays := start.Add(time.Hour * 24 * 10)

	fmt.Printf("start = %v\n", start)
	fmt.Printf("start.Add(time.Second * 10) = %v\n", afterTenSeconds)
	fmt.Printf("start.Add(time.Minute * 10) = %v\n", afterTenMinutes)
	fmt.Printf("start.Add(time.Hour * 10) = %v\n", afterTenHours)
	fmt.Printf("start.Add(time.Hour * 24 * 10) = %v\n", afterTenDays)
}
```

## 判断时间是否相等 Equal

判断两个时间是否一致

```go
func main() {
	secondsEastOfUTC := int((8 * time.Hour).Seconds())
	beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)

	// Unlike the equal operator, Equal is aware that d1 and d2 are the
	// same instant but in different time zones.
	d1 := time.Date(2000, 2, 1, 12, 30, 0, 0, time.UTC)
	d2 := time.Date(2000, 2, 1, 20, 30, 0, 0, beijing)

	datesEqualUsingEqualOperator := d1 == d2
	datesEqualUsingFunction := d1.Equal(d2)

	fmt.Printf("datesEqualUsingEqualOperator = %v\n", datesEqualUsingEqualOperator)
	fmt.Printf("datesEqualUsingFunction = %v\n", datesEqualUsingFunction)
}
```

## Before/After

判断时间A是否在时间B之前还是之后，返回bool

```go
func main() {
	a := time.Now()
	b := time.Now()

	fmt.Printf("a 在 b 之前: %v\n", a.Before(b))
	fmt.Printf("a 在 b 之后: %v\n", a.After(b))
}

// a 在 b 之前: true
// a 在 b 之后: false
```

## 时间四舍五入 Round

时间4舍5入

```go
func main() {
	t := time.Date(0, 0, 0, 12, 15, 30, 918273645, time.UTC)
	round := []time.Duration{
		time.Nanosecond,
		time.Microsecond,
		time.Millisecond,
		time.Second,
		2 * time.Second,
		time.Minute,
		10 * time.Minute,
		time.Hour,
	}

	for _, d := range round {
		fmt.Printf("t.Round(%6s) = %s\n", d, t.Round(d).Format("15:04:05.999999999"))
	}
}
```

## 舍去 Truncate

```go
func main() {
	t, _ := time.Parse("2006 Jan 02 15:04:05", "2012 Dec 07 12:15:30.918273645")
	trunc := []time.Duration{
		time.Nanosecond,
		time.Microsecond,
		time.Millisecond,
		time.Second,
		2 * time.Second,
		time.Minute,
		10 * time.Minute,
	}

	for _, d := range trunc {
		fmt.Printf("t.Truncate(%5s) = %s\n", d, t.Truncate(d).Format("15:04:05.999999999"))
	}
	// To round to the last midnight in the local timezone, create a new Date.
	midnight := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local)
	_ = midnight
}
```

# 定时器 Tick 

```go
func statusUpdate() string { return "" }

func main() {
	c := time.Tick(5 * time.Second)
	for now := range c {
		fmt.Printf("%v %s\n", now, statusUpdate())
	}
}
```