1 iota 常量计数器 - Go

  1. func main() {
  2.     // iota 常量计数器(逐行加1)
  3.     const (
  4.         a = "11"
  5.         b = 9
  6.         c,d = iota,iota
  7.     )
  9.     fmt.Println(a,b,c,d)
  10.     // 11 9 2 2
  11. }

2 全局变量修改 - Py

a = 100 

def save_a():
    # 修改全局变量
    global a 
    a = 300
    print(a)

if __name__ == "__main__":
    save_a()
    print(a)

3 waitgroup 控制协程退出 - Go

    var wg sync.WaitGroup
    for i:=0;i<5;i++{
        // add 数量和 done的数量一致
        wg.Add(1)
        go func(n int){
            defer wg.Done()
            fmt.Println(n)
        }(i)
    }
    wg.Wait()

4 互斥锁同步协程 - Go

package main

import (
    "fmt"
    "sync"
)

var total int
var wg sync.WaitGroup
var mutex sync.Mutex
func add(){
    defer wg.Done()
    for i:=0;i<50000;i++{
        mutex.Lock()
        total+=1
        mutex.Unlock()
    }
}

func sub (){
    defer wg.Done()
    for i:=0;i<50000;i++{
        mutex.Lock()
        total-=1
        mutex.Unlock()
    }
}
func main() {

    wg.Add(2)
    go add()
    go sub()
    wg.Wait()
    fmt.Println(total)   // 0
}

5 读写锁同步协程 - Go

package main

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

var total int
var wg sync.WaitGroup
var rwmutex sync.RWMutex
func read(){
    defer wg.Done()
    for i:=0;i<10;i++{
        rwmutex.RLock()
        fmt.Println("读取数据---")
        time.Sleep(time.Second*1)
        fmt.Println("读取数据结束---")
        rwmutex.RUnlock()
    }
}

func write (){
    defer wg.Done()
    for i:=0;i<2;i++{
        rwmutex.Lock()
        fmt.Println("修改数据开始---")
        time.Sleep(time.Second*10)
        fmt.Println("修改数据结束---")
        rwmutex.Unlock()
    }
}
func main() {
    wg.Add(2)
    go read()
    go write()
    wg.Wait()
}

修改数据开始---
修改数据结束---
读取数据---
读取数据结束---
修改数据开始---
修改数据结束---
读取数据---
读取数据结束---
读取数据---
读取数据结束---
读取数据---
读取数据结束---
读取数据---
读取数据结束---
读取数据---
读取数据结束---
读取数据---
读取数据结束---
读取数据---
读取数据结束---
读取数据---
读取数据结束---
读取数据---
读取数据结束---

6 Context超时机制 - Go

var wg sync.WaitGroup

func Info(ctx context.Context)  {
    defer wg.Done()

    for {
        select {
        case <-ctx.Done():
            fmt.Println("超时退出")
            return
        default:
            fmt.Println("继续输出")
        }
    }
}

func main() {
    //ctx,cancel:=context.WithCancel(context.Background())          // 需手动执行 cancel()
    ctx,_:=context.WithTimeout(context.Background(),time.Second*3)  // 根据时间参数自行执行Done
    wg.Add(1)
    go Info(ctx)
    //time.Sleep(time.Second*3)
    //cancel()
    wg.Wait()
}

7 Type使用场景 - Go

func main() {
    //给类型定义别名
    type MyByte  = byte
    var b MyByte
    fmt.Printf("%T\n",b)
    // 基于已有的类型 自定义类型
    type Myint int
    var a Myint
    fmt.Printf("%T",a)
    // 定义结构体

    // 定义接口

    // 定义函数别名

}

8 结构体的实例化 - Go

func main() {


    type Course struct {
        Name string
        Price int
    }
    // 第一种 实例化
    c1:=Course{Name: "Go",Price: 100}
    fmt.Println(c1.Name,c1.Price)
    // 第二种 按照顺序写入值
    c2:=Course{"Java",120}
    fmt.Println(c2.Name,c2.Price)
    // 第三种 通过指针
    c3:=&Course{Name:"Python",Price:100}
    //fmt.Println((*c3).Name) == c3.Name (内部会进行转化成) (*c3).Name 形式
    fmt.Println(c3.Name,c3.Price)
    // 第四种 零值(默认会赋属性对应类型的零值)
    c4:=Course{}
    fmt.Println(c4)

    //var c5 *Course  = new(Course)  等效 c5:=new(Course) c5:=&Course{}
    c5:=new(Course)
    c5.Name= "454545"
    fmt.Println(c5)
    fmt.Printf("%T\n",c5)

    var c6 Course
    fmt.Println(c6)
    fmt.Printf("%T",c6)
}

9 接口 鸭子类型 -Go

接口可以继承。组合可以支持组合

package main

import "fmt"
// 程序员接口
type CXY interface {
    Code() string
    Debug() string
}
// 设计接口 
type SJ interface {
    SJ() string
}

// 管理者接口 
type Manage interface {
    Code() string
    Debug() string
    SJ() string
}


type PythonCXY struct {
    Name string
}

func (this *PythonCXY) Code() string{
    return "我是Python程序员 我会Code "
}

func (this *PythonCXY) Debug() string{
    return "我是Python程序员 我会Debug"
}

func (this *PythonCXY) SJ() string{
    return "我是Python程序员 我会设计"
}

func main()  {
    var cxy Manage = &PythonCXY{}
    fmt.Println(cxy)
}

10 空接口使用场景

package main
import (
    "fmt"
)
func myPrint(i interface{}){
    fmt.Printf("%v\n",i)
}

func main()  {
    // 空接口 任何数据类型可以赋值给空接口 -- 多态
    var i interface{}
    i= 100
    fmt.Println(i)
    i= false
    fmt.Println(i)
    // 参数传递
    myPrint(10)
    myPrint(false)
    // 作为map的值
    var myMap  = make(map[string]interface{})
    myMap["name"] = "zhangsan"
    myMap["age"] = 25
    myMap["money"] = 45.6
    myPrint(myMap)
}

11 类型断言

package main
import (
    "fmt"
)

type MyInterface interface {
    A() string
}

type MyInterfaceDone struct {
}

func (this *MyInterfaceDone) A() string {
    return ""
}

func GetType(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("%d (整型) \n", v)
    case float64:
        fmt.Printf("%f (浮点型) \n", v)
    case string:
        fmt.Printf("%s (字符串) \n", v)
    case nil:
        fmt.Println("nil")
    case MyInterfaceDone:
        fmt.Println("MyInterfaceDone ")

    default:
        fmt.Println("无法判断数据类型 ")

    }
}

func main() {
    //a := 10               // int
    //b := 23.6             //float64
    //s := "你好"           // string
    //var in interface{}   // nil
    //var ii MyInterfaceDone // MyInterfaceDone

    type mystruct struct {
        Name string
    }
    GetType(mystruct{Name: "zs"})
    //var cc interface{}=mystruct{Name: "zs"}
    //vv,ok:= cc.(mystruct)
    //fmt.Println(vv,ok)

}

9 go rpc

默认序列化协议为Gob

client

package main

import (
    "fmt"
    "net/rpc"
)

func main()  {
    conn,err:=rpc.Dial("tcp","127.0.0.1:8080")
    if err!=nil{
        fmt.Println("连接失败")
    }
    var reqs string
    err= conn.Call("HelloGrpc.Hello","HH",&reqs)
    fmt.Println(reqs)
    // 输出 Hello Grpc HH
}

server

package main

import (
    "fmt"
    "net"
    "net/rpc"
)

type HelloGrpc struct {

}

func (this * HelloGrpc) Hello(req string,reqs *string) error {
    *reqs  ="Hello Grpc " + req
    return nil
}

func main()  {
    // 实例化 Server
    listen,err:=net.Listen("tcp","127.0.0.1:8080")
    if err!=nil{
        fmt.Println("监听失败")
        defer listen.Close()
    }
    // 注册处理逻辑
    rpc.RegisterName("HelloGrpc",&HelloGrpc{})
    // 服务启动
    conn,err:=listen.Accept()
    rpc.ServeConn(conn)
}

10 go rpc 替换序列化协议为Json 跨语言调用

go server

package main

import (
    "fmt"
    "net"
    "net/rpc"
    "net/rpc/jsonrpc"
)

type HelloGrpc struct {

}

func (this * HelloGrpc) Hello(req string,reqs *string) error {
    *reqs  ="Hello Grpc " + req
    return nil

}

func main()  {
    // 实例化 Server
    listen,err:=net.Listen("tcp","127.0.0.1:8080")
    if err!=nil{
        fmt.Println("监听失败")
        defer listen.Close()
    }
    // 注册处理逻辑
    rpc.RegisterName("HelloGrpc",&HelloGrpc{})
    // 服务启动
    for {
        conn,_:=listen.Accept()
        //rpc.ServeConn(conn)
        // 替换序列化协议为json
        rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
    }

}

go client

package main

import (
    "fmt"
    "net"
    "net/rpc"
    "net/rpc/jsonrpc"
)

func main()  {
    conn,err:=net.Dial("tcp","127.0.0.1:8080")
    if err!=nil{
        fmt.Println("连接失败")
    }
    var reqs string
    client:=rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
    err= client.Call("HelloGrpc.Hello","HH",&reqs)
    fmt.Println(reqs)
}

python client

import socket
import json

if __name__ == "__main__":
    request = {
        "id": 0,
        "params": ["HH"],
        "method": "HelloGrpc.Hello"
    }

    client = socket.create_connection(("localhost", 8080))
    # 发送消息
    client.sendall(json.dumps(request).encode())
    data = client.recv(1024)
    print(json.loads(data.decode())["result"])
    client.close()

11 替换rpc的传输协议为http

server

package main

import (
    "io"
    "net/http"
    "net/rpc"
    "net/rpc/jsonrpc"
)

type HelloGrpc struct {

}

func (this * HelloGrpc) Hello(req string,reqs *string) error {
    *reqs  ="Hello Grpc " + req
    return nil

}

func main()  {
    // 注册处理逻辑
    rpc.RegisterName("HelloGrpc",&HelloGrpc{})
    // 服务启动
    http.HandleFunc("/jsonrpc",func(w http.ResponseWriter,r *http.Request){
        var conn io.ReadWriteCloser = struct {
            io.Writer
            io.ReadCloser
        }{ReadCloser:r.Body,Writer:w}

        rpc.ServeRequest(jsonrpc.NewServerCodec(conn))
    })

    http.ListenAndServe(":8080",nil)


}

client

import requests
if __name__ == "__main__":

    request = {
        "id": 0,
        "params": ["HH"],
        "method": "HelloGrpc.Hello"
    }

    data = requests.post("http://127.0.0.1:8080/jsonrpc",json=request)
    print(data.text)  # {"id":0,"result":"Hello Grpc HH","error":null}