Golang常用包使用介绍_开发_开发者_运维开发者技术经验分享

sync包

常用的有3个功能

锁

锁分为普通互斥锁和读写锁

互斥锁 Mutex	读写锁 RWMutex
一个线程未释放锁时，其他线程加锁阻塞	读锁：一个线程未释放读锁时，其他线程可获取读锁，获取写锁阻塞写锁：一个线程未释放写锁时，其他线程可获取读锁或写锁都会阻塞

线程监听WaitGroup

使用场景：用于监听一组子线程是否执行完毕

使用流程	代码
建立监听对象	wg := new(sync.WaitGroup)
创建多个子线程并计入计数器	go func1(wg) wg.Add(1) go func2(wg) wg.Add(1)
线程子线程执行完毕后，减少计数器值	func1(wg){wg.Done()}
监听计数器值，直到计数器值为0时，执行后面的代码	wg.Wait()

池Pool

用于存放每次请求都需要实例化，且生命周期较长的对象，以减轻垃圾回收压力。

使用流程	代码
建立一个池	RequestPool = sync.Pool{New: func() interface{} {return &RequestHeader{}}}
从池中取一个对象	RequestPool .Get()
把对象放回池中	RequestPool .Put(RequestHeader) 把对象放入池之前，需要把对象中所有值都初始化

encoding/binary包

主要用来把数字转换为字节类型

单数值转换

//序列化
    var dataA uint64=6010
    var buffer bytes.Buffer
    err1 := binary.Write(&buffer, binary.BigEndian, &dataA)
    if err1!=nil{
        log.Panic(err1)
    }
    byteA:=buffer.Bytes()
    fmt.Println("序列化后：",byteA)
    //反序列化
    var dataB uint64
    var byteB []byte=byteA
    err2:=binary.Read(bytes.Ne编程wReader(byteB),binary.BigEndian,&dataB)
    if err2!=nil{
        log.Panic(err2)
    }
    fmt.Println("反序列化后：",dataB)

其中的BigEndian和LittleEndian 指定了转换的方式是大端字节序，开发者_Go教程还是小端字节序。

所谓大端和小端节序，是指不同cpu再把数据流转换为字节时，排位位置的不同，如下

Golang常用包使用介绍

若不同计算机程序之间使用了不同节序处理同一组数据，就会造成无法解析的情况

多数值转换

指把多个数字转换到一个byte切片中

首先定义一个定长切片 s := make([]byte,10)

首先要确定转换的节序，也可以跳过该步骤

binary.LittleEndian.PutUhttp://www.devze.comint16(s, uint16(0))

确定完之后，就可以向s中插入数字了

start := 0
start += binary.PutUvarint(b[2:], 1198)

插入数字到切片后，会返回该数字在切片中占用的长度

若切片空间不够，则返报错

所以我们最好确定往切片中插入数字的个数，并估算每个数字占用最大占用长度

解析切片中的某个数字，要知道该数字在切片中占用的起始位置，若位置不对则无法解析出正确的数字，返回0

i,err := binary.ReadUvarint(bytes.NewReader(b[2:]))
if err==nil{
   fmt.Println(i)
}else{
   fmt.Println(err.Error())
}

切片中可以插入字符串，转换为数字时，只要能够从正确的位置开始解js析，就会解析出正确的数字

encoding/gob包

是一个golang专属的数据序列化工具，用于序列化和反序列化数据，作用类似于json

不同的是，在反序列化时，需要有一个指定格式的变量接收值。该变量类型需要与序列化时数据类型兼容，否则反序列化失败

	type S struct{
		Field1 string
		Field2 int
    }
	func main() {
		s1 := &S{
			Field1: "Hello Gob",
			Field2: 999,
		}
		log.Println("Original value:", s1)
		buf := new(bytes.Buffer)
		err := gob.NewEncoder(buf).Encode(s1)
		if err != nil {
			log.Println("Encode:", err)
			return
		}
		s2 := &S{}
		err = gob.NewDecoder(buf).Decode(s2)
		if err != nil {
			log.Println("Decode:", err)
			retu编程客栈rn
		}
		log.Println("Decoded value:", s2)
	}

简单的数据可以使用上面代码直接加密和解密

但是当需要解密的数据是接口类型时，由于接口的特殊性，实现了接口中方法的变量可以作为值代替该方法，这导致gob不知道接口中数据的具体类型，会解密失败，如下

type Getter interface {
    Get() string
}
type Foo struct {
    Bar string
}
func (f Foo)Get() string {
    return f.Bar
}
buf := bytes.NewBuffer(nil)
// 创建一个接口变量
//接口中原值是一个get方法，因为Foo实现了get方法，所以可以最为值代替Get
g := Getter(Foo{"wazzup"})
// gob解密g时，认为g中的值是Get() 类型，但其实是Foo类型，就会报错
enc := gob.NewEncoder(buf)
enc.Encode(&g)

解决这个问题的方法就是在代码初始化时，使用 gob.Register()方法注册Foo变量

当gob解码是发现类型不对应，会从已注册的类型中查找