Go 中使用 base64


package main

import (
    "encoding/base64"
    "fmt"
    "log"
)

func main() {
    input := []byte("hello golang base64")

    // base64 encode
    encodeString := base64.StdEncoding.EncodeToString(input)
    fmt.Println(encodeString)

    // base decode
    decodeBytes, err := base64.StdEncoding.DecodeString(encodeString)
    if err != nil {
        log.Fatalln(err)
    }
    fmt.Println(string(decodeBytes))
}
阅读全文

Go cond锁定期唤醒锁


package main

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

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

func test(x int) {
    // 获取锁
    cond.L.Lock()
    // 等待通知  暂时阻塞
    cond.Wait()
    fmt.Println(x)
    time.Sleep(time.Second * 1)
    // 释放锁
    cond.L.Unlock()
}
func main() {
    for i := 0; i < 40; i++ {
        go test(i)
    }
    fmt.Println("start all")
    time.Sleep(time.Second * 3)
    fmt.Println("broadcast")
    // 下发一个通知给已经获取锁的goroutine
    cond.Signal()
    time.Sleep(time.Second * 3)
    // 3秒之后 下发一个通知给已经获取锁的goroutine
    cond.Signal()
    time.Sleep(time.Second * 3)
    // 3秒之后 下发广播给所有等待的goroutine
    cond.Broadcast()
    time.Sleep(time.Second * 60)
}
阅读全文

Go 中如何阻塞等待所有 goroutines 都完成


方案一:

package main

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

// 定义一个同步等待的组
var wg sync.WaitGroup

// 定义一个Printer函数用于并发
func Printer(a int) {
    time.Sleep(2000 * time.Millisecond)
    fmt.Printf("i am %d\n", a)
    defer wg.Done()
}

func main() {
    // 获取cpu个数
    maxProcs := runtime.NumCPU()
    // 限制同时运行的goroutines数量
    runtime.GOMAXPROCS(maxProcs)
    for i := 0; i < 10; i++ {
        //为同步等待组增加一个成员
        wg.Add(1)
        //并发一个goroutine
        go Printer(i)
    }
    // 阻塞等待所有组内成员都执行完毕退栈
    wg.Wait()
    fmt.Println("WE DONE!!!")
}

阅读全文

Go 打印函数执行时间


package main

import (
    "fmt"
    "time"
)

func timeCost(start time.Time) {
    terminal := time.Since(start)
    fmt.Println(terminal)
}

func main() {
    defer timeCost(time.Now())
    fmt.Println("start program")
    time.Sleep(5 * time.Second)
    fmt.Println("finish program")
}
阅读全文

Go make 和 new 的区别


new 和 make 都可以用来分配空间,初始化类型,但是它们确有不同。
new(T)返回的是 T 的指针
new(T)为一个 T 类型新值分配空间并将此空间初始化为 T 的零值,返回的是新值的地址,也就是 T 类型的指针 *T,该指针指向 T 的新分配的零值。

package main

import "fmt"

func main() {
    p1 := new(int)
    fmt.Printf("p1 --> %#v \n ", p1)
    fmt.Printf("p1 point to --> %#v \n ", *p1)

    var p2 *int
    i := 0
    p2 = &i
    fmt.Printf("p2 --> %#v \n ", p2)
    fmt.Printf("p2 point to --> %#v \n ", *p2)
}


阅读全文

Go 中 string、int、int64、float64类型相互转换


主要使用包 strconv

import "strconv"

func main() {
    // string to int
    int, _ := strconv.Atoi(string)
    // string to int64
    int64, _ := strconv.ParseInt(string, 10, 64)
    // string to float64
    float64, _ := strconv.ParseFloat(value, 64)
    // int to string
    string := strconv.Itoa(int)
    // int64 to string
    string := strconv.FormatInt(int64, 10)
}
阅读全文

Go http client 发送 get post 请求


引入包

import (
    "net/http"
)

发送 get 请求

res, _ := http.Get(getURL)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(string(body))

发送 post 请求

// 将 map 转换成 json jinxingfasong
requestJSON, _ := json.Marshal(requestMap)
req, _ := http.NewRequest("POST", postURL, strings.NewReader(string(requestJSON)))
// 设置请求头
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
res, err := client.Do(req)
if err != nil {
    fmt.Println(err)
}
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(string(body))
阅读全文