PHP转Go速学手册

我是如何从 php 转型写 go 的 本来想延续上一个公众号 <<不定期更新的日常>>系列,但是想想还是先写下这篇吧。希望对那些刚转型 Go 或者有意向转型的小伙伴有所帮助。 起点 去年七月初的时候,在上家公司感觉到毕业以来第一次瓶颈,加上小公司项目半凉的状态,随即提出离职。在交接的过程中,我开始投递简历出来面试,因为学历并不是很好,加之在开源世界并没有什么拿得出手的项目,也就没对大厂抱有希望,整个期间就面了三家公司,拿了其中两家 offer,一家做直播的,一家做电商行业的,选择了电商的那家,不算很大,一千多人还是有的, 阅读详情

链接???? http://tigerb.cn/php2go/

前言

整理了一份简要的手册,帮助大家高效的上手Go语言,主要是通过对比PHP和Go的不同点来强化理解,内容主要分为以下四部分:

  • 语言层面差异

  • 基础语法差异

  • 避坑指南

  • 进阶使用

语言层面差异

备注:下文基于PHP主流php-fpm模式。
对比项PHPGo
字符串表示单引号(PSR)双引号
拼接字符串.+
语言版本兼容性不好向下兼容
代码风格无官方标准,社区标准起步晚自始至今官方统一标准,且提供工具
脚本语言是不是
强类型语言不是(PHP7支持严格模式)是
是否支持垃圾回收是是
面向对象语言(OOP)神似部分支持,核心是合成复用
是否支持继承是否(有合成复用)
是否支持interface是是
是否支持try...catch...是否
是否支持包管理是是
是否支持跨平台是是
环境搭建成本高低
执行方式cli命令行模式、php-fpm模式(①)二进制
进程模型多进程单进程
原生是否支持创建TCP/UDP服务是(支持不好,生产不可用)是
原生是否支持创建HTTP服务是(支持不好,生产不可用)是
进程阻塞性是否
是否支持协程否(②)是
并发能力(③)弱极强
是否常驻内存运行不是(④)是
引入文件方式require或者include对应文件import导入包
是否支持单元测试是是
是否支持基准测试(benchmark)否是
是否支持性能分析支持(xhprof/tideways)支持(pprof/dlv)
性能分析工具使用成本高(装扩展成本高)极低
①其他模式还有swoole等
②PHP的swoole协程框架等支持协程
③此处不考虑I/O多路复用,PHP的swoole协程框架等也支持协程并发
④PHP的swoole协程框架是常驻内存,cli命令行模式也可以常驻内存等

刚开始由PHP语言转Go语言的过程,重点是编程意识的转变,尤其是以下几点:

  • 强类型

  • 常驻内存运行

  • 理解和使用指针

  • 并发安全

  • 资源及时释放或返还

基础语法差异

备注:下文基于PHP5.4+版本

常用基本类型对比

PHP类型比较少和简单,PHP常用数据类型有boolean布尔值、string字符串、int整型、float浮点型、array数组、object对象。

PHP常用数据类型和Go语言对应或者类似的类型做个对比,如下:

语言\类型booleanstringintfloatarrayobject
PHPboolstringintfloatarray(1,2,3)索引数组、array('1' => 1, '2' => 2, '3' => 3)关联数组实例化类class
Goboolstringint、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64float32、float64[length]type比较像struct

除此之外Go还支持更丰富的类型:

类型
slice切片(相当于PHP的索引数组)
map(相当于PHP的关联数组)
channel(管道,通过通信共享,不要通过共享来通信)
指针(Go语言的值类型都有对应的指针类型)
byte(字节,对应uint8别名,可以表示Ascaii码)
rune(对应int32,可以表示unicode)
等等
自定义类型,例如type userDefinedType int32

常用基本类型初始化方式对比

类型PHPGo(定义变量带var关键字,或者不带直接使用语法糖:=)
boolean$varStr = true;var varStr bool = true
或者 var varStr = true
或者 varStr := true
string$varStr = 'demo';var varStr string = ""
或者 varStr := ""(:=写法下面省略)
int32$varNum = 0;var varInt32 int32 = 0
int64同上var varInt64 int64 = 0
float32$varNum = 0.01;var varFloat32 float32 = 0
float64同上var varFloat64 float64 = 0
array$varArray = array();
或者语法糖$varArray = [];
var varArray [6]int32 = [6]int32{}
slice(切片)同上,PHP叫索引数据var varSlice []int32 = []int32{}切片相对于数据会自动扩容
map$varMap = array('key' => 'value');var varMap map[string]int32 = map[string]int32{}
closure(闭包)$varClosure = function() {};var varClosure func() = func() {}
channel无var varChannel chan string = make(chan string) 无缓存channel;
var varChannelBuffer chan string = make(chan string, 6)有缓存channel

PHP类的实例化和Go结构体的初始化的对比

PHP类的实例化

/* 
定义class
*/
class ClassDemo {
    // 私有属性
    private $privateVar = "";
    // 公有属性
    public $publicVar = "";
    // 构造函数
    public function __construct()
    {
        // 实例化类时执行
    }
    // 私有方法
    private function privateFun()
    {
    
    }
    // 公有方法
    public function publicFun()
    {
    
    }
}

// 实例化类ClassDemo 获取类ClassDemo的对象
$varObject = new ClassDemo(); // 对象(类)

Go结构体的初始化

// 包初始化时执行
func init() {

}

type StructDemo struct{
    // 小写开头驼峰表示私有属性
    // 不可导出
    privateVar string
    // 大写开头驼峰表示公有属性
    // 可导出
    PublicVar string
}

// 小写开头驼峰表示私有方法
// 结构体StructDemo的私有方法
func (demo *StructDemo) privateFun() error {
    return nil
}

// 大写开头驼峰表示公有属性
// 结构体StructDemo的公有方法
func (demo *StructDemo) PublicFun() error {
    return nil
}

// 初始化结构体StructDemo
// structDemo := &StructDemo{}

常用函数对比

常用函数描述PHPGo
数组长度count()len()
分割字符串为数组explode()strings.Split(s string, sep string) []string
转大写strtoupper()strings.ToUpper(s string) string
转小写strtolower()strings.ToLower(s string) string
去除空格trim()strings.Trim(s, cutset string) string
json序列化json_encode()json.Marshal(v interface{}) ([]byte, error)
json反序列化json_decode()json.Unmarshal(data []byte, v interface{}) error
序列化(不再建议使用)serialize()、unserialize()包https://github.com/wulijun/go-php-serialize
md5md5()包crypto/md5
终端输出echo、var_dump等fmt.Println(a ...interface{})
各种类型互转intval()等包strconv

避坑指南

  1. 谨慎使用全局变量,全局变量不会像PHP一样,在完成一次请求之后被销毁

  2. 形参是slice、map类型的参数,注意值可被全局修改

  3. 资源使用完毕,记得释放资源或回收资源

  4. 不要依赖map遍历的顺序

  5. 不要并发写map

  6. 注意判断指针类型不为空nil,再操作

  7. Go语言不支持继承,但是有合成复用

1. 谨慎使用全局变量,全局变量不会像PHP一样,在完成一次请求之后被销毁

package main

import (
	"github.com/gin-gonic/gin"
)

// 全局变量不会像PHP一样,在完成一次请求之后被销毁
var GlobalVarDemo int32 = 0

// 模拟接口逻辑
func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		atomic.AddInt32(&GlobalVarDemo,1)
		c.JSON(200, gin.H{
			"message": GlobalVarDemo,
		})
	})
	r.Run()
}

// 我们多次请求接口,可以很明显发现:全局变量不会像PHP一样,在完成一次请求之后被销毁。
// 但是PHP不一样,全局变量在完成一次请求之后会被自动销毁。
// curl "127.0.0.1:8080/ping" 
// {"message":1}                                                                     
// curl "127.0.0.1:8080/ping"
// {"message":2} <------- 值在递增
// curl "127.0.0.1:8080/ping"
// {"message":3} <------- 值在递增

2. 形参是slice、map类型的参数,注意值可被全局修改

类似PHP的引用传递,Go里面都是值传递,具体原因下面说。

// 切片
package main

import "fmt"

func main() {
	paramDemo := []int32{1}
	fmt.Printf("main.paramDemo 1 %v, pointer: %p \n", paramDemo, &paramDemo)
	// 浅拷贝
	demo(paramDemo)
	fmt.Printf("main.paramDemo 2 %v, pointer: %p \n", paramDemo, &paramDemo)
}

func demo(paramDemo []int32) ([]int32, error) {
	fmt.Printf("main.demo.paramDemo pointer: %p \n", &paramDemo)
	paramDemo[0] = 2
	return paramDemo, nil
}

// main.paramDemo 1 [1], pointer: 0xc00000c048
// main.demo.paramDemo pointer: 0xc00000c078 <------- 内存地址不一样,发生了值拷贝
// main.paramDemo 2 [2] <------- 原值被修改

// main.paramDemo 1 [1], pointer: 0xc0000a6030
// main.demo.paramDemo pointer: 0xc0000a6060 <------- 内存地址不一样,发生了值拷贝
// main.paramDemo 2 [2], pointer: 0xc0000a6030 <------- 原值还是被修改了



//===========数组就没有这个问题===========
package main

import "fmt"

func main() {
	paramDemo := [1]int32{1}
	fmt.Println("main.paramDemo 1", paramDemo)
	demo(paramDemo)
	fmt.Println("main.paramDemo 2", paramDemo)
}

func demo(paramDemo [1]int32) ([1]int32, error) {
	paramDemo[0] = 2
	return paramDemo, nil
}

// [Running] go run ".../demo/main.go"
// main.paramDemo 1 [1]
// main.paramDemo 2 [1] <------- 值未被修改

//===========Map同样有这个问题===========

package main

import "fmt"

func main() {
	paramDemo := map[string]string{
		"a": "a",
	}
	fmt.Println("main.paramDemo 1", paramDemo)
	demo(paramDemo)
	fmt.Println("main.paramDemo 2", paramDemo)
}

func demo(paramDemo map[string]string) (map[string]string, error) {
	paramDemo["a"] = "b"
	return paramDemo, nil
}

// [Running] go run ".../demo/main.go"
// main.paramDemo 1 map[a:a]
// main.paramDemo 2 map[a:b] <------- 值被修改

为什么?

答:Go语言都是值传递,浅复制过程,slice和map底层的类型是个结构体,实际存储值的类型是个指针。
// versions/1.13.8/src/runtime/slice.go
// slice源码结构体
type slice struct {
    array unsafe.Pointer // 实际存储值的类型是个指针
    len   int
    cap   int
}

// versions/1.13.8/src/runtime/map.go
// map源码结构体
type hmap struct {
    count     int
    flags     uint8
    B         uint8
    noverflow uint16
    hash0     uint32

    buckets    unsafe.Pointer // 实际存储值的类型是个指针
    oldbuckets unsafe.Pointer
    nevacuate  uintptr  

    extra *mapextra
}

怎么办?

答:深拷贝,开辟一块新内存,指针指向新内存地址,并把原有的值复制过去。如下:
package main

import "fmt"

func main() {
	paramDemo := []int32{1}
	fmt.Println("main.paramDemo 1", paramDemo)
	// 初始化新空间
	paramDemoCopy := make([]int32, len(paramDemo))
	// 深拷贝
	copy(paramDemoCopy, paramDemo)
	demo(paramDemoCopy)
	fmt.Println("main.paramDemo 2", paramDemo)
}

func demo(paramDemo []int32) ([]int32, error) {
	paramDemo[0] = 2
	return paramDemo, nil
}

// [Running] go run ".../demo/main.go"
// main.paramDemo 1 [1]
// main.paramDemo 2 [1]


3. 资源使用完毕,记得释放资源或回收资源

package main

import (
	"github.com/gomodule/redigo/redis"
)

var RedisPool *redis.Pool

func init() {
	RedisPool = NewRedisPool()
}

func main() {
	redisConn := RedisPool.Get()
	// 记得defer释放资源
	defer redisConn.Close()
}

func NewRedisPool() *redis.Pool {
	// 略...
	return &redis.Pool{}
}


为什么?

答:避免资源被无效的持有,浪费资源和增加了资源的连接数。其次如果是归还连接池也减少新建资源的开销。
  • 资源连接数线性增长

  • 如果一直持有,资源服务端也有超时时间

4. 不要依赖map遍历的顺序

以往PHP的”Map“(关联数组)不管遍历多少次,元素的顺序都是稳定不变的,如下:

<?php

$demoMap = array(
    'a' => 'a',
	'b' => 'b',
    'c' => 'c',
    'd' => 'd',
    'e' => 'e',
);
foreach ($demoMap as $v) {
    var_dump("v {$v}");
}

// 第一次执行
[Running] php ".../php/demo.php"
string(3) "v a"
string(3) "v b"
string(3) "v c"
string(3) "v d"
string(3) "v e"

// 第N次执行
// 遍历结果的顺序都是稳定不变的
[Running] php ".../php/demo.php"
string(3) "v a"
string(3) "v b"
string(3) "v c"
string(3) "v d"
string(3) "v e"

但是Go语言里就不一样了,如下:

package main

import "fmt"

func main() {
	var demoMap map[string]string = map[string]string{
		"a": "a",
		"b": "b",
		"c": "c",
		"d": "d",
		"e": "e",
	}
	for _, v := range demoMap {
		fmt.Println("v", v)
	}
}

// 第一次执行
// [Running] go run ".../demo/main.go"
// v a
// v b
// v c
// v d
// v e

// 第二次执行
// 遍历结果,元素顺序发生了改变
// [Running] go run ".../demo/main.go"
// v e
// v a
// v b
// v c
// v d

为什么?

答:底层实现都是数组+类似拉链法。
1. hash函数无序写入
2. 成倍扩容
3. 等量扩容
都决定了map本来就是无序的,所以Go语言为了避免开发者依赖元素顺序,每次遍历的时候都是随机了一个索引起始值。然后PHP通过额外的内存空间维护了map元素的顺序。

5. 不要并发写map

package main

import (
	"testing"
)

func BenchmarkDemo(b *testing.B) {
	var demoMap map[string]string = map[string]string{
		"a": "a",
		"b": "b",
	}
	// 模拟并发写map
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			demoMap["a"] = "aa"
		}
	})
}

// BenchmarkDemo
// fatal error: concurrent map writes
// fatal error: concurrent map writes

为什么?

答:并发不安全,触发panic:“fatal error: concurrent map writes”。
// go version 1.13.8源码
// hashWriting 值为 4
if h.flags&hashWriting != 0 {
	throw("concurrent map read and map write")
}

6. 注意判断指针类型不为空nil,再操作

package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	resp, err := http.Get("https://www.example.com")
	if resp.StatusCode != http.StatusOK || err != nil {
		// 当 resp为nil时 会触发panic
		// 当 resp.StatusCode != http.StatusOK 时err可能为nil 触发panic
		log.Printf("err: %s", err.Error())
	}
}


// [Running] go run ".../demo/main.go"
// panic: runtime error: invalid memory address or nil pointer dereference
package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	// 模拟请求业务code
	resp, err := http.Get("https://www.example.com")
	fmt.Println(resp, err)
	if err != nil {
		// 报错并记录异常日志
		log.Printf("err: %s", err.Error())
		return
	}
	// 模拟业务code不为成功的code
	if resp != nil && resp.StatusCode != http.StatusOK {
		// 报错并记录异常日志
	}
}

7.  Go语言不支持继承,但是有合成复用

abstract class AbstractClassDemo {

    // 抽象方法
    abstract public function demoFun();
    
    // 公有方法
    public function publicFun()
    {
        $this->demoFun();
    }
}

class ClassDemo extends AbstractClassDemo {

    public function demoFun()
    {
        var_dump("Demo");
    }
}

(new ClassDemo())->demoFun();

// [Running] php ".../php/demo.php"
// string(4) "Demo"

package main

import (
	"fmt"
)

//基础结构体
type Base struct {
}

// Base的DemoFun
func (b *Base) DemoFun() {
	fmt.Println("Base")
}

func (b *Base) PublicFun() {
	b.DemoFun()
}

type Demo struct {
	// 合成复用Base
	Base
}

// Demo的DemoFun
func (d *Demo) DemoFun() {
	fmt.Println("Demo")
}

func main() {
	// 执行
	(&Demo{}).PublicFun()
}

// [Running] go run ".../demo/main.go"
// Base <------ 注意此处执行的是被合成复用的结构体的方法

进阶使用

  1. 热加载工具bee

  2. Goroutine并发控制之sync.WaitGroup包的使用

  3. 子Goroutine超时控制之context.Context包的使用

  4. 并发安全的map之sync.Map包的使用

  5. 减少GC压力之sync.Pool包的使用

  6. 减少缓存穿透利器之singleflight包的使用

  7. Channel的使用

  8. 单元测试&基准测试

  9. 性能分析

1. 热加载工具bee

作用:以热加载方式运行Go代码,会监视代码的变动重新运行代码,提高开发效率。

使用:

安装
go get github.com/beego/bee/v2

热加载方式启动项目
SOAAGENT=10.40.24.126 bee run -main=main.go -runargs="start"

2. Goroutine并发控制之sync.WaitGroup包的使用

作用:Goroutine可以等待,直到当前Goroutine派生的子Goroutine执行完成。

使用:

package main

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

func main() {
	wg := &sync.WaitGroup{}

	wg.Add(1)
	go func(wg *sync.WaitGroup) {
		defer wg.Done()
		fmt.Println("子a 开始执行")
		time.Sleep(5 * time.Second)
		fmt.Println("子a 执行完毕")
	}(wg)

	wg.Add(1)
	go func(wg *sync.WaitGroup) {
		defer wg.Done()
		fmt.Println("子b 开始执行")
		time.Sleep(5 * time.Second)
		fmt.Println("子b 执行完毕")
	}(wg)

	wg.Add(1)
	go func(wg *sync.WaitGroup) {
		defer wg.Done()
		fmt.Println("子c 开始执行")
		time.Sleep(5 * time.Second)
		fmt.Println("子c 执行完毕")
	}(wg)

	fmt.Println("主 等待")
	wg.Wait()
	fmt.Println("主 退出")
}

// 第一次执行
// [Running] go run ".../demo/main.go"
// 子a 开始执行
// 子c 开始执行
// 子b 开始执行
// 主 等待 <------ 注意这里和下面打印的位置不一样,因为当前代码并发执行是没有保障执行顺序的
// 子b 执行完毕
// 子a 执行完毕
// 子c 执行完毕
// 主 退出

// 第一次执行
// [Running] go run ".../demo/main.go"
// 主 等待 <------ 注意这里和上面打印的位置不一样,因为当前代码并发执行是没有保障执行顺序的
// 子a 开始执行
// 子c 开始执行
// 子b 开始执行
// 子b 执行完毕
// 子c 执行完毕
// 子a 执行完毕
// 主 退出 <------ 主Goroutine一直等待直到子Goroutine都执行完毕

3. 子Goroutine超时控制之context.Context包的使用

作用:Go语言第一形参通常都为context.Context类型,1. 传递上下文 2. 控制子Goroutine超时退出 3. 控制子Goroutine定时退出

使用:

package main

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

func main() {
	ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
	defer cancel()
	go func(ctx context.Context) {
		execResult := make(chan bool)
		// 模拟业务逻辑
		go func(execResult chan<- bool) {
			// 模拟处理超时
			time.Sleep(6 * time.Second)
			execResult <- true
		}(execResult)
		// 等待结果
		select {
		case <-ctx.Done():
			fmt.Println("超时退出")
			return
		case <-execResult:
			fmt.Println("处理完成")
			return
		}
	}(ctx)

	time.Sleep(10 * time.Second)
}

// [Running] go run ".../demo/main.go"
// 超时退出

4. 并发安全的map之sync.Map包的使用

作用:并发安全的map,支持并发写。读多写少场景的性能好。

使用:

package main

import (
	"sync"
	"testing"
)

func BenchmarkDemo(b *testing.B) {
	demoMap := &sync.Map{}
	demoMap.Store("a", "a")
	demoMap.Store("b", "b")
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			demoMap.Store("a", "aa")
		}
	})
}

// BenchmarkDemo
// BenchmarkDemo-4   	 6334993	       203.8 ns/op	      16 B/op	       1 allocs/op
// PASS
// 没有panic

5. 减少GC压力之sync.Pool包的使用

作用:复用对象,减少垃圾回收GC压力。

使用:

5.1  不使用sync.Pool代码示例

package main

import (
	"sync"
	"testing"
)

type Country struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}
type Province struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}
type City struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}
type County struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}
type Street struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

// 模拟数据
// 地址信息对象
type AddressModule struct {
	Consignee       string    `json:"consignee"`
	Email           string    `json:"email"`
	Mobile          int64     `json:"mobile"`
	Country         *Country  `json:"country"`
	Province        *Province `json:"province"`
	City            *City     `json:"city"`
	County          *County   `json:"county"`
	Street          *Street   `json:"street"`
	DetailedAddress string    `json:"detailed_address"`
	PostalCode      string    `json:"postal_code"`
	AddressID       int64     `json:"address_id"`
	IsDefault       bool      `json:"is_default"`
	Label           string    `json:"label"`
	Longitude       string    `json:"longitude"`
	Latitude        string    `json:"latitude"`
}

// 不使用sync.Pool
func BenchmarkDemo_NoPool(b *testing.B) {
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			// 直接初始化
			addressModule := &AddressModule{}
			addressModule.Consignee = ""
			addressModule.Email = ""
			addressModule.Mobile = 0
			addressModule.Country = &Country{
				ID:   0,
				Name: "",
			}
			addressModule.Province = &Province{
				ID:   0,
				Name: "",
			}
			addressModule.City = &City{
				ID:   0,
				Name: "",
			}
			addressModule.County = &County{
				ID:   0,
				Name: "",
			}
			addressModule.Street = &Street{
				ID:   0,
				Name: "",
			}
			addressModule.DetailedAddress = ""
			addressModule.PostalCode = ""
			addressModule.IsDefault = false
			addressModule.Label = ""
			addressModule.Longitude = ""
			addressModule.Latitude = ""
			// 下面这段代码没意义 只是为了不报语法错误
			if addressModule == nil {
				return
			}
		}
	})
}

// 不使用sync.Pool执行结果
// goos: darwin
// goarch: amd64
// pkg: demo
// cpu: Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz
// BenchmarkDemo_NoPool-4   	144146564	        84.62 ns/op	     120 B/op	       5 allocs/op
// PASS
// ok  	demo	21.782s


不使用sync.Pool执行分析:火焰图&Top函数

可以很明显看见GC过程消耗了大量的CPU:

 

5.2 使用sync.Pool代码示例

// 使用sync.Pool
func BenchmarkDemo_Pool(b *testing.B) {
	// 使用缓存池sync.Pool
	demoPool := &sync.Pool{
		// 定义初始化结构体的匿名函数
		New: func() interface{} {
			return &AddressModule{
				Country: &Country{
					ID:   0,
					Name: "",
				},
				Province: &Province{
					ID:   0,
					Name: "",
				},
				City: &City{
					ID:   0,
					Name: "",
				},
				County: &County{
					ID:   0,
					Name: "",
				},
				Street: &Street{
					ID:   0,
					Name: "",
				},
			}
		},
	}
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			// 从缓存池中获取对象
			addressModule, _ := (demoPool.Get()).(*AddressModule)
			// 下面这段代码没意义 只是为了不报语法错误
			if addressModule == nil {
				return
			}

			// 重置对象 准备归还对象到缓存池
			addressModule.Consignee = ""
			addressModule.Email = ""
			addressModule.Mobile = 0
			addressModule.Country.ID = 0
			addressModule.Country.Name = ""
			addressModule.Province.ID = 0
			addressModule.Province.Name = ""
			addressModule.County.ID = 0
			addressModule.County.Name = ""
			addressModule.Street.ID = 0
			addressModule.Street.Name = ""
			addressModule.DetailedAddress = ""
			addressModule.PostalCode = ""
			addressModule.IsDefault = false
			addressModule.Label = ""
			addressModule.Longitude = ""
			addressModule.Latitude = ""
			// 还对象到缓存池
			demoPool.Put(addressModule)
		}
	})
}

// 使用sync.Pool执行结果
// goos: darwin
// goarch: amd64
// pkg: demo
// cpu: Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz
// BenchmarkDemo_Pool-4   	988550808	        12.41 ns/op	       0 B/op	       0 allocs/op
// PASS
// ok  	demo	14.215s


使用sync.Pool执行分析:火焰图&Top函数

runtime.mallocgc 已经在top里面看不见了

 

关于火焰图和Top函数的使用下面会讲到。

6. 减少缓存穿透利器之singleflight包的使用

作用:缓存等穿透时减少请求数。

使用:

package main

import (
	"io/ioutil"
	"net/http"
	"sync"
	"testing"

	"golang.org/x/sync/singleflight"
)

// 没有使用singleflight的代码示例
func TestDemo_NoSingleflight(t *testing.T) {
	t.Parallel()
	wg := sync.WaitGroup{}
	// 模拟并发远程调用
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			resp, err := http.Get("http://example.com")
			if err != nil {
				t.Error(err)
				return
			}
			_, err = ioutil.ReadAll(resp.Body)
			if err != nil {
				t.Error(err)
				return
			}
			t.Log("log")
		}()
	}

	wg.Wait()
}

// 使用singleflight的代码示例
func TestDemo_Singleflight(t *testing.T) {
	t.Parallel()
	singleGroup := singleflight.Group{}
	wg := sync.WaitGroup{}
	// 模拟并发远程调用
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			// 使用singleflight
			res, err, shared := singleGroup.Do("cache_key", func() (interface{}, error) {
				resp, err := http.Get("http://example.com")
				if err != nil {
					return nil, err
				}
				body, err := ioutil.ReadAll(resp.Body)
				if err != nil {
					return nil, err
				}
				return body, nil
			})
			if err != nil {
				t.Error(err)
				return
			}
			_, _ = res.([]byte)
			t.Log("log", shared, err)
		}()
	}

	wg.Wait()
}


抓包域名example.com的请求:tcpdump host example.com

没有使用Singleflight一共发起了3次请求

使用Singleflight只发起了1次请求

7. Channel的使用

作用:不要通过共享内存来通信,要通过通信来实现共享内存。相当于管道。

使用:

package main

import (
	"fmt"
	"time"
)

// 响应公共结构体
type APIBase struct {
	Code    int32  `json:"code"`
	Message string `json:"message"`
}

// 模拟接口A的响应结构体
type APIDemoA struct {
	APIBase
	Data APIDemoAData `json:"data"`
}

type APIDemoAData struct {
	Title string `json:"title"`
}

// 模拟接口B的响应结构体
type APIDemoB struct {
	APIBase
	Data APIDemoBData `json:"data"`
}

type APIDemoBData struct {
	SkuList []int64 `json:"sku_list"`
}

// 模拟接口逻辑
func main() {
	// 创建接口A传输结果的通道
	execAResult := make(chan APIDemoA)
	// 创建接口B传输结果的通道
	execBResult := make(chan APIDemoB)

	// 并发调用接口A
	go func(execAResult chan<- APIDemoA) {
		// 模拟接口A远程调用过程
		time.Sleep(2 * time.Second)
		execAResult <- APIDemoA{}
	}(execAResult)

	// 并发调用接口B
	go func(execBResult chan<- APIDemoB) {
		// 模拟接口B远程调用过程
		time.Sleep(1 * time.Second)
		execBResult <- APIDemoB{}
	}(execBResult)

	var resultA APIDemoA
	var resultB APIDemoB
	i := 0
	for {
		if i >= 2 {
			fmt.Println("退出")
			break
		}
		select {
		case resultA = <-execAResult: // 等待接口A的响应结果
			i++
			fmt.Println("resultA", resultA)
		case resultB = <-execBResult: // 等待接口B的响应结果
			i++
			fmt.Println("resultB", resultB)
		}
	}
}

// [Running] go run ".../demo/main.go"
// resultB {{0 } {[]}}
// resultA {{0 } {}}
// 退出

8.  单元测试&基准测试

作用:开发阶段调试代码块、接口;对代码块、接口做基准测试,分析性能问题,包含CPU使用、内存使用等。可做对比测试。ci阶段检测代码质量减少bug。

使用:

8.1 单元测试

一个很简单的单元测试示例:

package main

import (
	"io/ioutil"
	"net/http"
	"testing"
)

func TestDemo(t *testing.T) {
	t.Parallel()
	// 模拟调用接口
	resp, err := http.Get("http://example.com?user_id=121212")
	if err != nil {
		t.Error(err)
		return
	}
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		t.Error(err)
		return
	}
	t.Log("body", string(body))
}

// 执行
// go test -timeout 30s -run ^TestDemo$ demo -v -count=1
// === RUN   TestDemo
// === PAUSE TestDemo
// === CONT  TestDemo
// ......
// --- PASS: TestDemo (0.45s)
// PASS
// ok      demo    1.130s

多个测试用例的单元测试示例:

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"testing"
)

type Req struct {
	UserID int64
}

func TestDemo(t *testing.T) {
	t.Parallel()
	tests := []struct {
		TestName string
		*Req
	}{
		{
			TestName: "测试用例1",
			Req: &Req{
				UserID: 12121212,
			},
		},
		{
			TestName: "测试用例2",
			Req: &Req{
				UserID: 829066,
			},
		},
	}
	for _, v := range tests {
		t.Run(v.TestName, func(t *testing.T) {
			// 模拟调用接口
			url := fmt.Sprintf("http://example.com?user_id=%d", v.UserID)
			resp, err := http.Get(url)
			if err != nil {
				t.Error(err)
				return
			}
			body, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				t.Error(err)
				return
			}
			t.Log("body", string(body), url)
		})
	}
}

// 执行
// go test -timeout 30s -run ^TestDemo$ demo -v -count=1
// === RUN   TestDemo
// === PAUSE TestDemo
// === CONT  TestDemo
// === RUN   TestDemo/测试用例1
// ...
// === RUN   TestDemo/测试用例2
// ...
// --- PASS: TestDemo (7.34s)
//     --- PASS: TestDemo/测试用例1 (7.13s)
//     --- PASS: TestDemo/测试用例2 (0.21s)
// PASS
// ok  	demo	7.984s


8.2 基准测试

简单的基准测试:

package main

import (
	"sync"
	"testing"
)

// 压力测试sync.Map
func BenchmarkSyncMap(b *testing.B) {
	demoMap := &sync.Map{}
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			demoMap.Store("a", "a")
			for i := 0; i < 1000; i++ {
				demoMap.Load("a")
			}
		}
	})
}

// go test -benchmem -run=^$ -bench ^(BenchmarkSyncMap)$ demo -v -count=1 -cpuprofile=cpu.profile -memprofile=mem.profile -benchtime=10s

// goos: darwin
// goarch: amd64
// pkg: demo
// BenchmarkSyncMap
// BenchmarkSyncMap-4
//   570206	     23047 ns/op	      16 B/op	       1 allocs/op
// PASS
// ok  	demo	13.623s

对比基准测试:

package main

import (
	"sync"
	"testing"
)

// 压力测试sync.Map
func BenchmarkSyncMap(b *testing.B) {
	demoMap := &sync.Map{}
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			demoMap.Store("a", "a")
			for i := 0; i < 1000; i++ {
				demoMap.Load("a")
			}
		}
	})
}

// 用读写锁实现一个并发map
type ConcurrentMap struct {
	value map[string]string
	mutex sync.RWMutex
}

// 写
func (c *ConcurrentMap) Store(key string, val string) {
	c.mutex.Lock()
	defer c.mutex.Unlock()
	if c.value == nil {
		c.value = map[string]string{}
	}
	c.value[key] = val
}

// 读
func (c *ConcurrentMap) Load(key string) string {
	c.mutex.Lock()
	defer c.mutex.Unlock()
	return c.value[key]
}

// 压力测试并发map
func BenchmarkConcurrentMap(b *testing.B) {
	demoMap := &ConcurrentMap{}
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			demoMap.Store("a", "a")
			for i := 0; i < 1000; i++ {
				demoMap.Load("a")
			}
		}
	})
}

// go test -benchmem -run=^$ -bench . demo -v -count=1 -cpuprofile=cpu.profile -memprofile=mem.profile -benchtime=10s

// goos: darwin
// goarch: amd64
// pkg: demo
// BenchmarkSyncMap
// BenchmarkSyncMap-4   	  668082	     15818 ns/op	      16 B/op	       1 allocs/op
// BenchmarkConcurrentMap
// BenchmarkConcurrentMap-4       	  171730	     67888 ns/op	       0 B/op	       0 allocs/op
// PASS
// coverage: 0.0% of statements
// ok  	demo	23.823s


9. 性能分析

作用:CPU分析、内存分析。通过可视化调用链路、可视化火焰图、TOP函数等快速定位代码问题、提升代码性能。

  • pprof

  • trace

  • dlv

使用:

9.1 pprof的使用

9.1.1 基准测试场景

  1. 首先编写基准测试用例,复用上面sync.Map的用例:

package main

import (
	"sync"
	"testing"
)

// 压力测试sync.Map
func BenchmarkSyncMap(b *testing.B) {
	demoMap := &sync.Map{}
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			demoMap.Store("a", "a")
			for i := 0; i < 1000; i++ {
				demoMap.Load("a")
			}
		}
	})
}

  1. 执行基准测试,生成cpu.profile文件和mem.profile 文件。命令如下

go test -benchmem -run=^-bench ^BenchmarkSyncMap−benchBenchmarkSyncMap demo -v -count=1 -cpuprofile=cpu.profile -memprofile=mem.profile -benchtime=10s

常用参数解释:

-benchmem: 输出内存指标
-run: 正则,指定需要test的方法
-bench: 正则,指定需要benchmark的方法
-v: 即使成功也输出打印结果和日志
-count: 执行次数
-cpuprofile: 输出cpu的profile文件
-memprofile: 输出内存的profile文件
-benchtime: 执行时间

更多参数请查看:
go help testflag
  1. 使用go tool自带的pprof工具分析测试结果。命令如下:

go tool pprof -http=:8000 cpu.profile

常用参数解释:

-http: 指定ip:port,启动web服务可视化查看分析,浏览器会自动打开页面 http://localhost:8000/ui/
可视化选项菜单:

火焰图:

调用链路图:

Top函数:

9.1.2 Web服务场景

1. 使用上面全局变量的代码示例,引入net/http/pprof包,并单独注册各端口获取pprof数据。

package main

import (
	"net/http"
	// 引入pprof包
	// _代表只执行包内的init函数
	_ "net/http/pprof"

	"github.com/gin-gonic/gin"
)

// 全局变量不会像PHP一样,在完成一次请求之后被销毁
var GlobalVarDemo int32 = 0

// 模拟接口逻辑
func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		GlobalVarDemo++
		c.JSON(200, gin.H{
			"message": GlobalVarDemo,
		})
	})
	// 再开启一个端口获取pprof数据
	go func() {
		http.ListenAndServe(":8888", nil)
	}()
	// 启动web服务
	r.Run()
}

2. 访问链接 http://localhost:8888/debug/pprof/,可以看见相关profiles。

3. 命令使用pprof工具,获取远程服务profile,命令如下:

go tool pprof -http=:8000 http://localhost:8888/debug/pprof/profile?seconds=5

备注:
执行上面命令的时候,可以使用压测工具模拟流量,比如命令:siege -c 50 -t 100 "http://localhost:8080/ping"

同样,我们得到了这个熟悉的页面:

9.2 trace工具的使用

作用:清晰查看每个逻辑处理器中Goroutine的执行过程,可以很直观看出Goroutine的阻塞消耗,包含网络阻塞、同步阻塞(锁)、系统调用阻塞、调度等待、GC执行耗时、GC STW(Stop The World)耗时。

9.2.1 基准测试场景

使用:

生成trace.out文件命令:
go test -benchmem -run=^$ -bench ^BenchmarkDemo_NoPool$ demo -v -count=1 -trace=trace.out 
go test -benchmem -run=^$ -bench ^BenchmarkDemo_Pool$ demo -v -count=1 -trace=trace.out 

分析trace.out文件命令:
go tool trace -http=127.0.0.1:8000 trace.out
没使用sync.Pool:

  

使用sync.Pool:

9.2.2 Web服务场景

使用:

同样引入包net/http/pprof

package main

import (
	"net/http"
	// 引入pprof包
	// _代表只执行包内的init函数
	_ "net/http/pprof"

	"github.com/gin-gonic/gin"
)

// 全局变量不会像PHP一样,在完成一次请求之后被销毁
var GlobalVarDemo int32 = 0

// 模拟接口逻辑
func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		GlobalVarDemo++
		c.JSON(200, gin.H{
			"message": GlobalVarDemo,
		})
	})
	// 再开启一个端口获取pprof数据
	go func() {
		http.ListenAndServe(":8888", nil)
	}()
	// 启动web服务
	r.Run()
}


启动服务后执行如下命令:

1. 
生成trace.out文件命令:
curl http://localhost:8888/debug/pprof/trace?seconds=20 > trace.out
和上面命令同时执行,模拟请求,也可以用ab:
siege -c 50 -t 100 "http://localhost:8080/ping"

2. 分析trace.out文件命令:
go tool trace -http=127.0.0.1:8000 trace.out
快捷健:
w 放大
e 右移

    

9.3 dlv工具的使用

9.3.1 基准测试场景

作用:断点调试等。

安装:

go install github.com/go-delve/delve/cmd/dlv@latest

使用:

package main

import (
	_ "net/http/pprof"

	"github.com/gin-gonic/gin"
)

// 全局变量不会像PHP一样,在完成一次请求之后被销毁
var GlobalVarDemo int32 = 0

// 模拟接口逻辑
func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		GlobalVarDemo++
		c.JSON(200, gin.H{
			"message": GlobalVarDemo,
		})
	})
	r.Run()
}


命令行执行命令:

dlv debug main.go

进入调试,常用调试命令:

  • (list或l:输出代码):list main.go:16

  • (break或b:断点命令):执行 break main.go:16 给行 GlobalVarDemo++打断点

  • (continue或c:继续执行):continue

  • (print或p:打印变量):print GlobalVarDemo

  • (step或s:可以进入函数):step

更多命令请执行 help。

模拟请求:
curl http://localhost:8080/ping

9.3.2 Web服务场景

还是这个demo

package main

import (
	"github.com/gin-gonic/gin"
)

// 全局变量不会像PHP一样,在完成一次请求之后被销毁
var GlobalVarDemo int32 = 0

// 模拟接口逻辑
func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		GlobalVarDemo++
		c.JSON(200, gin.H{
			"message": GlobalVarDemo,
		})
	})
	// 启动web服务
	r.Run()
}


  • 找到服务进程ID lsof -i :8080

  • dlv调试进程 dlv attach 36968

  • 进入调试模式,调试代码(和上面一样)

9.4(扩展) 逃逸分析

逃逸分析命令:go build -gcflags "-m -l" *.go

package main

type Demo struct {
}

func main() {
	DemoFun()
}

func DemoFun() *Demo {
	demo := &Demo{}
	return demo
}

// # command-line-arguments
// ./main.go:11:10: &Demo literal escapes to heap <------- 局部变量内存被分配到堆上

9.5(扩展) 汇编代码

直接生成汇编代码命令:go run -gcflags -S main.go

# command-line-arguments
"".main STEXT nosplit size=1 args=0x0 locals=0x0
        0x0000 00000 (.../demo/main.go:6)  TEXT    "".main(SB), NOSPLIT|ABIInternal, $0-0
        0x0000 00000 (.../demo/main.go:6)  FUNCDATA        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0000 00000 (.../demo/main.go:6)  FUNCDATA        $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0000 00000 (.../demo/main.go:6)  FUNCDATA        $2, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0000 00000 (<unknown line number>)    RET
        0x0000 c3       
		略......

获取生成汇编代码整个优化过程:GOSSAFUNC=main go build main.go

dumped SSA to ./ssa.html <------- 生成的文件,浏览器打开此文件


Go轻松进阶系列 更多文章

PHP 程序员转 Go 语言的经历分享 之前有朋友让我分享从 PHP 转 Go 的经历,这次它来了。 阅读详情

相关推荐

php开发转go的学习计划及课程资料信息

通过这套教材组合,你可以在保持PHP开发思维的同时,快速建立Go语言的知识体系。遇到具体问题时,优先查阅《Go语言实战》对应章节和Go官方FAQ。

baixiaoshengaaa的博客 1421

PHP转GO 的正确打开路径 从hyperf,ES6,Python 到 Go

彻底打破PHP直接转GO语言的误区,充分将PHP转GO的正确方式给出,按照此渠道直接打通任督二脉,从此啥高级语言都不再是拦路虎

王森的博客 4225

[2020年面试题-PHP 与 golang] .Go 和 PHP 在运行的时候有什么区别和优势

原文链接 分享:[分享] 大环境下瑟瑟发抖辞职的第二天,拿了两个 offer 面试题解析 看你简历里也有用过 Go,Go 和 PHP 在运行的时候有什么区别和优势? 题主原回答: PHP 每个请求进来时都会创建 fpm-worker 进程,从而导致系统并发高时 CPU 会产生频繁创建进程的开销,而 Go 不会。 解析回答:PHP 每个请求进来时都会创建 fpm-worker 进程 补充下,这里 php 请求进来就会 由 PHP - FPM(php-fpm 是 php-cgi 的进程管理器)创.

weixin_43814458的博客 1652

PHP转Go超简单:语法对比+框架选择+避坑指南

本文从PHP开发者视角介绍了如何快速上手Go语言开发,对比了两者在语言特性、性能、网络编程等方面的异同。PHP是动态类型的解释型语言,而Go是静态类型的编译型语言,具有更高的性能和更严格的类型系统。

weixin_45926995的博客 2942

go语言手册教程(中文)

go是非常年轻的一门语言,它的主要目标是“兼具Python 等动态语言的开发速度和C/C++等编译型语言的性能与安全性” 很多公司,特别是中国的互联网公司,即将或者已经完成了使用 Go 语言改造旧系统的过程。经过 Go 语言重构的系统能使用更少的硬件资源获得更高的并发和I/O吞吐表现。充分挖掘硬件设备的潜力也满足当前精细化运营的市场大环境。

在 Linux/Debian/Ubuntu 上使用 Brasero 刻录光盘

在 Ubuntu 系统中,Brasero 是一个非常方便的光盘刻录工具。无论是创建数据光盘、音频光盘还是刻录光盘镜像文件,Brasero 都能轻松胜任。本文将介绍如何在 Ubuntu 上安装和使用 Brasero 进行光盘刻录。

I AM COMING BACK... 3553

为什么PHP都在转Go?

这时候有人会说,PHP有swoole,常驻内存,高性能,也有协程可以实现并发编程,资源占用低。举个例子,常用的http库,如果你写PHP你立马会想到Guzzle这个强大的库,如果是Go呢,标准库自带的功能就已经足够了,如果是Python,应该是用requests这个库,但是Java呢,我还真不清楚。在前后端分离的时代,虽然不用PHP套模板了,PHP还可以去写接口,配合一些PHP Web框架,写起接口来也是非常快的,三五行代码开启一个Web服务,相当于其它语言比如Java来说太简单方便了。

winkexin的博客 1035

AI与Agent赋能下的软件测试变革:面向未来测试工程师的工作方法论

AI Agent 软件测试 测试 software testing test

测试技师的自我修养 1241

[GO语言基础] 一.为什么我要学习Golang以及GO语言入门普及

作为网络安全初学者,会遇到采用Go语言开发的恶意样本。因此从今天开始从零讲解Golang编程语言,一方面是督促自己不断前行且学习新知识;另一方面是分享与读者,希望大家一起进步。这系列文章入门部分将参考“尚硅谷”韩顺平老师的视频和书籍《GO高级编程》,详见参考文献,并结合作者多年的编程经验进行学习和丰富,且看且珍惜吧!后续会结合网络安全进行GO语言实战深入,驾驭~ 这些年我学过各种编程语言,从最早的C语言到C++,再到C#、PHP、JAVA,再到IOS开发、Python,到最新的GO语言,学得是真的杂。有时

杨秀璋的专栏 12万+

【020】基于51单片机智能路灯系统Proteus仿真与实物设计

【020】基于51单片机智能路灯系统Proteus仿真与实物设计

小邓子分享官的博客 1881

好书分享:Control and Estimation with MATLAB(5th Edition)pdf

基于MATLAB的控制与估计》(第5版)由八章组成,包括控制算法和设计。主要内容包括状态估计和数据平滑、RLS和卡尔曼滤波器状态估计、控制系统设计、自适应控制和PID。书中的概念已经使用MATLAB和Simulink实现。提供了可下载的MATLAB和Simulink文件。适合人群:大学生、研究生、控制类工程研究人员。需要电子版pdf,回复索取。

jixianhu的博客 1511

PHP转Go实践:xjson解析神器「开源工具集」

业务系统从php转go,或go对接php服务,都会遇到这个因为数据类型不一致导致json解析错误的共性问题。使用第三方库json-iterator能很好的解决我们的痛点,并且比标准库执行速度还更快。收录到开源项目中,更好的帮助到需要的朋友,欢迎使用、star与PR共同建设。

王中阳讲编程 2万+

Diffusion、VAE与GAN:三大生成模型的原理对比与应用场景解析

本文深入解析了Diffusion、VAE与GAN三大生成模型的核心原理与特性。Diffusion模型通过逆向去噪过程实现高质量图像生成,但计算成本较高;VAE擅长学习概率潜空间,训练稳定但图像偏模糊;GAN通过对抗训练生成锐利图像,但存在模式崩溃风险。文章结合实战场景,为图像生成、修复、超分辨率等任务提供了清晰的模型选择指南。

weixin_29063979的博客 347

Go 和 Golang 有什么关系?

大家好,我是煎鱼。最近天气也冷了,掐指一算是招聘季了,无论是校招、社招、HR、面试官们都蠢蠢欲动。这不,我有一个朋友的 HR 朋友都有起名困难了,一看 Go 语言的工作说明(Job Des...

EDDYCJY的博客 1万+

运行后选择GDB/LLDB出现这样的窗口:launch: program ‘输入程序名称,例如 D:\Desktop\新建文件夹\a.exe‘ does not exist...如何解决?

🏆本文收录于 《全栈 Bug 调优(实战版)》 专栏。专栏聚焦真实项目中的各类疑难 Bug,从成因剖析 → 排查路径 → 解决方案 → 预防优化全链路拆解,形成一套可复用、可沉淀的实战知识体系。无论你是初入职场的开发者,还是负责复杂项目的资深工程师,都可以在这里构建一套属于自己的「问题诊断与性能调优」方法论,助你稳步进阶、放大技术价值 。

**My Coding Family** 1132

YOLOv5/v7/v8首发革新改进——轻巧、创新的LADH检测头

本文介绍了一种原创改进的轻量化非对称多级压缩LADH检测头,该检测头能够实现即插即用,并在YOLOv5/v7/v8检测器中取得了显著的性能提升。本文将介绍一种原创改进的轻量级非对称多级压缩LADH(Lightweight Asymmetric Dual-Head)检测头,该检测头能够实现即插即用,并显著提升YOLO检测器的性能。因此,我们提出了一种非对称多级压缩的方法,即对不同类别的检测头采用不同的压缩比例。然而,为了进一步提高YOLO的性能,我们进行了一项原创改进,设计了一种轻巧且创新的LADH检测头。

IpyVariable的博客 2727

从 PHP 转 Go

点击上方蓝色“Golang来啦”关注我哟加个“星标”,天天 15 分钟,掌握 Go 语言via:https://medium.com/@joesweeny/from-php-to-go-...

Seekload 1143

信号与电源完整性5:轨道塌陷噪声/电源轨道噪声分析及降低解决方案

经过上一节关于串扰的分析,我们已经清楚,噪声问题不仅仅来源于信号网络;电源和地网络所产生的噪声,被反馈到其所在的元器件和信号网络时,其破坏力也是巨大的;本节所讨论的轨道塌陷噪声就是一个典型的实例。在经过电源的地网络的电流发生改变时,在电源和地之间的阻抗上将产生一个压降;由于该压降的产生,用电元件的电压将直接被拉低,甚至可能对电路产生功能性的错误。接下来硬小二将详细的分析电源轨道噪声和降低其的解决方法。...

fydar的博客 2246

php转go注意,PHP转Golang一些感想

由于某些原因参与到团队Golang项目的开发中,之前开发主要用的PHP,现在Golang用了也有较长一段时间了,就想着写篇博客分享下现在的一些感想,缕一缕Golang的优缺点。缺点1:没有异常,Emmmm 等等... 它有!用过Golang都懂,漫天遍野的err判断if err != nil {return err}最初让人很不爽,当然现在没好多少...Golang其实有异常捕获机制panic/r...

weixin_39785286的博客 412

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

php简单还是go简单_PHP转Golang一些感想

由于某些原因参与到团队Golang项目的开发中,之前开发主要用的PHP,现在Golang用了也有较长一段时间了,就想着写篇博客分享下现在的一些感想,缕一缕Golang的优缺点。缺点1:没有异常,Emmmm 等等... 它有!用过Golang都懂,漫天遍野的err判断if err != nil {return err}最初让人很不爽,当然现在没好多少...Golang其实有异常捕获机制panic/r...

weixin_42371574的博客 1201

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

PHP转Go终极指南:用PHP2Go实现无缝迁移与性能飞跃

想象一下,你是一个经验丰富的PHP开发者,突然被要求用Go语言重构一个核心项目。你发现Go语言的性能确实诱人,但那些熟悉的PHP内置函数——`strpos()`、`array_merge()`、`date()`——在Go中都需要重新学习实现。这种困境是否似曾相识? 这正是PHP2Go项目诞生的背景。作为一个开源函数库,PHP2Go用Go语言重新实现了140多个PHP常用内置函数,让PHP开发者能

gitblog_00859的博客 1059

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

php 程序员学golang,一个 PHP 程序猿学习 Go 的体悟

正文开头先来一口鸡汤没有什么事情是一蹴而就的,要想取得成绩,那就努力吧。- 敬“明天”为什么想学Go要谈论学习心得,首先就得谈谈我为什么要来学习Go语言了。首先我总结了几点原因:PHP并发支持不好,就算是有了swoole、workerman等扩展,依旧杯水车薪PHP对微服务的支持不行PHP在大型企业不能满足使用需要Go语言最近几年火变国内外Go原生并发支持Go入门使用简单Go第三方扩展丰富好吧,看...

weixin_35720035的博客 369

php转go还是前端,我为什么从php转go?

今天有个同学问我,为什么从php转go?此前没认真的去思考过,在此记录下我理解的go相比较于php的一些优势此文并无贬低php之意,php也曾意气风发过运行环境简单golang官方提供了明确的环境安装方式php市面上选择较多,无统一的方式php环境搭建用过php的至少都能搭建个wamp或者lamp环境,但是没有一个官方的环境谁又没有在安装环境时遇到过各种坑呢~当然市面上有很多集成环境比如phpst...

weixin_39946313的博客 610

PHP 程序员是学 Swoole ?还是学 Go ?

这次为什么要讨论这个话题,因为 Swoole 和 Go 在 PHP 程序员坊间一直都是茶语饭后的谈资,觉得懂 Swoole 和 Go 的就高人一等。

A码农先森的专栏 962

php程序员如何转go,写给 PHP 程序员的 Go 入门教程

这两年唱衰 PHP 的论调不少(其实我觉得大可不必),导致不少 PHP 程序员产生危机感,纷纷寻求转型,根据我的观察,基本上 Go 都是首选。不管怎么说,技多不压身,多掌握一点知识总是好的。本文就作为一个基础的入门来帮助 PHP 程序员入门 Go 语言吧。1. 脚本语言 vs 编译型语言这其实是个我每次面试都会问的问题,脚本语言和编译型语言有什么区别。维基上的解释:语法和结构通常比较简单学习和使...

weixin_42356315的博客 2526
上一篇: Go服务监控搭建入门 | 教程
下一篇: 总结&新领域
TIGERB_Blog
博客等级 码龄10年 109粉丝 65原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值