本文介绍go里的rpc开发的知识点与相关使用场景。

什么是RPC

RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务。

RPC vs REST

• RPC主要是基于TCP/IP协议的，而REST服务主要是基于HTTP协议的
• REST通常以业务为导向，将业务对象上执行的操作映射到HTTP动词，格式非常简单。
• REST也存在一些弊端，比如只支持请求/响应这种单一的通信方式，对象和字符串之间的序列化操作也会影响消息传递速度。在单个请求获取多个资源时存在着挑战，而且有时候很难将所有的动作都映射到HTTP动词。比如注册、授权等等。
• 由于HTTP在应用层中完成，整个通信的代价较高，远程过程调用中直接基于TCP进行远程调用，数据传输在传输层TCP层完成，更适合对效率要求比较高的场景，RPC主要依赖于客户端和服务端之间建立Socket链接进行，底层实现比REST更复杂。

主流的RPC框架

主要用的就是GRPC,Thrift,Dubbo这三个，下面分别介绍下使用方式。

GRPC

GRPC是Google最近公布的开源软件，基于最新的HTTP2.0协议，并支持常见的众多编程语言(Golang,C++,Java,Php,Python等等)。

• 安装
  建议先配置go module代理。否则不开VPN下载速度可能会很慢，也许直接下载失败。

  1 2 3 4 5 6

  // 安装protobuf插件 go get -u github.com/golang/protobuf/protoc-gen-go // 再去下载protoc,地址:https://github.com/golang/protobuf/releases unzip protoc-x.x.x-linux-x86_64.zip -d /usr/local/ // 查看版本 protoc --version

• 示例1 校验用户
  目录结构如下：

  1 2 3 4 5 6 7 8

  . ├── client # 客户端 │   └── main.go ├── proto │   └── user_auth.proto └── server # 服务端 └── main.go

本文介绍golang的sync包里的知识点与使用方式。

什么是Sync包

Golang sync包提供了基础的异步操作方法，包括互斥锁Mutex，执行一次Once和并发等待组WaitGroup
主要的功能如下:

1
2
3
4
5
6
7

sync.Mutex: 互斥锁
sync.RWMutex: 读写锁
WaitGroup: 并发等待管理
Once：执行一次
Cond：信号量
Pool：临时对象池
Map：自带锁的map

sync.Mutex&sync.RWMutex

• sync.Mutex称为互斥锁，常用在并发编程里面。互斥锁需要保证的是同一个时间段内不能有多个并发协程同时访问某一个资源(临界区)
• sync.RWMutex目的是为了能够支持多个并发协程同时读取某一个资源，但只有一个并发协程能够更新资源。也就是说读和写是互斥的，写和写也是互斥的，读和读是不互斥的。
  这两个锁的用法在之前已介绍过，故不再重复介绍。需要的请查看：Golang代码优化04-锁

sync.WaitGroup

sync.WaitGroup指的是等待组，在Golang并发编程里面非常常见，指的是等待一组工作完成后，再进行下一组工作。

1
2
3

func (wg *WaitGroup) Add(delta int)  Add添加n个并发协程
func (wg *WaitGroup) Done()  Done完成一个并发协程
func (wg *WaitGroup) Wait()  Wait等待其它并发协程结束

简单的理解就是Boss监督Worker工作，等待所有的Worker完成后才收工！

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

func main() {
    n := 100
    wg := sync.WaitGroup{}
    // 监控n个协程
    wg.Add(n) 
    for i := 0; i < n; i++ {
        go func(i int) {
            fmt.Println(i)
            // 标识已完成工作
            wg.Done() 
        }(i)
    }
    // 阻塞等待所有goroutine完成工作
    wg.Wait()
    fmt.Println("All done!")
}

sync.Once

本文介绍关于Context的一些要点。

什么是Context

Context，上下文，golang协程的相关环境快照，其中包含函数调用以及涉及的相关的变量值。
通过Context在协程之间进行数据传递，相对于维护全局变量要简单。但也有人说它想virus,到处传播，褒贬不一。所以不同的场景下，还得程序猿自己决定是否适用。

结构

Context是一个树形结构。首先需要创建的是根节点。

• 顶层Context: Background

  1 2 3 4

  func main() { // 声明一个空的Context，它将作为所有由此继承Context的根节点 ctx := context.Background() }

• 子孙节点 WithCancel/WithDeadline/WithTimeout/WithValue

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

  // 带cancel返回值的Context，一旦cancel被调用，即取消该创建的context func WithCancel(parent Context) (ctx Context, cancel CancelFunc) // 带有效期cancel返回值的Context，即必须到达指定时间点调用的cancel方法才会被执行 func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) // 带超时时间cancel返回值的Context，类似Deadline，前者是时间点，后者为时间间隔 // 相当于WithDeadline(parent, time.Now().Add(timeout)). func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) // 带key-val的Context func WithValue(parent Context, key string, val interface) Context

介绍在项目开发中，经常用到到保证数据安全的锁的使用。

sync.Mutex 互斥锁

• demo

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

  type Item struct { mu sync.Mutex number int } // NewItem func NewItem() *Item { return &Item{ mu: sync.Mutex{}, number: 0, } } // SetNumber func (item *Item) SetNumber(num int) { item.mu.Lock() defer item.mu.Unlock() item.number = num } // Number func (item *Item) Number() int { item.mu.Lock() defer item.mu.Unlock() return item.number }

  通过mu互斥锁保证写入数据和读取数据都是线程安全的。如果不用锁，在多个协程里执行SetNumber()容易导致获取的数据和预期不一致

RWMutex 读写锁

在读多写少的场景中，可以优先使用读写锁RWMutex。

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

package main

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

func main() {
    var wg sync.WaitGroup

    u := NewUser()
    // 通过协程并发读取，这里使用读锁，比互斥锁效率更高
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            fmt.Println("Get Age:", u.GetAge(),time.Now().Second())
        }()
    }

    // 激活一个申请写锁的goroutine
    go func() {
        wg.Add(1)
        defer wg.Done()
        u.ChangeAge(10)
    }()
    // 阻塞，直到所有wg.Done
    wg.Wait()
}

// NewUser return user instance
func NewUser() *U {
    return &U{
        rwm: sync.RWMutex{},
        Age: 0,
    }
}

// U user
type U struct {
    rwm sync.RWMutex
    Age int
}
// GetAge
func (u *U) GetAge() int {
    u.rwm.RLock()
    defer u.rwm.RUnlock()
    return u.Age
}
// ChangeAge
func (u *U) ChangeAge(age int) {
    u.rwm.Lock()
    defer u.rwm.Unlock()
    u.Age = age
}

介绍读取http的response内容。

读取方式

• 1.使用ioutil.ReadAll()读取response

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

  func main () { // send get request resp, err := http.Get("https://api.ipify.org/?format=json") if err != nil { fmt.Println(err) return } // defer must execute after check error,otherwise will panic when resp is nil defer resp.Body.Close() // read body body, err := ioutil.ReadAll(resp.Body) if err != nil { fmt.Println(err) return } fmt.Println(string(body)) }

  但是ioutil.ReadAll()方法有弊端,有时候却会导致一些性能问题。比如http大量请求时轻则导致内存浪费严重，重则导致内存泄漏影响业务。

• 2.使用buffer读取

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

  func main () { resp, err := http.Get("https://api.ipify.org/?format=json") if err != nil { fmt.Println(err) return } defer resp.Body.Close() // new buffer buffer := bytes.NewBuffer(make([]byte, 4056)) if _, err := io.Copy(buffer, resp.Body);err != nil { fmt.Println(err) return } fmt.Println(buffer.String()) }

介绍一些常规的用法

channel的状态

• channel:未初始化时为nil
• active:正常的channel,可读可写
• closed:调用了close()后的状态

channel的操作

• 读 <-channel
• 写 ->channel
• 关闭 close

常用的channel使用方法

• 使用for..range 读取channel
  当需要不断从channel中读取数据时，使用for..range,当channel关闭时，for..range会自动退出

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

  func main() { ch := make(chan string) go sendData(ch) for out := range ch { fmt.Println(out) } } func sendData(ch chan string) { ch <- "Washington" ch <- "Tripoli" ch <- "London" ch <- "Beijing" ch <- "Tokyo" defer close(ch) }

• 使用value,ok判断channel是否关闭
  当直接读取channel时，如果channel已关闭，会触发panic,故需要判断channel是否关闭

  1 2 3 4 5 6 7 8 9 10 11

  func main() { ch := make(chan string) go sendData(ch) for { if out, open := <- ch; open { fmt.Println(out) }else { break } } }

• 使用select读取多个channel
  select可以同时监控多个通道的情况，只处理未阻塞的case。当通道为nil时，对应的case永远为阻塞，无论读写。特殊关注：普通情况下，对nil的通道写操作是要panic的。

• 使用channel的声明控制读写权限
  协程对某个channel只读或只写

• 使用缓冲channel增强并发和异步
  有缓冲通道是异步的，无缓冲通道是同步的。有缓冲通道可供多个协程同时处理，在一定程度可提高并发性。

在项目中，全局变量使用的较为普遍，如全局DB连接池、Redis连接池等。

初始化

Go的全局变量，在main函数执行前初始化。

1
2
3
4

var a = 1
func main()  {
	fmt.Println(a)
}

• 数据库连接
  database初始化数据库连接

  1 2 3 4 5 6 7 8 9 10

  package database var Instance *gorm.DB // init func init() { db, err := gorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local") if err != nil { log.Fatalf("failed to connect database:%s", err.Error()) } Instance = db }

使用

1
2
3
4
5
6

package main
import "database" // import,触发init函数
func main() {
    // ping mysql
    database.Instance.DB().Ping()
}

记录项目开发中Go写法的代码优化。

定制化error

在项目开发中，我们不想直接暴露系统底层的错误，同时常规的error无法满足项目精细化的处理，我们经常会对error通过code进行分类。故定义如下:

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

// Error 
type Error struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
}

// Error string
func (e *Error) Error() string {
	b, _ := json.Marshal(e)
	return string(b)
}

// New return error with code
func New( code int, message string) *Error {
	return &Error{
		Code:    code,
		Message: message,
	}
}

// Parse tries to parse a JSON string into an error. If that
// fails, it will set the given string as the error detail.
func Parse(errStr string) *Error {
	e := new(Error)

	if err := json.Unmarshal([]byte(errStr), e); err != nil {
		e.Code = http.StatusInternalServerError
		e.Message = err.Error()
	}
	return e
}

使用

1
2
3
4
5
6
7

// new
err := New(200105001, "something wrong" )
fmt.Println("err:",err.Error())

// parse
errParse := Parse(err.Error())
fmt.Println("err code": errParse.Code)

本篇文章介绍在公司做库存系统接触到的高并发场景下的优化方案。

什么是高并发

From:百度百科

由于分布式系统的问世，高并发（High Concurrency）通常是指通过设计保证系统能够同时并行处理很多请求。通俗来讲，高并发是指在同一个时间点，有很多用户同时的访问同一 API 接口或者 Url 地址。它经常会发生在有大活跃用户量，用户高聚集的业务场景中。

优化方向

静态资源

采用CDN(Content Delivery Network)是指内容分发网络，处理如html,js,css,image等静态资源。

动态资源(重点)

• 选择合适的web服务
  常见的web如nginx,swoole的HttpServer,go的HttpServer，由于各自的特性(nginx的epoll模型，swoole与go的协程)，它们都是能够轻松因对万级并发的优秀web服务。

• 数据层优化

  • 读写分离: 降低数据库的负载，提高查询性能。
  • 使用数据库连接池,减少连接实例化的次数，节省了内存和时间，提升了效率。
  • NoSQL:相较于MySQL的select，采用更高效的Redis数据结构缓存数据。
  • 内存: 相较于Redis缓存查询，使用内存来缓存数据会更高效。但维护成本较高，适用缓存不经常变更的数据。

• 业务层优化

  • 使用异步的方式拆分耗时较长的业务。具体方案有消息队列，协程，异步任务等。
  • 需请求三方服务接口事，选择Http长连接。

• 系统层优化

  • 集群模式，当一台服务扛不住压的时候，就需要多增加N台，提升N倍的接口处理能力。

本篇文章主要介绍单例模式。

概念

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

优点

• 实例控制
  单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
• 灵活性
  因为类控制了实例化过程，所以类可以灵活更改实例化过程。

示例

• Demo1

  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 38 39 40 41 42 43 44 45 46 47 48 49

  <?php /** * Singleton 单例类 * * @auther hongker * @date 2018-12-24 */ class Singleton { /** * 实例变量 * @var mixed */ private static $instance = null; /** * 获取实例 * @return Operate */ public static function getInstance() { if (self::$instance == null) { self::$instance = new Operate(); } return self::$instance; } } /** * Operate 实际操作类 */ class Operate { /** * 具体函数 */ public function doSomething() :void { echo "do something..\r\n"; } } // 调用方式 $instance = Singleton::getInstance(); $instance->doSomething();

  使用以上的模式，对外提供Singleton::getInstance()方法，避免暴露实例化Operate类。

• Demo2
  因为$instance是个静态变量，仅需初始化一次，便可随处适用。但不适合包含可变属性值的场景。如下：

  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 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

  <?php /** * Singleton 单例类 * * @auther hongker * @date 2018-12-24 */ class Singleton { /** * 实例变量 * @var mixed */ private static $instance = null; /** * 获取实例 * @return Operate */ public static function getInstance() { if (self::$instance == null) { self::$instance = new Operate(); } return self::$instance; } } /** * Operate 实际操作类 */ class Operate { /** * 操作名称 * @var string */ private $name; /** * 具体函数 */ public function doSomething() :void { echo "do something..\r\n"; } /** * 获取名称 * @return string */ public function getName() : string { return $this->name; } /** * 设置名称 * @param string $name 操作名称 */ public function setName(string $name):void { $this->name = $name; } } // 第一次获取实例 $instance1 = Singleton::getInstance(); $instance1->setName("get"); echo "instance1->getName: {$instance1->getName()}\r\n"; // 第二次获取实例 $instance2 = Singleton::getInstance(); $instance2->setName("post"); echo "instance2->getName: {$instance2->getName()}\r\n"; // 此时实例1的name属性也会发生变动 echo "instance1->getName: {$instance1->getName()}\r\n";

  输出如下:

  1 2 3

  instance1->getName: get instance2->getName: post instance1->getName: post

通过这两个实例可以很好的理解单例模式的适用方式，在实际开发过程中，还有很多的场景适用单例模式，但也有不适用的，所以需要多思考。