Go 基础 03

• goroutine   channel

package main

import (
    "fmt"
    "runtime"
)

// goroutine 使用 Channel 进行通信
// 计算 1000 以内的素数
// 一个 goroutine 写，一个 goroutine 读
func calc(taskChan chan int, resChan chan int, exitChan chan bool) {
    for v := range taskChan {
        flag := true
        // 判断 v 是否是素数
        for i := 2; i < v; i++ {
            if 0 == v%i {
                // 不是素数的 flag
                flag = false
                break
            }
        }
        if flag {
            // 是素数的情况，就放到 resChan 的 channel 中
            resChan <- v
        }
    }
    // 这个协程执行完成后，向 exitChan 的channel 中发送一个完成信号
    exitChan <- true
}

func main() {

    // 获取当前机器 cpu 的核数
    num := runtime.NumCPU()
    fmt.Println(num)

    intChan := make(chan int, 1000)
    resultChan := make(chan int, 1000)
    // exitChan 装满后，就表示所有协程都执行完成了
    exitChan := make(chan bool, num)

    // 匿名函数方式，启动一个协程
    go func() {
        for i := 0; i < 100000; i++ {
            intChan <- i
        }
        // 关闭 Channel
        close(intChan)
    }()
    // 计算 1000 以内的素数
    // 一个 goroutine 写，一个 goroutine 读
    // 通过 for 循环，一共启动 4 个协程
    // 同时从 intChan 中取数字，计算素数
    for i := 0; i < num; i++ {
        go calc(intChan, resultChan, exitChan)
    }

    // 匿名函数方式，启动一个协程
    go func() {
        // 没有完成的 channel 主线程取值时，就阻塞在这里
        // 直到把 exitChan 都取完，主线程才会继续向下执行
        for i := 0; i < num; i++ {
            // 只是取，并不关注取的是什么
            <-exitChan
            fmt.Printf("[message] => %d had completed ...
", i)
        }
        // 都取完之后，表示所有的协程都执行完成，就可以关闭 resultChan 的 channel
        close(resultChan)
    }()

    for v := range resultChan {
        fmt.Println(v)
    }
}

• 非阻塞方式从 channel 中读取数据

package main

import (
    "fmt"
    "time"
)

func main() {
    var ch chan int
    ch = make(chan int, 10)
    ch2 := make(chan int, 10)

    // 向 channel 中存放数据
    go func() {
        var i int = 1
        for {
            ch <- i
            time.Sleep(time.Second)
            ch2 <- i * i
            time.Sleep(time.Second)
            i++
        }
    }()

    for {
        // 当 channel 中的数据被取空时，
        // 不执行阻塞，而进入 default 分支
        select {
        case v := <-ch:
            fmt.Println(v)
        case v := <-ch2:
            fmt.Println(v)
        default:
            fmt.Println("get data timeout ...")
            time.Sleep(time.Second)
        }
    }
}

• tcp  编程

// server.go

package main

import (
    "fmt"
    "net"
)

func main() {
    fmt.Println("start server...")
    listen, err := net.Listen("tcp", "0.0.0.0:50000")
    if err != nil {
        fmt.Println("listen failed, err:", err)
        return
    }
    for {
        conn, err := listen.Accept()
        if err != nil {
            fmt.Println("accept failed, err:", err)
            continue
        }
        go process(conn)
    }
}
func process(conn net.Conn) {
    defer conn.Close()
    for {
        buf := make([]byte, 512)
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("read err:", err)
            return
        }

        fmt.Printf(string(buf[0:n]))
    }
}

// client.go

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
)

// 客户端的处理流程
func main() {
    // 1- 建立与服务端的连接
    conn, err := net.Dial("tcp", "localhost:50000")
    if err != nil {
        fmt.Println("Error dialing", err.Error())
        return
    }

    // 3- 关闭连接
    defer conn.Close()

    // 2- 进行数据收发
    // 从标准输入设备中读取
    inputReader := bufio.NewReader(os.Stdin)
    for {
        // 从标准输入设备中读取以 
 为结尾的一行
        input, _ := inputReader.ReadString('
')
        // 去掉读到数据的换行和回车
        trimmedInput := strings.Trim(input, "
")

        // 输入 Q 客户端就退出了
        if trimmedInput == "Q" {
            return
        }
        // 字符串转为字节切片后，向服务端发送
        _, err = conn.Write([]byte(trimmedInput))
        if err != nil {
            return
        }
    }
}

• redis  连接池

package main

import (
    "fmt"

    "github.com/garyburd/redigo/redis"
)

var pool *redis.Pool

func init() {
    pool = &redis.Pool{
        MaxIdle:     16,
        MaxActive:   0,
        IdleTimeout: 300,
        Dial: func() (redis.Conn, error) {
            return redis.Dial("tcp", "192.168.56.164:6379")
        },
    }
}

func main() {

    c := pool.Get()
    // 方法执行后，关闭 redis.Dial 的连接
    defer c.Close()

    _, err := c.Do("Set", "abc", 100)
    if err != nil {
        fmt.Println(err)
        return
    }

    r, err := redis.Int(c.Do("Get", "abc"))
    if err != nil {
        fmt.Println("get abc failed,", err)
        return
    }

    fmt.Println(r)
    // 关闭连接池已使用的资源
    pool.Close()
}

• http 编程

5.    // server.go

package main

import (
    "fmt"
    "net/http"
)

func Hello(w http.ResponseWriter, r *http.Request) {
    // 向本地打印
    fmt.Println("handle hello")
    // 向浏览器端发送数据
    fmt.Fprintf(w, "hello ")
}

func login(w http.ResponseWriter, r *http.Request) {
    fmt.Println("handle login")
    fmt.Fprintf(w, "login ")
}

func history(w http.ResponseWriter, r *http.Request) {
    fmt.Println("handle history")
    fmt.Fprintf(w, "history ")
}

// 服务端
func main() {
    // 设置路由，处理根目录
    http.HandleFunc("/", Hello)
    http.HandleFunc("/user/login", login)
    http.HandleFunc("/user/history", history)
    err := http.ListenAndServe("0.0.0.0:8880", nil)
    if err != nil {
        fmt.Println("http listen failed")
    }
}

// client.go

package main

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

// 客户端访问百度
func main() {
    res, err := http.Get("https://www.baidu.com/")
    if err != nil {
        fmt.Println("get err:", err)
        return
    }

    data, err := ioutil.ReadAll(res.Body)
    if err != nil {
        fmt.Println("get data err:", err)
        return
    }

    fmt.Println(string(data))
}

• 操作  mysql  数据库

package main

import (
    "fmt"

    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
)

type Person struct {
    // 结构体字段 UserId 对应 数据库中的 字段 user_id
    UserId   int    `db:"user_id"`
    Username string `db:"username"`
    Sex      string `db:"sex"`
    Email    string `db:"email"`
}

type Place struct {
    Country string `db:"country"`
    City    string `db:"city"`
    TelCode int    `db:"telcode"`
}

var Db *sqlx.DB

func init() {

    database, err := sqlx.Open("mysql", "root:123456@tcp(192.168.56.164:3306)/test")
    if err != nil {
        fmt.Println("open mysql failed,", err)
        return
    }

    Db = database
}

func main() {

    var person []Person
    // 查询并将结果返回到 person 数组中
    err := Db.Select(&person, "select user_id, username, sex, email from person where user_id=?", 1)
    if err != nil {
        fmt.Println("exec failed, ", err)
        return
    }

    fmt.Println("select succ:", person)
    fmt.Println("select succ:", person[0])
}

（ Over ）