gitxuzan

Google Authenticator工作原理

golang性能测试指定运行函数

【代码】golang跳转语句 break loop 和 goto loop。

go分布式存储，rs纠删码。

package mainimport ( "fmt" "github.com/go-ping/ping" "os" "os/signal")func main() { pinger, err := ping.NewPinger("api.juexin.live") if err != nil { panic(err) } // Listen for Ctrl-C. c := make(chan os.Signal, 1) signal.Notify(c, os.Inter

有时候我们想给map分散到不同切片中,需要根据某个key算出自定义区间Murmur3 哈希算法 ,比md5快10倍速度func BenchmarkMurmur3(b *testing.B) { for i := 0; i < b.N; i++ { res2 := murmur3.Sum32([]byte("xxxxx"))%uint32(256) _ = res2 }}func BenchmarkIndexOf(b *testing.B) { for i := 0; i &lt

有时候我们修改了配置 json 或者 yaml 文件，需要校验下文件格式是否正确源码package mainimport ( "flag" "fmt" "github.com/ChengjinWu/gojson" "github.com/goccy/go-yaml" "io/ioutil" "os" "path/filepath")// GOOS=linux go build -x -v -ldflags "-s -w" -o gojson main.gofunc main(

定义类型为函数type Foo struct { name string id int age int db interface{}}// FooOption 代表可选参数type FooOption func(foo *Foo)// WithName 代表Name为可选参数func WithName(name string) FooOption { return func(foo *Foo) { foo.name = name }}// WithAg

进制之间转换1. 二进制转八进制 %b -> %o2. 二进制转十进制 %b -> %d3. 二进制转十六进制 %b -> %x4. 八进制转二进制 %o -> %b5. 八进制转十进制 %o -> %d6. 八进制转十六进制 %o -> %x7. 十进制转二进制 %d -> %b8. 十进制转八进制 %d -> %o9. 十进制转十六进制 %d -> %x10. 十六进制转二进制 %x -> %b11. 十六进制转八进

目的：有时候我们error 想带一些额外的信息，例如code码等这个时候我们就可以自定义error，实现go官方包接口如下代码package errnovar OK = &Errno{Code: 0, Message: "success"}type Errno struct { Code int32 Message string}func (c *Errno) Error() string { // 实现接口 return c.Message}func Ne

就像1000个人眼中有1000个哈姆雷特一样，每个人眼中的区块链也是不一样的！作为技术人员眼中的区块链就是将各种技术的融合，包括密码学，p2p网络，分布式共识机制以及博弈论等。我们今天就来讨论一下区块链技术中的p2p网络，这是一种点到点的通信技术。说到p2p通信，它并没有名字看上去那样简单，在网络世界里实现p2p还是需要一些手段的！很多朋友可能会说，实现一个c/s模式的点到点通信很简单呀，但是前提是彼此可以看见，比如服务器在公网，或者服务器和客户端都在同一个局域网内，我们要探讨的p2p通信是指通信的双方分

直接上代码func main(){ // ------------------------- 平滑重启 ----------------------- g := router.Load() // 这里的g 代表 *gin.Engine s := &http.Server{ Addr: ":" + viper.GetString("gin.port"), Handler: g, ReadTimeout: 10 * time.Second, //Wri

1.相关go代码 import _ "net/http/pprof" // 监听端口 func main(){ go func() { defer func() { if r := recover(); r != nil { log.Println(errors.New("灾难错误"), r) } }() http.ListenAndServe("0.0.0.0:8899", nil) }() ..... }2.访问链接http://127.0

package stringximport ( "encoding/hex" "math/rand" "time")var letters = []byte("abcdefghjkmnpqrstuvwxyz123456789")var longLetters = []byte("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") // 61func init() { rand.Seed(time.Now(

https://go.dev/doc/tutorial/generics

golang 批量导出csv文件

package mainimport ( "encoding/json" "github.com/Xuzan9396/zlog" "github.com/gin-gonic/gin" "github.com/panjf2000/ants/v2" "github.com/segmentio/ksuid" "github.com/spf13/pflag" "io/ioutil" "net/http" "os" "os/exec" "strings" "sync" "time")

使用buffer池子// 声明buffer var numCalcsCreated int32var numCalcsCreatedBuff int32func CreateBuffer() interface{} { atomic.AddInt32(&numCalcsCreatedBuff, 1) return new(bytes.Buffer)}func BufferPool() *sync.Pool { // 创建实例 return &sync.Pool{ Ne

1.各个类型占用字节数1.bit(位): 二进制数中的一个数位，可以是0或者1，是计算机中数据的最小单位。二进制的一个“0”或一个“1”叫一位2.Byte(字节): 计算机中数据的基本单位，每8位组成一个字节int8: 8位,就是一个字节int16: 2个字节int32: 4个字节int64:8个字节float32: 4个字节float64: 8 个字节int 比较特殊,占用多大取决于你的cpu32位cpu 就是 4个字节64位 就是 8 个字节float32: 4个字节float

func Test_xingneng(t *testing.T) { schedulerTimer := time.NewTimer(1*time.Second) // 调度延迟事件 deal := func() time.Duration { // 处理业务 rand.Seed(time.Now().UnixNano()) i := rand.Intn(2) if i == 0 { return 10 *time.Second }else{ return 5 *ti

时间大全转载 https://www.cnblogs.com/yinzhengjie/p/12244385.html

onepackage mainimport ( "fmt" "log" "math/rand" "time" "github.com/alitto/pond")func main() { // Create a buffered (non-blocking) pool that can scale up to 100 workers // and has a buffer capacity of 1000 tasks panicHandler := func(p interf

// 使用chan实现互斥锁type Mutex struct { ch chan struct{}}// 使用锁需要初始化func NewMutex() *Mutex { mu := &Mutex{make(chan struct{}, 1)} mu.ch <- struct{}{} return mu}// 请求锁，直到获取到func (m *Mutex) Lock() { <-m.ch}// 解锁func (m *.

package mainimport ( "fmt" "github.com/gammazero/workerpool" "time")func main() { wp := workerpool.New(2) requests := []string{"alpha", "beta", "gamma", "delta", "epsilon"} for _, r := range requests { wp.Submit( func(r string ) func(){

package mainimport ( "log" "sync" "sync/atomic" "time")// 一个功能更加强大的Oncetype Oncev2 struct { m sync.Mutex done uint32}// 传入的函数f有返回值error，如果初始化失败，需要返回失败的error// Do方法会把这个error返回给调用者func (o *Oncev2) Do(f func() error) error { if atomic.Load

package mainimport ( "golang.org/x/sync/singleflight" "log" "time")func main() { var singleSetCache singleflight.Group getAndSetCache := func(requestID int, cacheKey string) (string, error) { value, _, _ := singleSetCache.Do(cacheKey, func() (

// https://github.com/AaronJan/Hunchctx := context.Background()r, err := hunch.All( ctx, func(ctx context.Context) (interface{}, error) { time.Sleep(300 * time.Millisecond) return 1, nil }, func(ctx context.Context) (inter

package mainimport ( "context" "errors" "fmt" "github.com/vardius/gollback" "time")func main() { rs, errs := gollback.All( // 调用All方法 context.Background(), func(ctx context.Context) (interface{}, error) { time.Sleep(3 * tim.

package main; import ( "sync/atomic" "fmt" "sync") //atomic包提供了底层的原子级内存操作//类型共有六种：int32, int64, uint32, uint64, uintptr, unsafe.Pinter//操作共五种：增减， 比较并交换， 载入， 存储，交换 func main() { //增减操作 var a int32; fmt.Println("a : ", a);

type SliceQueue struct { data []interface{} mu sync.Mutex}func NewSliceQueue(n int) (q *SliceQueue) { return &SliceQueue{data: make([]interface{}, 0, n)}}// Enqueue 把值放在队尾func (q *SliceQueue) Enqueue(v interface{}) { q.mu.Lock.

package mainimport ( "fmt" "unsafe")func main() { var x struct { a int b int c []int } x.b = 2 // unsafe.Offsetof 函数的参数必须是一个字段, 比如 x.b, 方法会返回 b 字段相对于 x 起始地址的偏移量, 包括可能的空洞。 //pb := &x.b //等价pb := (*int)(unsafe.Pointer(uintptr(unsafe.Point

package mainimport ( "github.com/petermattis/goid" "log" "sync" "sync/atomic" "time" "unsafe")// 复制Mutex定义的常量const ( mutexLocked = 1 << iota // 加锁标识位置 mutexWoken // 唤醒标识位置 mutexStarving // 锁饥饿标识位置 mutexWaiterSh

处理channel 100条数据写入一批数据，超过1s自动提交package mainimport ( "io" "log" "math/rand" "os" "strconv" "strings" "time")type LogBatch struct { Logs []string}type LogSink struct { logChan chan string autoCommitChan chan *LogBatch // 超时通知}fu

参数 · net.Dialer.Timeout 限制创建一个TCP连接使用的时间（如果需要一个新的链接） · http.Transport.TLSHandshakeTimeout 限制TLS握手使用的时间 · http.Transport.ResponseHeaderTimeout 限制读取响应报文头使用的时间 · http.Transport.ExpectContinueTimeout 限制客户端在发送一个包含：100-continue的http报文头后，等待收到一个go-ahead响应报

原子操作 var a int32 for i := 1;i <= 1000;i++{ go func(a *int32, i int) { rs := atomic.AddInt32(a, 1) defer atomic.AddInt32(a, -1) if i%2 == 0{ time.Sleep(1*time.Second) } if rs != 1 { //*a += 1 //defer func() { // *a -= 1

转载链接地址

代码buf:=strings.Builder{} buf.WriteString("1") buf.WriteString("+") buf.WriteString("2") dest:= buf.String() t.Log(dest) 结果: 1+2

转载读取三种文件方式 https://mp.weixin.qq.com/s/g3my_daXI-uYwSa0PBN0VA

golang qq滑块完整代码package mainimport ( "bytes" "github.com/go-rod/rod" "github.com/go-rod/rod/lib/devices" "github.com/go-rod/rod/lib/launcher" "github.com/nfnt/resize" "image/jpeg" "io/ioutil" "log" "math" "net/http" "strings" "time" "fmt")

gopath管理项目工程目录src下编写你的代码，配置gopath 为当前目录，src 下面会生成当前的第三方依赖包设置环境代理macexport GOPROXY="https://goproxy.cn,direct"windows 执行set GOPROXY="https://goproxy.cn,direct"依赖管理下载所有依赖包go get -d -v ./...最后可以运行你的项目了！...