Go语言开发（十三）、Go语言常用标准库三

Go语言开发（十三）、 Go 语言常用标准库三

一、sync

1、sync简介

sync提供基本的同步原语，如sync.Mutex，sync.RWMutex，sync.Once，sync.Cond，sync.Waitgroup，除了Once和WaitGroup类型外，大多数类型都供低级库使用。Go语言中，不要通过共享内存通信，而要通过通信共享内存，通过Channel和沟通可以更好地完成更高级别的同步。

type Locker interface {
   Lock()
   Unlock()
}

Locker提供了锁的两个操作方法，Lock、Unlock。

2、sync.Mutex

sync.Mutex是互斥锁，是Locker的一种实现。

一个互斥锁只能同时被一个goroutine锁定，其它goroutine将阻塞直到互斥锁被解锁（重新争抢对互斥锁的锁定）。

sync.Mutex使用注意：

（1）在首次使用后不要复制互斥锁。

（2）对一个未锁定的互斥锁解锁将会产生运行时错误。

使用示例：

package main

import (
   "fmt"
   "sync"
   "time"
)

var locker sync.Mutex

func mutexDemo() {
   var value int = 0
   for i := 0; i < 100; i++ {
      go func(i int) {
         locker.Lock()
         defer locker.Unlock()
         fmt.Printf("Goroutine %d : value: %d\n", i, value)
         value++
      }(i)
   }
}
func main() {
   mutexDemo()
   time.Sleep(time.Second)
}

3、sync.Pool

sync.Pool 临时对象池用于存储临时对象，将使用完毕的对象存入对象池中，在需要的时候取出来重复使用，目的是为了避免重复创建相同的对象造成GC负担过重。如果对象不再被其它变量引用，存放的临时对象可能会被GC回收掉。

type Pool struct {
   // 创建临时对象的函数
   New func() interface{}
}

// 向临时对象池中存入对象
func (p *Pool) Put(x interface{})

// 从临时对象池中取出对象
func (p *Pool) Get() interface{}

从sync.Pool中取出对象时，如果Pool中没有对象，将返回nil，但如果给 Pool.New字段指定一个函数，Pool将使用指定函数创建一个新对象返回。

sync.Pool可以安全的在多个goroutine中并行使用，但并不适用于所有空闲对象，应该用来管理并发的例程共享的临时对象，而不应该管理短寿命对象中的临时对象。

sync.Pool使用示例如下：

package main

import (
   "bytes"
   "io"
   "os"
   "sync"
   "time"
)

var bufPool = sync.Pool{
   New: func() interface{} {
      return new(bytes.Buffer)
   },
}

func Log(w io.Writer, key, val string) {
   // 获取临时对象，没有则自动创建
   b := bufPool.Get().(*bytes.Buffer)
   b.Reset()
   b.WriteString(time.Now().Format(time.RFC3339))
   b.WriteByte(' ')
   b.WriteString(key)
   b.WriteByte('=')
   b.WriteString(val)
   w.Write(b.Bytes())
   // 将临时对象放回到Pool中
   bufPool.Put(b)
}

func main() {
   Log(os.Stdout, "key", "value")
}

// output:
// 2018-12-31T15:57:27+08:00 key=value

4、sync.Once

sync.Once可以使得函数多次调用只执行一次。

type Once struct {
   m    Mutex
   done uint32
}
func (o *Once) Do(f func())

用done来记录执行次数，用互斥锁m来保证仅被执行一次。只有一个Do方法，调用执行。

利用sync.Once实现单例模式代码如下：

package Singleton

import (
   "sync"
)

type Singleton map[string]string

var (
   instance Singleton
   once sync.Once
)

func New() Singleton{
   once.Do(func() {
      instance = make(Singleton)
   })
   return instance
}

使用示例如下：

package main

import (
   "fmt"
   "DesignPattern/Singleton"
)

func main() {
   instance1 := Singleton.New()
   instance1["name"] = "Jack Bauer"
   instance2 := Singleton.New()
   fmt.Println("My name is", instance2["name"])
}
// output:
// My name is Jack Bauer

5、sync.RWMutex

sync.RWMutex是针对读写操作的互斥锁，读写锁与互斥锁最大的不同就是可以分别对读、写进行锁定。一般用在大量读操作、少量写操作的情况。sync.RWMutex提供四种操作方法：

func (rw *RWMutex) Lock()
func (rw *RWMutex) Unlock()

func (rw *RWMutex) RLock()
func (rw *RWMutex) RUnlock()

RLock对读操作进行锁定，RUnlock对读锁定进行解锁，Lock对写操作进行锁定，Unlock对写锁定进行解锁。

sync.RWMutex锁定规则如下：

（1）同时只能有一个goroutine能够获得写锁定。

（2）同时可以有任意多个gorouinte获得读锁定。

（3）同时只能存在写锁定或读锁定（读和写互斥）。

（4）当有一个goroutine获得写锁定，其它无论是读锁定还是写锁定都将阻塞直到写解锁；当有一个goroutine获得读锁定，其它读锁定任然可以继续；当有一个或任意多个读锁定，写锁定将等待所有读锁定解锁后才能够进行写锁定。

sync.RWMutex读写锁使用注意：

（1）在首次使用之后，不要复制读写锁。

（2）不要混用锁定和解锁，如：Lock和RUnlock、RLock和Unlock。对未读锁定的读写锁进行读解锁或对未写锁定的读写锁进行写解锁将会引起运行时错误。

使用示例代码：

package main

import (
   "fmt"
   "sync"
   "time"
)

var rw sync.RWMutex

func RWMutexDemo() {
   var value int = 0
   for i := 0; i < 10; i++ {
      go func(i int) {
         rw.Lock()
         defer rw.Unlock()
         fmt.Printf("Goroutine %d : Write value: %d\n", i, value)
         value++
      }(i)
      go func(i int) {
         rw.RLock()
         defer rw.RUnlock()
         fmt.Printf("Goroutine %d : Read value: %d\n", i, value)
      }(i)

   }
}
func main() {
   RWMutexDemo()
   time.Sleep(time.Minute)
}

6、sync.WaitGroup

sync.WaitGroup用于等待一组goroutine结束。

sync.WaitGroup操作方法如下：

func (wg *WaitGroup) Add(delta int)
func (wg *WaitGroup) Done()
func (wg *WaitGroup) Wait()

Add用来添加goroutine的个数。Done执行一次数量减1。Wait用来等待结束。

sync.WaitGroup使用示例如下：

package main

import (
   "fmt"
   "sync"
)

var wg sync.WaitGroup

func WaitGroupDemo() {
   var value int = 0
   for i := 0; i < 10; i++ {
      wg.Add(1)
      go func(i int) {
         defer wg.Done()
         fmt.Printf("Goroutine %d : Write value: %d\n", i, value)
         value++

      }(i)
      wg.Add(1)
      go func(i int) {
         defer wg.Done()
         fmt.Printf("Goroutine %d : Read value: %d\n", i, value)
      }(i)
   }
}

func main() {
   WaitGroupDemo()
   wg.Wait()
}

7、sync.Cond

sync.Cond实现一个条件等待变量，即等待或宣布事件发生的goroutine的会合点。

func NewCond(l Locker) *Cond
func (c *Cond) Broadcast()
func (c *Cond) Signal()
func (c *Cond) Wait()

NewCond用于根据Locker创建一个条件等待变量，Wait用于让一个goroutine等待通知，Signal用于单次发送通知让等待的goroutine继续，Broadcast用于广播通知让所有等待的goroutine继续。

sync.Cond条件等待变量实现生产者-消费者模式示例如下：

package main

import (
   "fmt"
   "math/rand"
   "sync"
   "time"
)

var locker = new(sync.Mutex)
var cond = sync.NewCond(locker)

var capacity = 10
var consumerNum = 5
var producerNum = 2

func Produce(out chan<- int) {
   for i := 0; i < producerNum; i++ {
      go func(nu int) {
         for {
            cond.L.Lock()
            for len(out) == capacity {
               fmt.Println("Capacity Full, stop Produce")
               cond.Wait()
            }
            num := rand.Intn(100)
            out <- num
            fmt.Printf("Producer %d produce: num %d\n", nu, num)
            cond.L.Unlock()
            cond.Signal()
            time.Sleep(time.Microsecond * 500)
         }
      }(i)
   }
}

func Consume(in <-chan int) {
   for i := 0; i < consumerNum; i++ {
      go func(nu int) {
         for {
            cond.L.Lock()
            for len(in) == 0 {
               fmt.Println("Capacity Empty, stop Consume")
               cond.Wait()
            }
            num := <-in
            fmt.Printf("Consumer %d: consume num %d\n", nu, num)
            cond.L.Unlock()
            time.Sleep(time.Second)
            cond.Signal()
         }
      }(i)
   }
}

func main() {
   rand.Seed(time.Now().UnixNano())

   quit := make(chan bool)
   ProductPool := make(chan int, capacity)

   Produce(ProductPool)
   Consume(ProductPool)

   <-quit
}

二、reflect

1、reflect简介

在计算机科学领域，反射是指能够自描述和自控制的应用。反射通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

每种语言的反射模型都不同，并且某些语言不支持反射。Golang语言通过reflect包实现反射机制，在运行时动态的调用对象的方法和属性。

Go语言中的变量包括（type, value）两部分，type包括static type和concrete type。static typ是编码时的类型(如int、string)，concrete type是runtime的类型。

类型断言能否成功，取决于变量的concrete type，而不是static type。因此，一个reader变量如果其concrete type实现了write方法，也可以被类型断言为writer。

Golang指定类型变量的类型是静态类型，在创建变量时类型就已经确定，因此，反射主要与Golang的interface类型相关（type是concrete type）。

在Golang的实现中，每个interface变量都有一个(value, type)对用于记录变量的实际值和类型。value是变量的实际值，type是变量的实际类型。interface类型的变量包含2个指针，一个指针指向值的类型(concrete type)，另一个指针指向实际的值(value)。

2、reflect接口

package main

import (
   "fmt"
   "reflect"
)

func main() {

   var num float64 = 3.14
   value := reflect.ValueOf(num)
   pointer := reflect.ValueOf(&num)
   fmt.Println("value: ", value.Interface().(float64))
   fmt.Println("value: ", pointer.Interface().(*float64))
   fmt.Println("type: ", reflect.TypeOf(num))
}

// output:
// value:  3.14
// value:  0xc42001e0e8
// type:  float64

对于未知原有类型，需要进行遍历探测其Filed：

package main

import (
   "fmt"
   "reflect"
)

type Student struct {
   Name string
   ID   int
   Age  int
}

func (student Student) Print() {
   fmt.Printf("%s's ID is %d, %d years.", student.Name, student.ID, student.Age)
}

func handleFieldAndMethod(input interface{}) {
   inputType := reflect.TypeOf(input)
   fmt.Println("type: ", inputType.Name())
   inputValue := reflect.ValueOf(input)
   fmt.Println("value: ", inputValue)
   // 获取方法字段
   // 1. 先获取interface的reflect.Type，然后通过NumField进行遍历
   // 2. 再通过reflect.Type的Field获取其Field
   // 3. 最后通过Field的Interface()得到对应的value
   for i := 0; i < inputType.NumField(); i++ {
      field := inputType.Field(i)
      value := inputValue.Field(i).Interface()
      fmt.Printf("%s %v %v\n", field.Name, field.Type, value)
   }
   // 获取方法
   // 1. 先获取interface的reflect.Type，然后通过.NumMethod进行遍历
   for i := 0; i < inputType.NumMethod(); i++ {
      m := inputType.Method(i)
      fmt.Printf("%s: %v\n", m.Name, m.Type)
   }
}

func main() {

   bauer := Student{"Bauer", 1, 130}
   handleFieldAndMethod(bauer)
}

// output:
// type:  Student
// value:  {Bauer 1 130}
// Name string Bauer
// ID int 1
// Age int 130
// Print: func(main.Student)

package main

import (
   "fmt"
   "reflect"
)

type Student struct {
   Name string
   ID   int
   Age  int
}

func (student Student) Print() {
   fmt.Printf("%s's ID is %d, %d years.", student.Name, student.ID, student.Age)
}

func CallMethod() {
   student := Student{"Bauer", 1, 20}
   value := reflect.ValueOf(student)
   methodValue := value.MethodByName("Print")
   // 对于无参函数
   args := make([]reflect.Value, 0)
   methodValue.Call(args)
}

func main() {
   CallMethod()
}

// output:
// Print: func(main.Student)

三、runtime

1、runtime简介

Go语言编译器产生本地可执行代码，可执行代码仍旧运行在Go的 runtime中，runtime负责管理包括内存分配、垃圾回收、栈处理、goroutine、channel、切片（slice）、map 和反射（reflection）等。

runtime与C标准库的作用一样都是为了语言的跨平台性，runtime可以运行在Windows和Unix平台，可以运行在Intel或ARM处理器上。Go程序都附带runtime，runtime负责与底层操作系统交互。

2、runtime常用方法

3、cgo

CGO是实现Go与C互操作的方式，包括Go调C和C调Go两个过程。Go调用C需要在程序中引入的一个伪包，import “C”即为在Go中使用的伪包。C伪包会在编译前被CGO工具捕捉到，并做一些代码的改写和桩文件的生成，不会被Go编译器见到。

Go语言中调用C程序的方法如下：

//自定义函数调用
package main

/*
#include <stdio.h>
#include <stdlib.h>
void output(char *str) {
   printf("%s\n", str);
}
*/
import "C"
import "unsafe"

func main() {
   str := C.CString("hello cgo")
   C.output(str)
   C.free(unsafe.Pointer(str))
}

4、调度器

每一个Go程序都附带一个runtime，runtime负责与底层操作系统交互，也都会有scheduler对goruntines进行调度。

四、plugin

1、plugin简介

Golang是静态编译型语言，在编译时就将所有引用的包全部加载打包到最终的可执行程序中，因此不能在运行时动态加载其它共享库。Go 1.8开始，Go语言 Linux 和MacOS版本通过plugin包提供插件化加载共享库机制，能够在运行时动态加载外部功能。

2、plugin常用方法

type Plugin struct {
   pluginpath string
   err        string        // set if plugin failed to load
   loaded     chan struct{} // closed when loaded
   syms       map[string]interface{}
}

func Open(path string) (*Plugin, error)
func (p *Plugin) Lookup(symName string) (Symbol, error)

type Symbol interface{}

Open: 根据参数path提供的插件路径加载插件，并返回插件结构的指针 *Plugin 。

Lookup:  *Plugin 的惟一方法，通过名称symName在插件中寻找对应的变量或方法，以Symbol的形式返回。从插件中找到的任何元素都是以Symbol形式(即interface{})返回，需要通过断言的形式对结果进行判断和转换，得到需要的类型。

3、插件编译方法

4、插件使用示例

插件编写HelloPlugin.go：

package main

import (
   "fmt"
)

func init() {
   fmt.Println("Hello")
}

func Hello() {
   fmt.Println("world")
}

插件编译：

go build -buildmode=plugin -o HelloPlugin.so HelloPlugin.go 插件调用main.go：

package main

import (
   "fmt"
   "plugin"
)

func main() {
   open, err := plugin.Open("./HelloPlugin.so")
   if err != nil {
      fmt.Println(err.Error())
   }
   symbol, err := open.Lookup("Hello")
   if err != nil {
      fmt.Println(err)
   }
   symbol.(func())()
}

编译运行：

go run main.go

5、插件化编程

插件管理器实现：

package PluginManager

import "fmt"

// 插件容器
var Plugins map[string]Plugin

func init() {
   Plugins = make(map[string]Plugin)
}

type Plugin interface {
   Start()
}

// 启动这个容器中所有的插件
func Start() {
   for name, plugin := range Plugins {
      go plugin.Start()
      fmt.Printf("%s Plugin Start.\n", name)
   }
}

// 插件做完之后必须得插入到容器中
func Register(name string, plugin Plugin) {
   Plugins[name] = plugin
}

插件实现：

package HelloPlugin

import (
   "GoExample/Plugin/PluginManager"
   "fmt"
)

type HelloPlugin struct {
}

// 导入包时注册插件
func init() {
   plugin := HelloPlugin{}
   PluginManager.Register("HelloPlugin", plugin)
}
func (this HelloPlugin) Start() {
   fmt.Println("This is HelloPlugin.")
}

插件使用：

package main

import "GoExample/Plugin/PluginManager"
import _ "GoExample/Plugin/HelloPlugin"

func main() {
   PluginManager.Start()
}

// output：
// HelloPlugin Plugin Start.

五、signal

1、signal简介

2、signal示例

package main

import (
   "fmt"
   "os"
   "os/signal"
   "syscall"
)

func main() {
   signalChannel := make(chan os.Signal, 1)
   done := make(chan bool, 1)
   // 监听SIGINT、SIGTERM
   signal.Notify(signalChannel, syscall.SIGINT, syscall.SIGTERM)
   go func(ch chan os.Signal) {
      // 接收信号
      channel := <-ch
      fmt.Printf("Received a signal: %s\n", channel)
      done <- true
   }(signalChannel)
   // signal.Stop(signalChannel)
   for {
      fmt.Println("Waiting signal.")
      <-done
      fmt.Println("Exiting.")
   }
}