Golang整理

最新推荐文章于 2023-01-29 20:32:42 发布
最新推荐文章于 2023-01-29 20:32:42 发布
阅读量98 收藏
点赞数
分类专栏： Golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tony10010/article/details/115162169
版权

1. go struct能不能比较

  • 如果结构体的所有成员变量都是可比较的，那么结构体就可比较
  • 如果结构体中存在不可比较的成员变量，那么结构体就不能比较
  • 结构体之间能进行强制转换也可以比较。结构体之间进行转换需要他们具备完全相同的成员(字段名、字段类型、字段个数)
  • 指针比较实际上是比较指针指向的内存地址，而不是指针变量的内存地址
package main
import "fmt"
type Student struct {
	Name string
	Age  int
	Slice []int
	Map map[string]int
}
func main() {
	s1 := Student{
		Name:  "s1",
		Age:   20,
		Slice: []int{1,2,3},
		Map: map[string]int{"1": 1, "2": 2},
	}
	s2 := Student{
		Name:  "s1",
		Age:   20,
		Slice: []int{1,2,3},
		Map: map[string]int{"1": 1, "2": 2},
	}
	fmt.Println(s1 != s2) // 不能比较，因为结构体包含不可比较类型
}

package main
import "fmt"
type Student struct {
	Name string
	Age  int
}
func main() {
	s1 := Student{
		Name: "s1",
		Age:  20,
	}
	s2 := Student{
		Name: "s1",
		Age:  20,
	}
	fmt.Println(s1 == s2) // true
}

package main
import "fmt"
type Student struct {
	Name string
	Age  int
}
type Driver struct {
	Name string
	Age  int
}
func main() {
	s1 := Student{
		Name: "s1",
		Age:  20,
	}
	d1 := Driver{
		Name: "s1",
		Age:  20,
	}
	// fmt.Println(s1 == d1) // 报错
	fmt.Println(s1 == Student(d1)) // 可以比较
}

2. go defer

  • 延迟函数的参数在defer语句出现时就已经确定下来了
  • 延迟函数可能操作主函数的具名返回值
  • 延迟函数执行按后进先出顺序执行，即先出现的defer最后执行
package main
import "fmt"
func main(){
	a := 1
	b := 2
	defer calc(a, calc(a,b))
	a = 0
	defer calc(a, calc(a,b))
}
func calc(x,y int) int {
	fmt.Println(x,y,x+y)
	return x+y
}

package main
import "fmt"
func main()  {
	defer func() {fmt.Println(1)}()
	defer func() {fmt.Println(2)}()
	defer func() {fmt.Println(3)}()
	panic(1) // 程序发生panic 会先处理defer然后panic
}

package main
import "fmt"
func printArray(array *[3]int) {
	for i := range array {
		fmt.Println(array[i])
	}
}
func deferFuncParameter() {
	var aArray = [3]int{1, 2, 3}
	defer printArray(&aArray)
	aArray[0] = 10
	return
}
func main() {
	deferFuncParameter() // 10 2 3
}

3. go select

  • select就是用来监听和channel有关的IO操作，当 IO 操作发生时，触发相应的动作
  • 如果有一个或多个IO操作可以完成，则Go运行时系统会随机的选择一个执行（底层是打乱顺序，然后遍历每个channel，遇到第一个就return）
  • 执行default分支语句，如果连default都没有，则select语句会一直阻塞，直到至少有一个IO操作可以进行
  • 每个case都会被计算一遍
  • 可以使用break结束一次case的执行
package main
import "fmt"
var ch1 chan int
var ch2 chan int
var chs = []chan int{ch1, ch2}
var numbers = []int{1, 2, 3, 4, 5}
func main () {
	select {
	case getChan(0) <- getNumber(2):
		fmt.Println("1th case is selected.")
	case getChan(1) <- getNumber(3):
		fmt.Println("2th case is selected.")
	default:
		fmt.Println("default!.")
	}
}
func getNumber(i int) int {
	fmt.Printf("numbers[%d]\n", i)
	return numbers[i]
}
func getChan(i int) chan int {
	fmt.Printf("chs[%d]\n", i)
	return chs[i]
}
select走的是default，但是每个case都会被计算一次
chs[0]
numbers[2]
chs[1]
numbers[3]
default!.

package main
import "fmt"
func main()  {
	ch1 := make(chan int, 1)
	ch2 := make(chan int, 1)
	ch1 <- 3
	ch2 <- 5
	select {
	case <- ch1:
		fmt.Println("ch1 selected.")
		break
		fmt.Println("ch1 selected after break")
	case <- ch2:
		fmt.Println("ch2 selected.")
		fmt.Println("ch2 selected without break")
	}
}

4. go context 用途

  • 上下文，追踪goroutine，控制goroutine停止，包含 goroutine 的运行状态、环境、现场等信息
  • context.WithDeadline()
  • context.WithValue()
  • context.WithTimeout()
  • context.WithCancel()

5. 主协程等待其余协程执行完后退出

  • 使用channel
package main

import "fmt"

var ch = make(chan int)
func person1() {
	fmt.Println("person1")
	ch <- 1
}
func person2() {
	fmt.Println("person2")
	ch <- 2
}
func main() {
	go person1()
	go person2()
	count := 2
	// 判断所有协程是否退出
	for range ch {
		count--
		if 0 == count {
			close(ch)
		}
	}
	fmt.Println("main goroutine finished")
}
  • 使用sync.WaitGroup
package main
import (
	"fmt"
	"runtime"
	"sync"
)
var wg = sync.WaitGroup{}
func main()  {
	fmt.Println("main goroutine start...")
	wg.Add(2)
	runtime.GOMAXPROCS(1)
	for i := 0; i < 2; i++{
		go func(i int) {
			fmt.Println(i)
			wg.Done()
		}(i)
	}
	wg.Wait()
	fmt.Println("main goroutine finished...")
}
  • 使用select
package main
import (
	"fmt"
	"time"
)
func main()  {
	fmt.Println("main goroutine start...")
	ch := make(chan int)
	go func() {
		fmt.Println("sub goroutine running")
		time.Sleep(time.Second * 2)
		ch <- 1
		fmt.Println("sub goroutine finished")
	}()
	select {
	case <- ch:
		fmt.Println("main goroutine finished...")
	}
}
  • 使用context
package main
import (
	"context"
	"fmt"
	"time"
)
func main()  {
	fmt.Println("main goroutine start...")
	ctx, cancel := context.WithTimeout(context.Background(), time.Second * 3)
	go func() {
		for{
			select {
			case <-ctx.Done():
				fmt.Println("select ctx done")
			default:
				time.Sleep(time.Millisecond * 100)
				fmt.Println("select default")
			}
		}
	}()
	time.Sleep(time.Second * 1)
	cancel()
	fmt.Println("main goroutine finished...")
}

6. map顺序读取

  • map本无法顺序读取
  • 先遍历所有的key，然后对key排序后，按顺序取出value
package main
import (
	"fmt"
	"sort"
)
func main() {
	hash := map[string]int{
		"jerry":   10,
		"tom":     2,
		"panghu":  39,
		"xiaofu":  30,
		"daxiong": 40,
	}
	keys, i := make([]string, len(hash)), 0
	for key, _ := range hash {
		keys[i] = key
		i++
	}
	sort.Strings(keys)
	for _, key := range keys {
		fmt.Println(key, hash[key])
	}
}

7. slice，len，cap，共享，扩容

  • slice 底层结构
    • 指向数组的指针
    • 长度
    • 容量
  • slice扩容
    • 长度小于1024 每次容量翻倍
    • 大于1024 每次 涨25%
package main
import "fmt"
func main() {
	a := make([]int, 2, 2)
	a[0], a[1] = 1, 2
	b := append(a[0:1], 3)
	c := append(a[1:2], 4)
	fmt.Println(b, c) // [1，3],[3, 4] c赋值时底层数组已经发生变化了
}

package main
import "fmt"
func main() {
	a := make([]int, 2, 2)
	a[0], a[1] = 1, 2
	b := make([]int, 1)
	copy(b, a[0: 1])
	b = append(b, 3)

	c := make([]int, 1)
	copy(c, a[1:2])
	c = append(c, 4)
	fmt.Println(b, c) // [1,3], [2,4]
}

8. go copy函数

  • 目标数组长度不足拷贝长度时，只拷贝目标数组长度
  • 两个数组切片不一样大，就会按其中较小的那个数组切片的元素个数进行复制

9. go 实现集合

package main

import (
	"fmt"
	"sync"
)

type Set struct {
	set map[string]struct{}
	lock sync.Mutex
}

func (s *Set) AddElem(elem string) {
	s.lock.Lock()
	defer s.lock.Unlock()
	s.set[elem] = struct{}{}
}

func (s *Set) RemoveElem(elem string) {
	s.lock.Lock()
	defer s.lock.Unlock()
	delete(s.set, elem)
}

func (s *Set) Smembers() []string {
	members, i := make([]string, len(s.set)), 0
	for key, _ := range s.set {
		members[i] = key
		i++
	}
	return members
}

func (s *Set) Size() int {
	return len(s.set)
}

func main() {
	s := Set{set: map[string]struct{}{}}
	s.AddElem("111")
	s.AddElem("222")
	fmt.Println(s.Smembers())
	s.RemoveElem("222")
	fmt.Println(s.Smembers())
}

10. golang 实现消息队列

  • 通过切片简单实现
package main
import (
	"errors"
	"fmt"
	"sync"
	"time"
)
type MsgQueue struct {
	queue []int
	lock  sync.Mutex
}
func (q *MsgQueue) AddMsg(i int) {
	q.lock.Lock()
	defer q.lock.Unlock()
	q.queue = append(q.queue, i)
}
func (q *MsgQueue) GetMsg() (int, error) {
	q.lock.Lock()
	defer q.lock.Unlock()
	if len(q.queue) == 0 {
		return 0, errors.New("queue blank")
	}
	msg := q.queue[0]
	q.queue = q.queue[1:]
	return msg, nil
}
func main() {
	q := MsgQueue{queue: []int{}}
	for i := 0; i < 100; i++ {
		go func(i int) {
			q.AddMsg(i)
		}(i)
	}
	for {
		fmt.Println(q.GetMsg())
		time.Sleep(100 * time.Millisecond)
	}
}

11. Go大文件排序

  • 思路
    • 大文件分隔成小文件，然后排序写入小文件
    • 打开所有排好序的小文件，每次取出最小的一个
蜗牛你慢点Ⅷ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解golang碎片整理之 fmt.Scan
09-19
本文介绍了从golang语言中fmt包从标准输入获取数据的Scan系列函数、从io.Reader中获取数据的Fscan系列函数以及从字符串中获取数据的Sscan系列函数的用法，感兴趣的小伙伴们可以参考一下
golang 八股文整理
最新发布
trinityleo5的博客
10-22 1053
golang 八股文整理
Golang面试题整理
wudean0910的博客
11-22 3008
1、= 和 := 的区别？ := 声明+赋值 = 仅赋值 2、指针的作用？ 指针用来保存变量的地址。 * 运算符，也称为解引用运算符，用于访问地址中的值。 ＆运算符，也称为地址运算符，用于返回变量的地址。 3、Go 允许多个返回值吗？ 允许 4、 Go 有异常类型吗？ Go 没有异常类型，只有错误类型（Error），通常使用返回值来表示异常状态。 5、什么是协程（Goroutine） Goroutine 是与其他函数或方法同时运行的函数或方法。 Goroutines 可
Golang基础知识点整理
Mr_XiMu的博客
08-08 1737
Golang基础知识点整理
golang面试整理
akspusd的专栏
01-29 106
知乎上面有帖子比较全面，学习下。
golang学习资源整理
人生代码 ---- 公众号
06-27 503
golang学习资源整理
学习Golang编程实例精选
02-13
收集整理了Golang的主要编程领域，帮助大家特别是Java程序员快速掌握Golang编程
golang基础.ppt
01-20
整理golang语法基础： 数据类型 变量定义 控制结构 函数function 结构体struct 面向对象 接口interface 恐慌panic和恢复recover 并发goroutine和channel Import和package main,init,test 指针和内存分配(new和make)
Go 语言优秀资源整理，为项目落地加速:person_running:-Golang开发
05-26
Go 语言优秀资源整理，为项目落地加速:person_running: go-awesome Go 语言优秀资源整理，为项目落地加速 :person_running: 在 GitHub 上稳定更新，觉得不错请点个 Star :red_heart: 如转载分享，请保留出处，...
golang语言基础.xmind
09-04
自己整理的go语言基础脑图，方便阅读、更改。 目前只包含基础部分，适合新手阅读，可在学习的同时继续完善。
一个grpcServer实现多个proto文件
Tony10010的博客
02-24 2824
一个GRPCServer实现多个proto文件 多个proto文件定义在同一个package包中 每个proto文件中的service不相同（多个接口） 注册GRPCServer的结构体需要实现多个proto文件中定义的接口的方法 注册GRPCServer时需要调用每个pb.go文件中的RegisterXXXXServer方法 举例 第一个proto文件 syntax = "proto3"; package api; service Decision { rpc Decision(Decis
Golang随机睡眠
Tony10010的博客
01-16 2613
func main() { s := rand.Intn(100) fmt.Println(s) time.Sleep(time.Second * time.Duration(s)) fmt.Println("finish") }
Golang panic后获取返回值
Tony10010的博客
01-16 1586
宕机后的所有语句不会执行，但是会执行宕机前的defer语句，recover 捕获宕机错误 package main import "fmt" func main() { defer fmt.Println("1111") defer func() { err := recover() fmt.Print...
Golang 通过字符串调用方法
Tony10010的博客
03-22 1141
package main import ( "fmt" "reflect" ) type Student struct { } func (s *Student) Listen() { fmt.Println("listen") } func main() { student := Student{} value := reflect.ValueOf(&student) f := value.MethodByName("Listen") f.Call([]reflect.Val
Golang列表操作
Tony10010的博客
01-16 949
package main import "container/list" import "fmt" func main() { l := list.New() // 创建列表 fmt.Println(l) l.PushBack("fist") //在列表尾部插入 l.PushFront(67) // 列表头部插入 ...
Golang Map为什么是无序的
Tony10010的博客
04-02 835
Map无序 底层数据 哈希表，本就是无序的， 正常写入(非哈希冲突写入)：是hash到某一个bucket上，而不是按buckets顺序写入 哈希冲突写入：如果存在hash冲突，会写到同一个bucket上。 range遍历的时候随机一个位置开始 Map扩容 成倍扩容： (元素数量/bucket数量) > 6.5时触发成倍扩容，元素顺序变化 等量扩容：溢出桶的数量大于等于 2*B时 触发等量扩容，不会改变元素顺序 参考文章 为什么说Go的Map是无序的？ ...
Golang runtime运行时
Tony10010的博客
02-24 491
NumCPU NumGoroutine GOOS func runtimeInfo() { runtime.GOMAXPROCS(1) fmt.Println(runtime.NumCPU()) // 返回当前cpu核心数 fmt.Println(runtime.NumGoroutine()) // 返回正在执行和排队的任务数 fmt.Println(runtime.GOOS) // 返回当前操作系统 } Gosched func runtimeGosched() {
Golang pprof 工具使用
Tony10010的博客
03-30 471
Golang pprof分析工具使用 1. 概述 go的pprof工具可以用来监测进程的运行数据，用于监控程序的性能，对内存使用和CPU使用的情况统信息进行分析。 官方提供了两个包：runtime/pprof和net/http/pprof，前者用于普通代码的性能分析，后者用于web服务器的性能分析 2. runtime/pprof的使用 该包提供了一系列用于调试信息的方法，可以很方便的对堆栈进行调试 StartCPUProfile：开始监控cpu。 StopCPUProfile：停止监控cpu，使用Sta
golang 文件写 入门
Tony10010的博客
03-06 410
ioutil os.OpenFile 记得写完内容后 file.Sync() bufio.NewWriter 写完内容后 writer.Flush() const ( // O_RDONLY, O_WRONLY, or O_RDWR 必须指定 O_RDONLY int = syscall.O_RDONLY // 只读 O_WRONLY int = syscall.O_WRONLY // ...
golang八股文整理
09-13
下面是一份简单的整理： 1. Golang的特点：静态类型、垃圾回收、并发模型、内存安全、编译型语言等。 2. Golang中的基本数据类型：整型、浮点型、布尔型、字符串、数组、切片、映射、结构体等。 3. Golang中的控制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值