分类 Golang 中的文章

Golang|context

 | Golang

context意义

Go 中的 context 包在与 API 和慢处理交互时可以派上用场，特别是在生产级的 Web 服务中。在这些场景中，您可能想要通知所有的 goroutine 停止运行并返回。

context使用

context相关函数

1
2
3
4
5
6
7
8

//返回一个空 context， 这只能用于高等级（在 main 或顶级请求中），作为context的根节点
context.Background() Context
//返回一个空的 context，不知道用什么的时候就上这个
context.TODO() Context
context.WithValue(parent Context, key, val interface{}) (ctx Context, cancel CancelFunc)
context.WithCancel(parent Context) (ctx Context, cancel CancelFunc)
context.WithDeadline(parent Context, d time.Time) (ctx Context, cancel CancelFunc)
context.WithTimeout(parent Context, timeout time.Duration) (ctx Context, cancel CancelFunc)

context相关使用

Done方法取消

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func Stream(ctx context.Context, out chan<- Value) error {
	for {
		v, err := DoSomething(ctx)
		if err != nil {
			return err
		}
		select {
		case <-ctx.Done():
			return ctx.Err()
		case out <- v:
		}
	}
}

WithValue传值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	valueCtx := context.WithValue(ctx, key, "add value")
	go watch(valueCtx)
	time.Sleep(10 * time.Second)
	cancel()
	time.Sleep(5 * time.Second)
}

func watch(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			//get value
			fmt.Println(ctx.Value(key), "is cancel")
			return
		default:
			//get value
			fmt.Println(ctx.Value(key), "int goroutine")
			time.Sleep(2 * time.Second)
		}
	}
}

WithTimeout超时取消

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package main

import (
	"fmt"
	"golang.org/x/net/context"
	"sync"
	"time"
)

var (
	wg sync.WaitGroup
)

func work(ctx context.Context) error {
	defer wg.Done()
	for i := 0; i < 1000; i++ {
		select {
		case <-time.After(2 * time.Second):
			fmt.Println("Doing some work ", i)
		// we received the signal of cancelation in this channel
		case <-ctx.Done():
			fmt.Println("Cancel the context ", i)
			return ctx.Err()
		}
	}
	return nil
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second)
	defer cancel()
	fmt.Println("Hey, I'm going to do some work")
	wg.Add(1)
	go work(ctx)
	wg.Wait()
	fmt.Println("Finished. I'm going home")
}

WithDeadline截止时间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	d := time.Now().Add(1 * time.Second)
	ctx, cancel := context.WithDeadline(context.Background(), d)
	defer cancel()
	select {
	case <-time.After(2 * time.Second):
		fmt.Println("oversleep")
	case <-ctx.Done():
		fmt.Println(ctx.Err())
	}
}

参考

  1. 理解 golang 中的 context（上下文）包
  2. Golang Context分析
  3. Go语言实战笔记（二十）Go Context
……

阅读全文

Golang|channel

 | Golang

channel结构体

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

type hchan struct {
	qcount   uint           //大小
	dataqsiz uint           //有缓存的队列大小
	buf      unsafe.Pointer //有缓存的循环队列指针
	elemsize uint16
	closed   uint32
	elemtype *_type //类型
	sendx    uint   //有缓存的可发送下标
	recvx    uint   //有缓存的可存储下标
	recvq    waitq  //接受的goroutine抽象出来的结构体sudog的队列，是一个双向链表
	sendq    waitq  //同上，是发送的相关链表
	lock     mutex  //互斥锁
}
type waitq struct {
	first *sudog
	last  *sudog
}

channel创建

1

ch := make(chan int, 3)

创建channel实际上就是在内存中实例化了一个hchan的结构体，并返回一个ch指针，我们使用过程中channel在函数之间的传递都是用的这个指针，这就是为什么函数传递中无需使用channel的指针，而直接用channel就行了，因为channel本身就是一个指针。

……

阅读全文

golang|内存分配

 | Golang

内存分配

GO语言内存管理子系统主要由两部分组成：内存分配器和垃圾回收器（gc）。内存分配器主要解决小对象的分配管理和多线程的内存分配问题。

Golang运行时的内存分配算法主要源自 Google 为 C 语言开发的TCMalloc算法，全称Thread-Caching Malloc。核心思想就是把内存分为多级管理，从而降低锁的粒度。它将可用的堆内存采用二级分配的方式进行管理：每个线程都会自行维护一个独立的内存池，进行内存分配时优先从该内存池中分配，当内存池不足时才会向全局内存池申请，以避免不同线程对全局内存池的频繁竞争。

……

阅读全文

Golang|MPG

 | Golang

并行和并发

并发(concurrency)

两个或两个以上的任务在一段时间内被执行。例如跑步的时候，停下来系鞋带

并行(parallelism)

两个或两个以上的任务在同一时刻被同时执行。例如跑步的时候，边跑边听歌

线程模型

从线程讲起，无论语言层面何种并发模型，到了操作系统层面，一定是以线程的形态存在的。而操作系统根据资源访问权限的不同，体系架构可分为用户空间和内核空间；内核空间主要操作访问CPU资源、I/O资源、内存资源等硬件资源，为上层应用程序提供最基本的基础资源，用户空间呢就是上层应用程序的固定活动空间，用户空间不可以直接访问资源，必须通过系统调用、库函数或Shell脚本,来调用内核空间提供的资源。

……

阅读全文

golang|基础笔记

 | Golang

go课程

本文阅读课程来源见此go系列教程

变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

//声明方式一
//var name type
var age int
age = 25
//声明并初始化
var age int = 25
//让go类型推断
var age = 25
//声明多个变量，注意变量不能重复定义
var width, heigth int = 210, 220
//简短声明
age := 25
//简短声明多变量，
age, name := 25,"wengwei"
//注意多变量声明不能完全重复
age, name := 25,"wengwei"
age, name := 26,"wengwei"
//上面定义会报错
age, name := 25,"wengwei"
age, name2 := 26,"wengwei"
//上面定义不会报错

类型

go支持一下几类基本类型

……

阅读全文

Golang|map

 | Golang

map

由<key,value>对组成的抽象数据结构，并且同一个key只出现一次

实现对比

方法 | hash | 搜索树 -|-|- 复杂度 | O(1) | O(logN) 顺序 | 乱序 | 有序 痛点 | 碰撞问题 | 平衡问题

源码位置

1
2
3
4
5
6
7

//main.go
package main

func main() {
	m := make(map[int]int)
	m[2] = 2
}

上面代码通过以下指令查看汇编语句 go tool compile -S main.go

……

阅读全文

  1. 1
  2. 2
  3. 3