下载APP
登录
关闭
讲堂
算法训练营
Python 进阶训练营
企业服务
极客商城
客户端下载
兑换中心
渠道合作
推荐作者
当前播放: 25 | CSP并发机制
00:00 / 00:00
标清
  • 标清
1.0x
  • 2.0x
  • 1.5x
  • 1.25x
  • 1.0x
  • 0.5x
网页全屏
全屏
00:00
付费课程,可试看

Go语言从入门到实战

共55讲 · 55课时,约700分钟
6092
免费
01 | Go语言课程介绍
免费
02 | 内容综述
免费
03 | Go语言简介:历史背景、发...
免费
04 | 编写第一个Go程序
免费
05 | 变量、常量以及与其他语言...
06 | 数据类型
07 | 运算符
08 | 条件和循环
09 | 数组和切片
10 | Map声明、元素访问及遍历
11 | Map与工厂模式,在Go语言...
12 | 字符串
13 | Go语言的函数
14 | 可变参数和defer
15 | 行为的定义和实现
16 | Go语言的相关接口
17 | 扩展与复用
18 | 不一样的接口类型,一样的...
19 | 编写好的错误处理
20 | panic和recover
21 | 构建可复用的模块(包)
22 | 依赖管理
23 | 协程机制
24 | 共享内存并发机制
25 | CSP并发机制
26 | 多路选择和超时
27 | channel的关闭和广播
28 | 任务的取消
29 | Context与任务取消
30 | 只运行一次
31 | 仅需任意任务完成
32 | 所有任务完成
33 | 对象池
34 | sync.pool对象缓存
35 | 单元测试
36 | Benchmark
37 | BDD
38 | 反射编程
39 | 万能程序
40 | 不安全编程
41 | 实现pipe-filter framew...
42 | 实现micro-kernel frame...
43 | 内置JSON解析
44 | easyjson
45 | HTTP服务
46 | 构建RESTful服务
47 | 性能分析工具
48 | 性能调优示例
49 | 别让性能被锁住
50 | GC友好的代码
51 | 高效字符串连接
52 | 面向错误的设计
53 | 面向恢复的设计
54 | Chaos Engineering
55 | 结束语
本节摘要
展开

精选留言(10)

  • 2019-06-06
    初学语言,用中文解释,便于理解
    ```go
    func service() string {
        fmt.Println("---service---立即执行 50 毫秒延时")
        time.Sleep(time.Millisecond * 50)
        return "---service---Done"
    }

    func otherTask() {
        fmt.Println("---otherTask---working on something else")
        fmt.Println("---otherTask---立即执行 100 毫秒延时")
        time.Sleep(time.Millisecond * 100)
        fmt.Println("---otherTask---Task is Done")
    }

    func AsyncService() chan string { // 该函数返回一个通道, 消息类型是 string
        // retCh := make(chan string) // 声明一个无缓冲 chan通道, 这个通道的类型是 string, 通道用于协程间的通信
        // // ⚠️ 使用无缓冲通道时, 如果协程1 没有立即接受协程 2 通过管道发送的消息,就会阻塞,反之亦然
        retCh := make(chan string, 1) // 声明一个缓冲容量为 1 的chan通道, 这个通道的类型是 string, 通道用于协程间的通信
        go func() { // 此处执行 匿名协程函数
            ret := service()
            fmt.Println("---AsyncService---returned result:", ret)
            retCh <- ret //通过通道将 service()函数返回的值传递给 通道 retCh
            fmt.Println("---AsyncService---service exited")
        }()
        return retCh // 返回这个通道
    }

    func TestAsyncService(t *testing.T) {
        retCh := AsyncService()
        otherTask()
        fmt.Println(<-retCh)
    }

    ```
    展开
    3
  • 2019-03-21
    type Promise struct{
        wg sync.WaitGroup
        res string
        err error
    }

    func NewPromise(f func() (string ,error)) *Promise{
        p := &Promise{}
        p.wg.Add(1)
        go func(){
            p.res, p.err = f()
            p.wg.Done()
        }()
        return p
    }

    func (p *Promise) then(r func(string), e func(error))(*Promise){
        go func(){
            p.wg.Wait()
            if p.err != nil{
                e(p.err)
                return
            }
            r(p.res)
        }()
        return p
    }
    使用go模仿的异步promise
    展开
    3
  • 2019-03-20
    老师 :请教个问题,goroutine异步执行的结果通过channel来通知主线程,是不是应该把goroutine执行过程中的error等信息也放到channel返回,因为node的异常机制都是通过回调函数带回来的。

    作者回复: 你可以传回一个结构体,里面包含结果和错误

    2
  • 2019-06-27
    主方法最后为什么要sleep一下

    作者回复: 如果不sleep,主协程退出,程序就终止了(他不会等待子协程)

    1
  • 2019-11-29
    感觉就像个内嵌版的消息队列
  • 2019-09-06
    图画的用心
  • 2019-08-06
    老师您好,学习本节课程后,测试并总结如下:
        1. 若创建通道时未设置通道容量,则协程在向通道中存放数据后会一直等待,直到其它协程取走数据后才会向下执行;
        2. 若创建通道时设置通道容量,则协程在向通道中存放数据后会继续向下执行;
        3. 在向通道中存放数据时,若通道已满,则当前协程会一直等待,直到通道空闲;
        4. 在从通道中读取数据时,若通道中不存在数据,则当前协程会一直等待,直到其它协程向通道中存放数据。
        5. 当4发生时,若没有协程向该通道存放数据,则会照成程序死锁。

    有错误的地方,烦请老师斧正。
    展开
  • 2019-07-18
    我的理解是 在协程里吧数据写入管道后 协程就继续往下执行了 协程不需要等待管道里的数据被提取
    func service() string {
        time.Sleep(time.Millisecond * 110)
        fmt.Println("service end")
        return "service action call"
    }

    func sendMessage() chan string {
        Mchannel := make(chan string)
        go func() {
            fmt.Println("service in.")
            ret := service()
            Mchannel <- ret
            fmt.Println("service exited.")
        }()
        return Mchannel
    }

    service exited. 这句输出 会在 service action call 前输出
    展开

    作者回复: 如果不是buffer chan,在发送时无接收者或者buffer chan中的数据已经满了的时候,发送者是会被阻塞的

  • 2019-06-19
    回复@南宫云遥子:
    ch := make(chan int)
    1. 这样定义出来的是一个无缓冲的channel, 必须要有一个同时写一个等待
    2. 如果串行执行的话写和等待并不成对, 造成死锁
    3. 可以使用cap(ch)看到创建出来的channel容量为0
    解决:
    ch := make(chan int, 1)
    1. 这样的话有一个缓冲, 可以先写进去再取值
    展开
  • 2019-04-23
    channel不能写完就读吗?这段代码会报死锁
    ```
    func main(){
        c := make(chan int)
        c <- 12
        time.Sleep(2 * time.Second)
        ch := <-c
        fmt.Println(ch)
    }
    ```
    ```
    fatal error: all goroutines are asleep - deadlock!
    ```
    展开
    1