LRU缓存链表实现思路

March 22, 2018 · One min read

LRU缓存链表实现思路

assets

./LRUMap.java

build

CGO_ENABLED=0 GOOS=linux go build -v -installsuffix cgo -o wolan-ingress

## 生成 dll
# 生成 .so .h
go build -o libddd.so -buildmode=c-shared main.go
# go build -ldflags "-s -w" -o libdemo.dll -buildmode=c-shared main.go
# ldflags "-s -w" -s -w 选项用于减小生成动态链接库的体积，-s 是压缩，-w 是去掉调试信息
# c 连接 lib
gcc test.c -L ./ -lddd -o test
# 默认使用 /usr/lib，临时env
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:. ./test

# 生成静态库
c-archive

blog

[译]Go文件操作大全 http://colobu.com/2016/10/12/go-file-operations
[转]Golang资料集 https://gocn.io/article/65
Go 的构建模式 https://blog.lab99.org/post/golang-2017-10-01-video-go-build-mode.html
视频笔记：gRPC 从学习到生产 https://blog.lab99.org/post/golang-2017-09-27-video-grpc-from-tutorial-to-production.html
tonybai http://tonybai.com
Go程序设计语言(二) http://tonybai.com/2012/08/27/the-go-programming-language-tutorial-part2/
Go程序设计语言(三) http://tonybai.com/2012/08/28/the-go-programming-language-tutorial-part3/

awesome

中文 https://github.com/hackstoic/golang-open-source-projects
Go by Example 中文版 https://gobyexample-cn.github.io/

env

-GOPATH z:\www  下面会自动src bin
go env -w GOPROXY=https://goproxy.cn/,direct
GOPATH=~/Desktop/www
GOPATH=~/Desktop/www GOPROXY=https://goproxy.cn,direct go get -v golang.org/x/tools/cmd/goimports

install liunx

wget https://storage.googleapis.com/golang/go1.17.5.linux-amd64.tar.gz
tar -xvf go1.8.1.linux-amd64.tar.gz -C /usr/local/
sudo vi /etc/profile
export GOROOT=/usr/local/go
export GOPATH=/go # bin pkg src
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

go env -w GOPROXY=https://goproxy.cn/,direct

git clone https://github.com/golang/text.git $GOPATH/src/golang.org/x/text

下载

https://golang.org/dl/

go 性能跟踪

March 20, 2018 · One min read

视频笔记：7种 Go 程序性能分析方法 - Dave Cheney https://blog.lab99.org/post/golang-2017-10-20-video-seven-ways-to-profile-go-apps.html
[译] Go 可视化性能分析工具 https://colobu.com/2017/03/02/a-short-survey-of-golang-pprof/

pprof

brew install gperftools
brew install graphviz

import _ "net/http/pprof"

http://localhost:1777/debug/pprof/
http://localhost:1777/debug/pprof/profile

go tool pprof http://localhost:1777/debug/pprof/profile

go-torch

go get github.com/uber/go-torch
cd $GOPATH/src/github.com/uber/go-torch
git clone https://github.com/brendangregg/FlameGraph.git

go-torch --file "profile" --url http://localhost:2345
go-torch -u http://localhost:1777/

go 远程执行

March 20, 2018 · 5 min read

远程执行命令有什么用？为什么要远程执行命令？如果你只有2，3台服务器需要管理的时候，远程执行命令确实没有没多大作用，你可以登录到每台服务器上去完成各种操作。当你的服务器大于3台的时候，远程执行的命令的方式就可以大大提高你的生产力了。

如果你有一个可以远程执行命令的工具，那么就可以像操作单台机器那样操作多台机器，机器越多，效率提高的越多。远程执行命令最常用的方法就是利用 SSH 协议，将命令发送到远程机器上执行，并获取返回结果。

本文介绍如何使用 golang 实现远程执行命令。

一般命令

所谓一般命令，就是在一定时间内会执行完的命令。比如 grep, cat 等等。执行命令的步骤是：连接，执行，获取结果

连接

连接包含了认证，可以使用 password 或者 sshkey 2种方式来认证。下面的示例为了简单，使用了密码认证的方式来完成连接。

import (  
  "fmt"
  "time"

  "golang.org/x/crypto/ssh"
)

func connect(user, password, host string, port int) (*ssh.Session, error) {  
  var (
    auth         []ssh.AuthMethod
    addr         string
    clientConfig *ssh.ClientConfig
    client       *ssh.Client
    session      *ssh.Session
    err          error
  )
  // get auth method
  auth = make([]ssh.AuthMethod, 0)
  auth = append(auth, ssh.Password(password))

  clientConfig = &ssh.ClientConfig{
    User:    user,
    Auth:    auth,
    Timeout: 30 * time.Second,
  }

  // connet to ssh
  addr = fmt.Sprintf("%s:%d", host, port)

  if client, err = ssh.Dial("tcp", addr, clientConfig); err != nil {
    return nil, err
  }

  // create session
  if session, err = client.NewSession(); err != nil {
    return nil, err
  }

  return session, nil
}

连接的方法很简单，只要提供登录主机的用户，密码， 主机名或者IP SSH端口

执行，命令获取结果

连接成功后，执行命令很简单

import (  
  "fmt"
  "log"
  "os"
  "time"

  "golang.org/x/crypto/ssh"
)

func main() {  
  session, err := connect("root", "xxxxx", "127.0.0.1", 22)
  if err != nil {
    log.Fatal(err)
  }
  defer session.Close()

  session.Run("ls /; ls /abc")
}

上面代码运行之后，虽然命令正常执行了，但是没有正常输出的结果，也没有异常输出的结果。要想显示结果，需要将 session 的 Stdout 和 Stderr 重定向修改 func main 为如下：

func main() {  
  session, err := connect("root", "xxxxx", "127.0.0.1", 22)
  if err != nil {
    log.Fatal(err)
  }
  defer session.Close()

  session.Stdout = os.Stdout
  session.Stderr = os.Stderr
  session.Run("ls /; ls /abc")
}

这样就能在屏幕上显示正常，异常的信息了。

交互式命令

上面的方式无法远程执行交互式命令，比如 top ，远程编辑一个文件，比如 vi /etc/nginx/nginx.conf 如果要支持交互式的命令，需要当前的terminal来接管远程的 PTY。

package main

import (
  "fmt"
  "log"
  "os"
  "time"

  "golang.org/x/crypto/ssh"
  "golang.org/x/crypto/ssh/terminal"
)

func connect(user, password, host string, port int) (*ssh.Session, error) {
  var (
    auth         []ssh.AuthMethod
    addr         string
    clientConfig *ssh.ClientConfig
    client       *ssh.Client
    session      *ssh.Session
    err          error
  )
  // get auth method
  auth = make([]ssh.AuthMethod, 0)
  auth = append(auth, ssh.Password(password))
  clientConfig = &ssh.ClientConfig{
    User:    user,
    Auth:    auth,
    Timeout: 30 * time.Second,
  }
  // connet to ssh
  addr = fmt.Sprintf("%s:%d", host, port)
  if client, err = ssh.Dial("tcp", addr, clientConfig); err != nil {
    return nil, err
  }
  // create session
  if session, err = client.NewSession(); err != nil {
    return nil, err
  }
  return session, nil
}

func main() {
  session, err := connect("root", "123", "139.196.14.10", 22)
  if err != nil {
    log.Fatal(err)
  }
  defer session.Close()

  fd := int(os.Stdin.Fd())
  oldState, err := terminal.MakeRaw(fd)
  if err != nil {
    panic(err)
  }
  defer terminal.Restore(fd, oldState)
  // excute command
  session.Stdout = os.Stdout
  session.Stderr = os.Stderr
  session.Stdin = os.Stdin
  termWidth, termHeight, err := terminal.GetSize(fd)
  if err != nil {
    panic(err)
  }
  // Set up terminal modes
  modes := ssh.TerminalModes{
    ssh.ECHO:          1,     // enable echoing
    ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
    ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
  }
  // Request pseudo terminal
  if err := session.RequestPty("xterm", termHeight, termWidth, modes); err != nil {
    log.Fatal(err)
  }
  session.Run("htop")
}

这样就可以执行交互式命令了，比如上面的 top 也可以通过 vi /etc/nginx/nignx.conf 之类的命令来远程编辑文件。

Go语言中的并发编程总结

March 20, 2018 · 23 min read

Go语言中的并发编程总结

https://jimmysong.io/posts/golang-concurrency-summary/

Go语言并发编程总结

Golang :不要通过共享内存来通信，而应该通过通信来共享内存。这句风靡在Go社区的话,说的就是 goroutine中的 channel。他在go并发编程中充当着类型安全的管道作用。

1、通过golang中的 goroutine 与sync.Mutex进行并发同步

import( 

    "fmt"

    "sync"

    "runtime"

)

var count int =0;

func counter(lock * sync.Mutex){

      lock.Lock()

      count++

      fmt.Println(count)

      lock.Unlock()

}

func main(){

   lock:=&sync.Mutex{}

   for i:=0;i<10;i++{

      //传递指针是为了防止 函数内的锁和 调用锁不一致

      go counter(lock)  

     }

   for{

      lock.Lock()

      c:=count

      lock.Unlock()

      ///把时间片给别的goroutine  未来某个时刻运行该routine

      runtime.Gosched()

      if c>=10{

        fmt.Println("goroutine end")

        break

        }

   }    

}

2、goroutine之间通过 channel进行通信

channel是和类型相关的可以理解为是一种类型安全的管道。

简单的channel 使用

package main  

import "fmt"

func Count(ch chan int) {

    ch <- 1  

    fmt.Println("Counting")

}

func main() {

    chs := make([]chan int, 10)

for i := 0; i < 10; i++ {

        chs[i] = make(chan int)

  go Count(chs[i])

  fmt.Println("Count",i)

    }

for i, ch := range chs {

  <-ch

  fmt.Println("Counting",i)

    }  

}

3、Go语言中的select是语言级内置非堵塞

select {

case <-chan1: // 如果chan1成功读到数据，则进行该case处理语句  

case chan2 <- 1: // 如果成功向chan2写入数据，则进行该case处理语句  

default: // 如果上面都没有成功，则进入default处理流程  

}

可以看出，select不像switch，后面并不带判断条件，而是直接去查看case语句。每个

case语句都必须是一个面向channel的操作。比如上面的例子中，第一个case试图从chan1读取

一个数据并直接忽略读到的数据，而第二个case则是试图向chan2中写入一个整型数1，如果这

两者都没有成功，则到达default语句。

4、channel 的带缓冲读取写入

之前我们示范创建的都是不带缓冲的channel，这种做法对于传递单个数据的场景可以接受，

但对于需要持续传输大量数据的场景就有些不合适了。接下来我们介绍如何给channel带上缓冲，

从而达到消息队列的效果。

要创建一个带缓冲的channel，其实也非常容易：

c := make(chan int, 1024)

在调用make()时将缓冲区大小作为第二个参数传入即可，比如上面这个例子就创建了一个大小

为1024的int类型channel，即使没有读取方，写入方也可以一直往channel里写入，在缓冲区被

填完之前都不会阻塞。

从带缓冲的channel中读取数据可以使用与常规非缓冲channel完全一致的方法，但我们也可

以使用range关键来实现更为简便的循环读取：

for i := range c {

    fmt.Println("Received:", i)

} 

5、用goroutine模拟生产消费者

package main

import "fmt"

import "time"

func Producer (queue chan<- int){

        for i:= 0; i < 10; i++ {

                queue <- i  

                }

}

func Consumer( queue <-chan int){

        for i :=0; i < 10; i++{

                v := <- queue

                fmt.Println("receive:", v)

        }

}

func main(){

        queue := make(chan int, 1)

        go Producer(queue)

        go Consumer(queue)

        time.Sleep(1e9) //让Producer与Consumer完成

}

6、通过make 创建通道

make(c1 chan int)   创建的是 同步channel ...读写完全对应

make(c1 chan int ,10) 闯进带缓冲的通道 上来可以写10次

7、随机向通道中写入0或者1

package main

import "fmt"

import "time"

func main(){

       ch := make(chan int, 1)

 for {

   ///不停向channel中写入 0 或者1

  select {

   case ch <- 0:

   case ch <- 1:

  }

    //从通道中取出数据

    i := <-ch

    fmt.Println("Value received:",i)

    time.Sleep(1e8)

    }

}

8、带缓冲的channel

之前创建的都是不带缓冲的channel，这种做法对于传递单个数据的场景可以接受，

但对于需要持续传输大量数据的场景就有些不合适了。接下来我们介绍如何给channel带上缓冲，

从而达到消息队列的效果。

要创建一个带缓冲的channel，其实也非常容易：

c := make(chan int, 1024)

在调用make()时将缓冲区大小作为第二个参数传入即可，比如上面这个例子就创建了一个大小

为1024的int类型channel，即使没有读取方，写入方也可以一直往channel里写入，在缓冲区被

填完之前都不会阻塞。

从带缓冲的channel中读取数据可以使用与常规非缓冲channel完全一致的方法，但我们也可

以使用range关键来实现更为简便的循环读取：

for i := range c {

    fmt.Println("Received:", i)

}

下面是测试代码‘

package main

import "fmt"

import "time"

func A(c chan int){

 for i:=0;i<10;i++{

        c<- i

    }

}

func B(c chan int){

 for val:=range c {

      fmt.Println("Value:",val)  

    }

}

func main(){

    chs:=make(chan int,10)

    //只要有通道操作一定要放到goroutine中否则 会堵塞当前的主线程 并且导致程序退出

    //对于同步通道 或者带缓冲的通道 一定要封装成函数 使用 goroutine 包装

    go A(chs)

    go B(chs)

    time.Sleep(1e9)

}

9、关于创建多个goroutine具体到go语言会创建多少个线程

import "os"

func main() {

    for i:=0; i<20; i++ {

        go func() {

            for {

                b:=make([]byte, 10)

                os.Stdin.Read(b) // will block

            }

        }()

    }

    select{}

}

会产生21个线程：

runtime scheduler(src/pkg/runtime/proc.c)会维护一个线程池，当某个goroutine被block后，scheduler会创建一个新线程给其他ready的goroutine

GOMAXPROCS控制的是未被阻塞的所有goroutine被multiplex到多少个线程上运行

10、在channel中也是可以传递channel的,Go语言的channel和map、slice等一样都是原生类型

需要注意的是，在Go语言中channel本身也是一个原生类型，与map之类的类型地位一样，因

此channel本身在定义后也可以通过channel来传递。

我们可以使用这个特性来实现lunix上非常常见的管道（pipe）特性。管道也是使用非常广泛

的一种设计模式，比如在处理数据时，我们可以采用管道设计，这样可以比较容易以插件的方式

增加数据的处理流程。

下面我们利用channel可被传递的特性来实现我们的管道。为了简化表达，我们假设在管道中

传递的数据只是一个整型数，在实际的应用场景中这通常会是一个数据块。

首先限定基本的数据结构：

type PipeData struct {

    value int

    handler func(int) int

    next chan int

}

然后我们写一个常规的处理函数。我们只要定义一系列PipeData的数据结构并一起传递给

这个函数，就可以达到流式处理数据的目的：

func handle(queue chan *PipeData) {

for data := range queue {

        data.next <- data.handler(data.value)

    }

}

11、我们默认创建的是双向通道,单向通道没有意义,但是我们却可以通过强制转换将双向通道转换成为单向通道。

var ch1 chan int  // ch1是一个正常的channel，不是单向的  

var ch2 chan<- float64// ch2是单向channel，只用于写float64数据

var ch3 <-chan int // ch3是单向channel，只用于读取int数据 

channel是一个原生类型，因此不仅支持被传递，还支持类型转换。只有在介绍了单向channel的概念后，读者才会明白类型转换对于

channel的意义：就是在单向channel和双向channel之间进行转换。

示例如下：

ch4 := make(chan int)

ch5 := <-chan int(ch4) // ch5就是一个单向的读取channel

ch6 := chan<- int(ch4) // ch6 是一个单向的写入channel

基于ch4，我们通过类型转换初始化了两个单向channel：单向读的ch5和单向写的ch6。

从设计的角度考虑，所有的代码应该都遵循“最小权限原则” ，

从而避免没必要地使用泛滥问题，进而导致程序失控。写过C++程序的读者肯定就会联想起const 指针的用法。非const指针具备const指针的所有功能，将一个指针设定为const就是明确告诉

函数实现者不要试图对该指针进行修改。单向channel也是起到这样的一种契约作用。

下面我们来看一下单向channel的用法：

func Parse(ch <-chan int) {

for value := range ch {

        fmt.Println("Parsing value", value)  

    }

}

除非这个函数的实现者无耻地使用了类型转换，否则这个函数就不会因为各种原因而对ch 进行写，避免在ch中出现非期望的数据，从而很好地实践最小权限原则。

12、只读只写单向 channel 代码例子，遵循权限最小化的原则

package main

import "fmt"

import "time"

//接受一个参数 是只允许读取通道  除非直接强制转换 要么你只能从channel中读取数据

func sCh(ch <-chan int){

   for val:= range ch {

     fmt.Println(val)

   }

}

func main(){

    //创建一个带100缓冲的通道 可以直接写入 而不会导致 主线程堵塞

    dch:=make(chan int,100)

    for i:=0;i<100;i++{

      dch<- i  

    }

    //传递进去 只读通道

    go sCh(dch)

    time.Sleep(1e9)

}

13、channel的关闭,以及判断channel的关闭

关闭channel非常简单，直接使用Go语言内置的close()函数即可：

close(ch)

在介绍了如何关闭channel之后，我们就多了一个问题：如何判断一个channel是否已经被关

闭？我们可以在读取的时候使用多重返回值的方式：

x, ok := <-ch

这个用法与map中的按键获取value的过程比较类似，只需要看第二个bool返回值即可，如

果返回值是false则表示ch已经被关闭。

14、Go的多核并行化编程

高性能并发编程必须设置GOMAXPROCS 为最大核数目,这个值由runtime.NumCPU()获取

在执行一些昂贵的计算任务时，我们希望能够尽量利用现代服务器普遍具备的多核特性来尽

量将任务并行化，从而达到降低总计算时间的目的。此时我们需要了解CPU核心的数量，并针对

性地分解计算任务到多个goroutine中去并行运行。

下面我们来模拟一个完全可以并行的计算任务：计算N个整型数的总和。我们可以将所有整

型数分成M份，M即CPU的个数。让每个CPU开始计算分给它的那份计算任务，最后将每个CPU

的计算结果再做一次累加，这样就可以得到所有N个整型数的总和：

type Vector []float64

// 分配给每个CPU的计算任务

func (v Vector) DoSome(i, n int, u Vector, c chan int) {

for ; i < n; i++ {

         v[i] += u.Op(v[i])

     }

     c <- 1       

// 发信号告诉任务管理者我已经计算完成了

}

const NCPU = 16     

// 假设总共有16核   

func (v Vector) DoAll(u Vector) {   

    c := make(chan int, NCPU)  // 用于接收每个CPU的任务完成信号   

for i := 0; i < NCPU; i++ {   

go v.DoSome(i*len(v)/NCPU, (i+1)*len(v)/NCPU, u, c)

    } 

// 等待所有CPU的任务完成

for i := 0; i < NCPU; i++ {   

<-c    // 获取到一个数据，表示一个CPU计算完成了

    }

// 到这里表示所有计算已经结束

}

这两个函数看起来设计非常合理。DoAll()会根据CPU核心的数目对任务进行分割，然后开

辟多个goroutine来并行执行这些计算任务。

是否可以将总的计算时间降到接近原来的1/N呢？答案是不一定。如果掐秒表（正常点的话，

应该用7.8节中介绍的Benchmark方法），会发现总的执行时间没有明显缩短。再去观察CPU运行

状态，你会发现尽管我们有16个CPU核心，但在计算过程中其实只有一个CPU核心处于繁忙状态，

这是会让很多Go语言初学者迷惑的问题。

官方的答案是，这是当前版本的Go编译器还不能很智能地去发现和利用多核的优势。虽然

我们确实创建了多个goroutine，并且从运行状态看这些goroutine也都在并行运行，但实际上所有

这些goroutine都运行在同一个CPU核心上，在一个goroutine得到时间片执行的时候，其他goroutine

都会处于等待状态。从这一点可以看出，虽然goroutine简化了我们写并行代码的过程，但实际上

整体运行效率并不真正高于单线程程序。

在Go语言升级到默认支持多CPU的某个版本之前，我们可以先通过设置环境变量

GOMAXPROCS的值来控制使用多少个CPU核心。具体操作方法是通过直接设置环境变量

GOMAXPROCS的值，或者在代码中启动goroutine之前先调用以下这个语句以设置使用16个CPU

核心：

runtime.GOMAXPROCS(16)

到底应该设置多少个CPU核心呢，其实runtime包中还提供了另外一个函数NumCPU()来获

取核心数。可以看到，Go语言其实已经感知到所有的环境信息，下一版本中完全可以利用这些

信息将goroutine调度到所有CPU核心上，从而最大化地利用服务器的多核计算能力。抛弃

GOMAXPROCS只是个时间问题。

15、主动出让时间片给其他 goroutine 在未来的某一时刻再来执行当前goroutine

我们可以在每个goroutine中控制何时主动出让时间片给其他goroutine，这可以使用runtime

包中的Gosched()函数实现。

实际上，如果要比较精细地控制goroutine的行为，就必须比较深入地了解Go语言开发包中

runtime包所提供的具体功能。

16、Go中的同步

倡导用通信来共享数据，而不是通过共享数据来进行通信，但考虑

到即使成功地用channel来作为通信手段，还是避免不了多个goroutine之间共享数据的问题，Go

语言的设计者虽然对channel有极高的期望，但也提供了妥善的资源锁方案。

17、Go中的同步锁

倡导用通信来共享数据，而不是通过共享数据来进行通信，但考虑

到即使成功地用channel来作为通信手段，还是避免不了多个goroutine之间共享数据的问题，Go

语言的设计者虽然对channel有极高的期望，但也提供了妥善的资源锁方案。

对于这两种锁类型，任何一个Lock()或RLock()均需要保证对应有Unlock()或RUnlock()

调用与之对应，否则可能导致等待该锁的所有goroutine处于饥饿状态，甚至可能导致死锁。锁的

典型使用模式如下：

var l sync.Mutex

func foo() {

l.Lock()

//延迟调用在函数退出并且局部资源被释放的时候调用

defer l.Unlock()

//…

}

这里我们再一次见证了Go语言defer关键字带来的优雅

18、全局唯一操作 sync.Once.Do() sync.atomic原子操作子包

对于从全局的角度只需要运行一次的代码，比如全局初始化操作，Go语言提供了一个Once

类型来保证全局的唯一性操作，具体代码如下：

var a string

var once sync.Once  

func setup() {

a = "hello, world"

}  

func doprint() {

once.Do(setup)

print(a)  

}  

func twoprint() {

go doprint()

go doprint()  

}

如果这段代码没有引入Once， setup()将会被每一个goroutine先调用一次，这至少对于这个

例子是多余的。在现实中，我们也经常会遇到这样的情况。Go语言标准库为我们引入了Once类

型以解决这个问题。once的Do()方法可以保证在全局范围内只调用指定的函数一次（这里指

setup()函数），而且所有其他goroutine在调用到此语句时，将会先被阻塞，直至全局唯一的

once.Do()调用结束后才继续。

这个机制比较轻巧地解决了使用其他语言时开发者不得不自行设计和实现这种Once效果的

难题，也是Go语言为并发性编程做了尽量多考虑的一种体现。

如果没有once.Do()，我们很可能只能添加一个全局的bool变量，在函数setup()的最后

一行将该bool变量设置为true。在对setup()的所有调用之前，需要先判断该bool变量是否已

经被设置为true，如果该值仍然是false，则调用一次setup()，否则应跳过该语句。实现代码

var done bool = false

func setup() {

a = "hello, world" 

done = true

}     

func doprint() { 

if !done {

        setup()

    }   

print(a)  

}

这段代码初看起来比较合理，但是细看还是会有问题，因为setup()并不是一个原子性操作，

这种写法可能导致setup()函数被多次调用，从而无法达到全局只执行一次的目标。这个问题的

复杂性也更加体现了Once类型的价值。

为了更好地控制并行中的原子性操作，sync包中还包含一个atomic子包，它提供了对于一

些基础数据类型的原子操作函数，比如下面这个函数：

func CompareAndSwapUint64(val *uint64, old, new uint64) (swapped bool)

就提供了比较和交换两个uint64类型数据的操作。这让开发者无需再为这样的操作专门添加Lock操作。

原文链接

cgo

March 20, 2018 · One min read

golang生成.a文件被C调用遇到的坑 https://www.jianshu.com/p/dafc3ac76d9c

生成.a .h

go build -buildmode=c-archive -o liba.a liba.go

build

gcc liba.c liba.a -o liba
./liba

./liba.c ./liba.go

web

./simple_web.go

cpu_test.go

package temp

import "testing"

func Fib(n int) int {
    switch n {
    case 0:
        return 0
    case 1:
        return 1
    default:
        return Fib(n-1) + Fib(n-2)
    }
}

func BenchmarkFib(b *testing.B) {
    for n := 0; n < b.N; n++ {
        Fib(20)
    }
}

原型

prototype 1

package main

import "fmt"

type ISpeaker interface {
    Speak()
    Change(string)
}

type SimpleSpeaker struct {
    Message string
}

func (this *SimpleSpeaker) Speak() {
    fmt.Println("I am", this.Message)
}

func (this *SimpleSpeaker) Change(a string) {
    this.Message = this.Message + " " + a
}

func main() {
    var speaker ISpeaker
    speaker = &SimpleSpeaker{"abc"}
    speaker.Speak()
    speaker.Change("change")
    speaker.Speak()
    fmt.Printf("%T", speaker)
}

prototype 2 继承

package main

import "fmt"

type IReadWriter interface {
    Read(buf *byte, cb int) int
    Write(buf *byte, cb int) int
}

type A struct {
    a int
}

func NewA(params int) *A {
    fmt.Println("NewA:", params)
    return &A{params}
}

func (this *A) Read(buf *byte, cb int) int {
    fmt.Println("A_Read:", this.a)
    return cb
}

func (this *A) Write(buf *byte, cb int) int {
    fmt.Println("A_Write:", this.a)
    return cb
}

type B struct {
    A
}

func NewB(params int) *B {
    fmt.Println("NewB:", params)
    return &B{A{params}}
}

func (this *B) Write(buf *byte, cb int) int {
    fmt.Println("B_Write", this.a)
    return cb
}
func (this *B) Foo() {
    fmt.Println("B_Foo:", this.a)
}

func main() {
    var p IReadWriter = NewB(8)
    p.Read(nil, 10)
    p.Write(nil, 10)
}

cli call linux

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("ls", "-l")
    stdout, _ := cmd.CombinedOutput()

    o := string(stdout)
    fmt.Printf("%T => %v \n", o, o)
}

https

//openssl genrsa -des3 -out server.key 2048
//openssl rsa -in server.key -out server.key
//openssl req -new -x509 -key server.key -out server.crt -days 3650

//openssl genrsa -des3 -out server.key 2048
//openssl req -new -key server.key -out server.csr
//openssl req -new -x509 -key server.key -out ca.crt -days 3650
//openssl x509 -req -days 3650 -in server.csr   -CA ca.crt -CAkey server.key   -CAcreateserial -out server.crt
package main

import (
    "net/http"
)

func main() {
    h := http.FileServer(http.Dir("."))
    http.ListenAndServeTLS(":443", "server.crt", "server.key", h)
}

快速排序

// go run sorter.go -i 1.dat -o 2.dat -a bubblesort
package main

import (
    "algorithms/bubblesort"
    "algorithms/qsort"
    "bufio"
    "flag"
    "fmt"
    "io"
    "os"
    "strconv"
    "time"
)

var infile *string = flag.String("i", "infile", "File contains values for sorting")
var outfile *string = flag.String("o", "outfile", "File to receive sorted values")
var algorithm *string = flag.String("a", "qsort", "Sort algorithm")

func main() {
    flag.Parse()
    if infile != nil {
        fmt.Println("infile =", *infile, "outfile =", *outfile, "algorithm =", *algorithm)
    }

    values, err := readValues(*infile)
    if err == nil {
        fmt.Println("Read values:", values)

        t1 := time.Now()

        switch *algorithm {
        case "qsort":
            qsort.QuickSort(values)
        case "bubblesort":
            bubblesort.BubbleSort(values)
        }

        t2 := time.Now()

        fmt.Println("spend", t2.Sub(t1), "to comlpete")
        fmt.Println("End values:", values)
        writeValues(values, "2.dat")
    } else {
        fmt.Println(err)
    }
}

func readValues(infile string) (values []int, err error) {
    file, err := os.Open(infile)
    if err != nil {
        return
    }
    defer file.Close()

    br := bufio.NewReader(file)

    values = make([]int, 0)

    for {
        line, isPerfix, err1 := br.ReadLine()
        if err1 != nil {
            if err1 != io.EOF {
                err = err1
            }
            break
        }
        if isPerfix {
            return
        }
        str := string(line)
        value, err1 := strconv.Atoi(str)
        if err1 != nil {
            err = err1
            return
        }
        values = append(values, value)
    }

    return
}

func writeValues(values []int, outfile string) error {
    file, err := os.Create(outfile)
    if err != nil {
        return err
    }

    defer file.Close()

    for _, value := range values {
        str := strconv.Itoa(value)
        file.WriteString(str + "\n")
    }

    return nil
}

web-staging.go

package main

import (
    "fmt"
    "html/template"
    "io/ioutil"
    "log"
    "net/http"
    "os/exec"
    "path"
)

const (
    TEMPLATTE_DIR = "./views"
    // TEMPLATTE_DIR = ""
)

var templates map[string]*template.Template

func init() {
    fileInfoArr, err := ioutil.ReadDir(TEMPLATTE_DIR)
    check(err)

    templates = make(map[string]*template.Template)
    var templateName, templatePath string
    for _, fileInfo := range fileInfoArr {
        templateName = fileInfo.Name()
        if ext := path.Ext(templateName); ext != ".html" {
            continue
        }
        templatePath = TEMPLATTE_DIR + "/" + templateName
        log.Println("Loading template: ", templatePath)
        t := template.Must(template.ParseFiles(templatePath))
        templates[templatePath] = t
    }
    for _, a := range templates {
        log.Printf("%v", a)
    }
}

func check(err error) {
    if err != nil {
        panic(err)
    }
}

func readerHtml(w http.ResponseWriter, tmpl string, locals map[string]interface{}) {
    tmpl = TEMPLATTE_DIR + "/" + tmpl + ".html"
    err := templates[tmpl].Execute(w, locals)
    check(err)
}

func aHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method == "GET" {
        readerHtml(w, "index", nil)
    }
    if r.Method == "POST" {
        branch_name := r.FormValue("branch_name")
        staging_id := r.FormValue("staging_id")

        if branch_name == "" {
            fmt.Fprintf(w, "error")
            return
        }

        _dostr := ""
        // _dostr += "cd /Users/a111111/Desktop/www/kreport && "
        _dostr += "cd /data/deployment/echo-web-staging/echo-web && "
        _dostr += "git fetch --prune origin && "
        _dostr += "git checkout " + branch_name + " && "
        _dostr += "git pull && "
        _dostr += "echo 'git status' && "
        _dostr += "git status && "
        _dostr += "../staging_deploy_echo_web.sh " + staging_id + ";"
        cmd, _ := exec.Command("/bin/sh", "-c", _dostr).Output()

        locals := make(map[string]interface{})
        locals["log"] = string(cmd)
        readerHtml(w, "done", locals)
    }
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", aHandler)
    err := http.ListenAndServe(":10080", mux)
    if err != nil {
        log.Fatal("ListenAndServe: ", err.Error())
    }
}

pipeline,steam归并排序，imooc视频

March 20, 2018 · One min read

./cmd/pipeline-demo/main.go

doc

MYSQL最朴素的监控方式状态指标 https://mp.weixin.qq.com/s/J7R8eJY8pNOnxLBOeSRlgA
无限容量数据库架构设计 https://mp.weixin.qq.com/s/ad4tpM6cdi9r6vgfbaTzxg

时区

select now(); set global time_zone = '+8:00';

commit 查看未提交事务

https://blog.csdn.net/u013235478/article/details/68062939 select trx_state, trx_started, trx_mysql_thread_id, trx_query from information_schema.innodb_trx; show global variables LIKE '%wait_timeout%';

processlist

docker

docker run --restart=unless-stopped --name mysql-1 -it -d \
  -v "$PWD":/var/lib/mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=12341234 -e TZ=Asia/Shanghai mysql:8.0.15 \
  --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci
docker run --restart=unless-stopped --name mysql-1 -it -d \
  -v "$PWD":/var/lib/mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=12341234 -e TZ=Asia/Shanghai mysql:8.0.15 \
  --character-set-server=utf8 --collation-server=utf8_general_ci
docker run --restart=unless-stopped --name mysql-1 -it -d \
  -v "$PWD":/var/lib/mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=12341234 -e TZ=Asia/Shanghai mysql:5.7.25 \
  --character-set-server=utf8 --collation-server=utf8_general_ci

# 导入 sql
docker exec -i gimclocal_svc-mysql-1_1 sh -c 'exec mysql -uroot -p"1234@1234"' < config/20221027.sql

# 加user https://www.cnblogs.com/xujishou/p/6306765.html
CREATE DATABASE IF NOT EXISTS `{$bundle}-app-test` default charset utf8 COLLATE utf8_general_ci;
grant all privileges on `{$bundle}-app-test`.* to `{$bundle}-app`@'%' identified by 'Abc.1234';
grant select on `gimc-prod`.* to `gtest`@'%';
grant select on `gimc-prod\_%`.* to `gtest`@'%';

# 修改时区
cp /usr/share/zoneinfo/GMT /etc/localtime
cp /usr/share/zoneinfo/PRC /etc/localtime
docker cp /etc/localtime mysql-1:/etc/localtime
docker cp /usr/share/zoneinfo/PRC mysql-1:/etc/localtime

SHOW VARIABLES LIKE 'character%';

# cnf
/etc/mysql/mysql.conf.d/mysqld.cnf
/etc/mysql/my.cnf

show tables;
show table status; # 大小行数more

table

CREATE TABLE `table_demo`
(
    `id`         int(11)    NOT NULL AUTO_INCREMENT,
    `status`     tinyint(1) NOT NULL DEFAULT '1' COMMENT '状态',
    `created_at` timestamp  NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `updated_at` timestamp  NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8 COMMENT ='参考';

optmize + repair

#!/bin/bash

host_name=localhost  
user_name=haohe_club  
user_pwd=iy9nPKJV   
database=club  
need_optmize_table=true  
tables=$(mysql -h$host_name -u$user_name -p$user_pwd $database -A -Bse "show tables")  

for table_name in $tables  
do  
  check_result=$(mysql -h$host_name -u$user_name -p$user_pwd $database -A -Bse "check table $table_name" | awk '{ print $4 }')  
  if [ "$check_result" = "OK" ]  
  then  
    echo "It's no need to repair table $table_name"  
  else  
    echo $(mysql -h$host_name -u$user_name -p$user_pwd $database -A -Bse "repair table $table_name")  
  fi  

  # 优化表,可提高性能  
  if [ $need_optmize_table = true ]  
  then  
    echo $(mysql -h$host_name -u$user_name -p$user_pwd $database -A -Bse "optimize table $table_name")  
  fi  
done  

assets

build

blog

awesome

env

install liunx​

下载​

pprof

go-torch

一般命令

连接​

执行，命令获取结果​

交互式命令

Go语言并发编程总结

1、通过golang中的 goroutine 与sync.Mutex进行并发同步​

2、goroutine之间通过 channel进行通信​

3、Go语言中的select是语言级内置 非堵塞​

4、channel 的带缓冲读取写入​

5、用goroutine模拟生产消费者​

6、 通过make 创建通道​

7、随机向通道中写入0或者1​

8、带缓冲的channel​

9、关于创建多个goroutine具体到go语言会创建多少个线程​

10、在channel中也是可以传递channel的,Go语言的channel和map、slice等一样都是原生类型​

11、我们默认创建的是双向通道,单向通道没有意义,但是我们却可以通过强制转换 将双向通道 转换成为单向通道 。​

12、只读只写单向 channel 代码例子，遵循权限最小化的原则​

13、channel的关闭,以及判断channel的关闭​

14、Go的多核并行化编程​

15、主动出让时间片给其他 goroutine 在未来的某一时刻再来执行当前goroutine​

16、Go中的同步​

17、Go中的同步锁​

18、全局唯一操作 sync.Once.Do() sync.atomic原子操作子包​

生成.a .h

build

web​

cpu_test.go​

原型​

prototype 1​

prototype 2 继承​

cli call linux​

https​

快速排序​

web-staging.go​

doc

时区​

commit 查看未提交事务​

processlist​

docker

table​

optmize + repair​

install liunx

下载

连接

执行，命令获取结果

1、通过golang中的 goroutine 与sync.Mutex进行并发同步

2、goroutine之间通过 channel进行通信

3、Go语言中的select是语言级内置非堵塞

4、channel 的带缓冲读取写入

5、用goroutine模拟生产消费者

6、通过make 创建通道

7、随机向通道中写入0或者1

8、带缓冲的channel

9、关于创建多个goroutine具体到go语言会创建多少个线程

10、在channel中也是可以传递channel的,Go语言的channel和map、slice等一样都是原生类型

11、我们默认创建的是双向通道,单向通道没有意义,但是我们却可以通过强制转换将双向通道转换成为单向通道。

12、只读只写单向 channel 代码例子，遵循权限最小化的原则

13、channel的关闭,以及判断channel的关闭

14、Go的多核并行化编程

15、主动出让时间片给其他 goroutine 在未来的某一时刻再来执行当前goroutine

16、Go中的同步

17、Go中的同步锁

18、全局唯一操作 sync.Once.Do() sync.atomic原子操作子包

web

cpu_test.go

原型

prototype 1

prototype 2 继承

cli call linux

https

快速排序

web-staging.go

时区

commit 查看未提交事务

processlist

table

optmize + repair