语言基础

字符串 数组 切片

  • 数组的定义

    1. var a [3]int                    // 定义长度为3的int型数组, 元素全部为0
    2. var b = [...]int{1, 2, 3}       // 定义长度为3的int型数组, 元素为 1, 2, 3
    3. var c = [...]int{2: 3, 1: 2}    // 定义长度为3的int型数组, 元素为 0, 2, 3
    4. var d = [...]int{1, 2, 4: 5, 6} // 定义长度为6的int型数组, 元素为 1, 2, 0, 0, 5, 6

  • 字符串 ```go //for range对字符串的迭代模拟实现 func forOnString(s string) { for i := 0; len(s) > 0; {

    1.   r, size := utf8.DecodeRuneInString(s)
    2.   fmt.Println(string(r),size,s)
    3.   s = s[size:]
    4.   i += size

    } }

  1. <a name="vh45M"></a>
  2. # Context
  3. ```go
  4. /*
  5. type Context interface {
  6.     Deadline() (deadline time.Time, ok bool)
  7.     Done() <-chan struct{}
  8.     Err() error
  9.     Value(key interface{}) interface{}
  10. }
  11. Deadline会返回一个超时时间，Goroutine获得了超时时间后，例如可以对某些io操作设定超时时间。
  12. Done方法返回一个信道（channel），当Context被撤销或过期时，该信道是关闭的，即它是一个表示Context是否已关闭的信号。
  13. 当Done信道关闭后，Err方法表明Context被撤的原因。
  14. Value可以让Goroutine共享一些数据，当然获得数据是协程安全的。但使用这些数据的时候要注意同步，比如返回了一个map，而这个map的读写则要加锁
  15. */

WithCancel

WithCancel创建的上下文需要主动调用cancel函数来结束上下文的生命周期 

  1. func main() {
  2.     // 父context(利用根context得到)
  3.     ctx, cancel := context.WithCancel(context.Background())
  5.     // 父context的子协程
  6.     go watch1(ctx)
  8.     // 子context，注意：这里虽然也返回了cancel的函数对象，但是未使用
  9.     valueCtx, _ := context.WithCancel(ctx)
  10.     // 子context的子协程
  11.     go watch2(valueCtx)
  13.     fmt.Println("现在开始等待3秒,time=", time.Now().Unix())
  14.     time.Sleep(3 * time.Second)
  16.     // 调用cancel()
  17.     fmt.Println("等待3秒结束,调用cancel()函数")
  18.     // 必须主动调用 
  19.     cancel()
  21.     // 再等待5秒看输出，可以发现父context的子协程和子context的子协程都会被结束掉
  22.     time.Sleep(5 * time.Second)
  23.     fmt.Println("最终结束,time=", time.Now().Unix())
  24. }
  26. // 父context的协程
  27. func watch1(ctx context.Context) {
  28.     for {
  29.         select {
  30.         case <-ctx.Done(): //取出值即说明是结束信号
  31.             fmt.Println("收到信号，父context的协程退出,time=", time.Now().Unix())
  32.             return
  33.         default:
  34.             fmt.Println("父context的协程监控中,time=", time.Now().Unix())
  35.             time.Sleep(1 * time.Second)
  36.         }
  37.     }
  38. }
  40. // 子context的协程
  41. func watch2(ctx context.Context) {
  42.     for {
  43.         select {
  44.         case <-ctx.Done(): //取出值即说明是结束信号
  45.             fmt.Println("收到信号，子context的协程退出,time=", time.Now().Unix())
  46.             return
  47.         default:
  48.             fmt.Println("子context的协程监控中,time=", time.Now().Unix())
  49.             time.Sleep(1 * time.Second)
  50.         }
  51.     }
  52. }

WithDeadline

WithDeadline 创建的上下文过期时间是指的某一个时刻，参数类型time.TIme可以看出，当父context到达过期时间时，所有由该父context创建的上下文全部过期

  1. func main() {
  2.     // 父context(利用根context得到)
  3.     ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(5*time.Second))
  4.     defer cancel()
  6.     // 父context的子协程
  7.     go watch1(ctx)
  9.     // 子context，注意：这里虽然也返回了cancel的函数对象，但是未使用
  10.     valueCtx, _ := context.WithCancel(ctx)
  11.     // 子context的子协程
  12.     go watch2(valueCtx)
  14.     // 再等待5秒看输出，可以发现父context的子协程和子context的子协程都会被结束掉
  15.     time.Sleep(10 * time.Second)
  16.     fmt.Println("最终结束,time=", time.Now().Unix())
  17. }
  19. // 父context的协程
  20. func watch1(ctx context.Context) {
  21.     for {
  22.         select {
  23.         case <-ctx.Done(): //取出值即说明是结束信号
  24.             fmt.Println("收到信号，父context的协程退出,time=", time.Now().Unix())
  25.             fmt.Println(ctx.Err().Error())
  26.             return
  27.         default:
  28.             fmt.Println("父context的协程监控中,time=", time.Now().Unix())
  29.             time.Sleep(1 * time.Second)
  30.         }
  31.     }
  32. }
  34. // 子context的协程
  35. func watch2(ctx context.Context) {
  36.     for {
  37.         select {
  38.         case <-ctx.Done(): //取出值即说明是结束信号
  39.             fmt.Println("收到信号，子context的协程退出,time=", time.Now().Unix())
  40.             return
  41.         default:
  42.             fmt.Println("子context的协程监控中,time=", time.Now().Unix())
  43.             time.Sleep(1 * time.Second)
  44.         }
  45.     }
  46. }

WithTimeout

WithTimeout 创建的上下文传入的时间参数可以理解为现在开始Context剩余的生命时长即指定总共的生命周期时长

  1. ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)

WithValue

用来和父context共享一些数据

  1. func main() {
  2.     // 父context(利用根context得到)
  3.     ctx := context.WithValue(context.Background(), "keys", "valus")
  5.     // 父context的子协程
  6.     go watch1(ctx)
  8.     // 子context，注意：这里虽然也返回了cancel的函数对象，但是未使用
  9.     valueCtx, _ := context.WithCancel(ctx)
  10.     //// 子context的子协程
  11.     go watch2(valueCtx)
  13.     // 再等待5秒看输出，可以发现父context的子协程和子context的子协程都会被结束掉
  14.     time.Sleep(10 * time.Second)
  15.     fmt.Println("最终结束,time=", time.Now().Unix())
  16. }
  18. // 父context的协程
  19. func watch1(ctx context.Context) {
  20.     for {
  21.         select {
  22.         case <-ctx.Done(): //取出值即说明是结束信号
  23.             fmt.Println("收到信号，父context的协程退出,time=", time.Now().Unix())
  24.             fmt.Println(ctx.Err().Error())
  25.             return
  26.         default:
  27.             fmt.Println("父context的协程监控中,time=", time.Now().Unix())
  28.             fmt.Println("获取值", ctx.Value("keys"))
  29.             time.Sleep(1 * time.Second)
  30.         }
  31.     }
  32. }
  34. // 子context的协程
  35. func watch2(ctx context.Context) {
  36.     for {
  37.         select {
  38.         case <-ctx.Done(): //取出值即说明是结束信号
  39.             fmt.Println("收到信号，子context的协程退出,time=", time.Now().Unix())
  40.             return
  41.         default:
  42.             fmt.Println("子context的协程监控中,time=", time.Now().Unix())
  43.             fmt.Println("子获取值", ctx.Value("keys"))
  44.             time.Sleep(1 * time.Second)
  45.         }
  46.     }
  47. }

锁的使用

互斥锁

错误示范

  1.    使用两个携程进行对一个变量进行操作，理论上讲最终a应该时0
  1. var (
  2.     a  = 0
  3.     wg sync.WaitGroup
  4. )
  6. func main() {
  8.     wg.Add(2)
  9.     go Add()
  10.     go Sub()
  11.     wg.Wait()
  12.     fmt.Println(a) // 答案不唯一 
  14. }
  16. func Add() {
  17.     defer wg.Done()
  18.     for i := 0; i < 100000; i++ {
  19.         a += i
  20.     }
  21. }
  23. func Sub() {
  24.     defer wg.Done()
  25.     for i := 0; i < 100000; i++ {
  26.         a -= i
  27.     }
  28. }

使用互斥锁实现

  1. var (
  2.     a     = 0
  3.     wg    sync.WaitGroup
  4.     mutex sync.Mutex
  5. )
  7. func main() {
  9.     wg.Add(2)
  10.     go Add()
  11.     go Sub()
  12.     wg.Wait()
  13.     fmt.Println(a)
  15. }
  17. func Add() {
  18.     defer wg.Done()
  19.     for i := 0; i < 100000; i++ {
  20.         mutex.Lock()
  21.         a += i
  22.         mutex.Unlock()
  23.     }
  24. }
  26. func Sub() {
  27.     defer wg.Done()
  28.     for i := 0; i < 100000; i++ {
  29.         mutex.Lock()
  30.         a -= i
  31.         mutex.Unlock()
  32.     }
  33. }

控制逻辑处理器数量

  1. var (
  2.     a  = 0
  3.     wg sync.WaitGroup
  4. )
  6. func main() {
  7.     // 分配一个逻辑处理器给调度器使用
  8.     runtime.GOMAXPROCS(1)
  9.     wg.Add(2)
  10.     go Add()
  11.     go Sub()
  12.     wg.Wait()
  13.     fmt.Println(a)
  15. }
  17. func Add() {
  18.     defer wg.Done()
  19.     for i := 0; i < 100000; i++ {
  20.         a += i
  21.     }
  22. }
  24. func Sub() {
  25.     defer wg.Done()
  26.     for i := 0; i < 100000; i++ {
  27.         a -= i
  28.     }
  29. }

Channel 通道

数据获取

  1. func main() {
  2.     // 创建无缓冲的通道
  3.     chans := make(chan int, 10)
  4.     // 方案一 阻塞获取数据
  5.     //go func() {
  6.     //    // 阻塞获取
  7.     //    data := <-chans
  8.     //    fmt.Println("获取到数据", data)
  9.     //}()
  11.     // 方案二 select + for + default 轮询获取
  12.     //go func() {
  13.     //    for {
  14.     //        select {
  15.     //        case data := <-chans:
  16.     //            fmt.Println("获取到数据", data)
  17.     //            return
  18.     //        default:
  19.     //            fmt.Print("等待中")
  20.     //        }
  21.     //    }
  22.     //}()
  24.     // 方案三 select 无 default
  25.     // 如果使用 select 加default 则无法获取到数据 需要添加无限循环来处理
  26.     //go func() {
  27.     //    select {
  28.     //    case data := <-chans:
  29.     //        fmt.Println("获取到数据", data)
  30.     //        return
  31.     //    }
  32.     //}()
  34.     // 方案四 select + default + for
  35.     // 由于 select 存在default分支 故select会结束 但是存在For 所以
  36.     // 可以继续执行获取操作
  37.     go func() {
  38.         for {
  39.             select {
  40.             case data := <-chans:
  41.                 fmt.Println("获取到数据", data)
  42.                 return
  43.             default:
  44.                 fmt.Print("持续等待中...")
  45.             }
  46.         }
  48.     }()
  50.     time.Sleep(time.Second * 2)
  51.     chans <- a
  52.     time.Sleep(time.Second * 1)
  53. }

发送接收案例

  1. // MsgPop 消息获取
  2. func MsgPop(msg chan []byte) {
  3.     for v := range msg {
  4.         // fmt.Println(v, "获取数据")
  5.         SendMsg(v)
  6.         fmt.Println("等待中")
  7.     }
  8. }
  10. // 消息发送
  11. func MsgPush(cc chan []byte) {
  12.     a := map[int]string{
  13.         0: "wx-notice1",
  14.         1: "wm-notice2",
  15.         2: "wm-notice3",
  16.         3: "wm-notice4",
  17.         4: "wm-notice5",
  18.         5: "wm-notice6",
  19.         6: "wm-notice7",
  20.         7: "wm-notice8",
  21.         8: "wm-notice9",
  22.         9: "wm-notice10",
  23.     }
  24.     for i := 0; i < 10; i++ {
  25.         time.Sleep(time.Second)
  26.         msg := NoticeType{
  27.             MsgType: a[i],
  28.             MsgInfo: "zhangsan",
  29.         }
  30.         data, _ := json.Marshal(msg)
  31.         cc <- data
  32.     }
  33. }
  35.  // 业务实现 
  36. func SendMsg(msg []byte) {
  37.     var not NoticeType
  38.     json.Unmarshal(msg, &not)
  39.     fmt.Println("获取到数据", not)
  40.     switch not.MsgType {
  41.     case "wx-notice1":
  42.         fmt.Println("wx-notice1")
  43.     case "wm-notice2":
  44.         fmt.Println("wm-notice2")
  45.     default:
  46.         fmt.Println("其他")
  47.     }
  50.  func main() {
  51.     var wg sync.WaitGroup
  52.     wg.Add(2)
  53.     chanData := make(chan []byte, 10000)
  55.     go redis.MsgPop(chanData)
  56.     go redis.MsgPush(chanData)
  57.     wg.Wait()
  58. }