首页 > 编程开发 > Go语言

Golang channel底层是如何实现的？

来自：博客园
时间：2024-07-06
阅读：

Hi 你好，我是k哥。大厂搬砖6年的后端程序员。

我们知道，Go语言为了方便使用者，提供了简单、安全的协程数据同步和通信机制，channel。那我们知道channel底层是如何实现的吗？今天k哥就来聊聊channel的底层实现原理。同时，为了验证我们是否掌握了channel的实现原理，本文也收集了channel的高频面试题，理解了原理，面试题自然不在话下。

1 原理

默认情况下，读写未就绪的channel(读没有数据的channel，或者写缓冲区已满的channel)时，协程会被阻塞。

但是当读写channel操作和select搭配使用时，即使channel未就绪，也可以执行其它分支，当前协程不会被阻塞。

ch := make(chan int)
select{
  case <- ch:
  default:
}

本文主要介绍channel的阻塞模式，和select搭配使用的非阻塞模式，后续会另起一篇介绍。

1.1 数据结构

Golang channel底层是如何实现的？

channel涉及到的核心数据结构包含3个。

hchan

// channel
type hchan struct {
    // 循环队列
    qcount   uint           // 通道中数据个数
    dataqsiz uint           // buf长度
    buf      unsafe.Pointer // 数组指针
    sendx    uint   // send index
    recvx    uint   // receive index
    elemsize uint16 // 元素大小
    elemtype *_type // 元素类型
    
    closed   uint32 // 通道关闭标志
    
    recvq    wAItq  // 由双向链表实现的recv waiters队列
    sendq    waitq  // 由双向链表实现的send waiters队列
    lock mutex
}

hchan是channel底层的数据结构，其核心是由数组实现的一个环形缓冲区：

  1. qcount 通道中数据个数

  2. dataqsiz 数组长度

  3. buf 指向数组的指针，数组中存储往channel发送的数据

  4. sendx 发送元素到数组的index

  5. recvx 从数组中接收元素的index

  6. elemsize channel中元素类型的大小

  7. elemtype channel中的元素类型

  8. closed 通道关闭标志

  9. recvq 因读取channel而陷入阻塞的协程等待队列

  10. sendq 因发送channel而陷入阻塞的协程等待队列

  11. lock 锁

waitq

// 等待队列(双向链表)
type waitq struct {
    first *sudog
    last  *sudog
}

waitq是因读写channel而陷入阻塞的协程等待队列。

  1. first 队列头部

  2. last 队列尾部

sudog

// sudog represents a g in a wait list, such as for sending/receiving
// on a channel.
type sudog struct {
    g *g // 等待send或recv的协程g
    next *sudog // 等待队列下一个结点next
    prev *sudog // 等待队列前一个结点prev
    elem unsafe.Pointer // data element (may point to stack)
    
    success bool // 标记协程g被唤醒是因为数据传递(true)还是channel被关闭(false)
    c        *hchan // channel
}

sudog是协程等待队列的节点：

  1. g 因读写而陷入阻塞的协程

  2. next 等待队列下一个节点

  3. prev 等待队列前一个节点

  4. elem 对于写channel，表示需要发送到channel的数据指针；对于读channel，表示需要被赋值的数据指针。

  5. success 标记协程被唤醒是因为数据传递(true)还是channel被关闭(false)

  6. c 指向channel的指针

1.2 通道创建

func makechan(t *chantype, size int) *hchan {
    elem := t.elem
    // buf数组所需分配内存大小
    mem := elem.size*uintptr(size)
    var c *hchan
    Switch {
    case mem == 0:// Unbuffered channels，buf无需内存分配
        c = (*hchan)(mallocgc(hchanSize, nil, true))
        // Race detector uses this location for synchronization.
        c.buf = c.raceaddr()
    case elem.ptrdata == 0: // Buffered channels，通道元素类型非指针
        c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
        c.buf = add(unsafe.Pointer(c), hchanSize)
    default:
        // Buffered channels，通道元素类型是指针
        c = new(hchan)
        c.buf = mallocgc(mem, elem, true)
    }

    c.elemsize = uint16(elem.size)
    c.elemtype = elem
    c.dataqsiz = uint(size)
    return c
}

通道创建主要是分配内存并构建hchan对象。

1.3 通道写入

3种异常情况处理

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    // 1.channel为nil
    if c == nil {
        gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }
    
    lock(&c.lock) //加锁
    
    // 2.如果channel已关闭，直接panic
    if c.closed != 0 {
        unlock(&c.lock)
        panic(plainError("send on closed channel"))
    }
   
    // Block on the channel. 
    mysg := acquireSudog()
    c.sendq.enqueue(mysg) // 入sendq等待队列
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
    
    
    closed := !mysg.success // 协程被唤醒的原因是因为数据传递还是通道被关闭
    // 3.因channel被关闭导致阻塞写协程被唤醒并panic
    if closed {
        panic(plainError("send on closed channel"))
    }
}

  1. 对 nil channel写入，会死锁

  2. 对被关闭的channel写入，会panic

  3. 对因写入而陷入阻塞的协程，如果channel被关闭，阻塞协程会被唤醒并panic

写时有阻塞读协程

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    lock(&c.lock) //加锁
    // 1、当存在等待接收的Goroutine
    if sg := c.recvq.dequeue(); sg != nil {
        // Found a waiting receiver. We pass the value we want to send
        // directly to the receiver, bypassing the channel buffer (if any).
        send(c, sg, ep, func() { unlock(&c.lock) }, 3) // 直接把正在发送的值发送给等待接收的Goroutine，并将此接收协程放入可调度队列等待调度
        return true
    }
}

// send processes a send operation on an empty channel c.
// The value ep sent by the sender is copied to the receiver sg.
// The receiver is then woken up to go on its merry way.
// Channel c must be empty and locked.  send unlocks c with unlockf.
// sg must already be dequeued from c.
// ep must be non-nil and point to the heap or the caller's stack.
func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    // 将ep写入sg中的elem
    if sg.elem != nil {
         t:=c.elemtype
         dst := sg.elem
        
         // memmove copies n bytes from "from" to "to".
         memmove(dst, ep, t.size)
         sg.elem = nil // 数据已经被写入到<- c变量，因此sg.elem指针可以置空了
    }
    gp := sg.g
    unlockf()
    gp.param = unsafe.Pointer(sg)
    sg.success = true
    
    // 唤醒receiver协程gp
    goready(gp, skip+1)
}

// 唤醒receiver协程gp，将其放入可运行队列中等待调度执行
func goready(gp *g, traceskip int) {
    systemstack(func() {
        ready(gp, traceskip, true)
    })
}
// Mark gp ready to run.
func ready(gp *g, traceskip int, next bool) {
    status := readgstatus(gp)
    // Mark runnable.
    _g_ := getg()
    mp := acquirem() // disable preemption because it can be holding p in a local var
    // status is Gwaiting or Gscanwaiting, make Grunnable and put on runq
    casgstatus(gp, _Gwaiting, _Grunnable)
    runqput(_g_.m.p.ptr(), gp, next)
    wakep()
    releasem(mp)
}

  1. 加锁

  2. 从阻塞读协程队列取出sudog节点

  3. 在send方法中，调用memmove方法将数据拷贝给sudog.elem指向的变量。

  4. goready方法唤醒接收到数据的阻塞读协程g，将其放入协程可运行队列中等待调度

  5. 解锁

写时无阻塞读协程但环形缓冲区仍有空间

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    lock(&c.lock) //加锁
    // 当缓冲区未满时
    if c.qcount < c.dataqsiz {
        // Space is available in the channel buffer. Enqueue the element to send.
        qp := chanbuf(c, c.sendx) // 获取指向缓冲区数组中位于sendx位置的元素的指针
        typedmemmove(c.elemtype, qp, ep) // 将当前发送的值拷贝到缓冲区
        c.sendx++ 
        if c.sendx == c.dataqsiz {
            c.sendx = 0 // 因为是循环队列，sendx等于队列长度时置为0
        }
        c.qcount++
        unlock(&c.lock)
        return true
    }
}

  1. 加锁

  2. 将数据放入环形缓冲区

  3. 解锁

写时无阻塞读协程且环形缓冲区无空间

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    lock(&c.lock) //加锁
    
    // Block on the channel. 
    // 将当前的Goroutine打包成一个sudog节点，并加入到阻塞写队列sendq里
    gp := getg()
    mysg := acquireSudog()
    mysg.elem = ep
    mysg.g = gp
    mysg.c = c
    gp.waiting = mysg
    c.sendq.enqueue(mysg) // 入sendq等待队列
    
   
    // 调用gopark将当前Goroutine设置为等待状态并解锁，进入休眠等待被唤醒，触发协程调度
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
    
    // 被唤醒之后执行清理工作并释放sudog结构体
    gp.waiting = nil
    gp.activeStackChans = false
    closed := !mysg.success // gp被唤醒的原因是因为数据传递还是通道被关闭
    gp.param = nil
  
    mysg.c = nil
    releaseSudog(mysg)
    // 因关闭被唤醒则panic
    if closed {
        panic(plainError("send on closed channel"))
    }
    // 数据成功传递
    return true
}

  1. 加锁。

  2. 将当前协程gp封装成sudog节点，并加入channel的阻塞写队列sendq。

  3. 调用gopark将当前协程设置为等待状态并解锁，触发调度其它协程运行。

  4. 因数据被读或者channel被关闭，协程从park中被唤醒，清理sudog结构。

  5. 因channel被关闭导致协程唤醒，panic

  6. 返回

整体写流程

Golang channel底层是如何实现的？

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    // 1.channel为nil
    if c == nil {
        // 当前Goroutine阻塞挂起
        gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }
    // 2.加锁
    lock(&c.lock) 
    
    // 3.如果channel已关闭，直接panic
    if c.closed != 0 {
        unlock(&c.lock)
        panic(plainError("send on closed channel"))
    }
    // 4、存在阻塞读协程
    if sg := c.recvq.dequeue(); sg != nil {
        // Found a waiting receiver. We pass the value we want to send
        // directly to the receiver, bypassing the channel buffer (if any).
        send(c, sg, ep, func() { unlock(&c.lock) }, 3) // 直接把正在发送的值发送给等待接收的Goroutine，并将此接收协程放入可调度队列等待调度
        return true
    }
    // 5、缓冲区未满时
    if c.qcount < c.dataqsiz {
        // Space is available in the channel buffer. Enqueue the element to send.
        qp := chanbuf(c, c.sendx) // 获取指向缓冲区数组中位于sendx位置的元素的指针
        typedmemmove(c.elemtype, qp, ep) // 将当前发送的值拷贝到缓冲区
        c.sendx++ 
        if c.sendx == c.dataqsiz {
            c.sendx = 0 // 因为是循环队列，sendx等于队列长度时置为0
        }
        c.qcount++
        unlock(&c.lock)
        return true
    }
    // Block on the channel. 
    // 6、将当前协程打包成一个sudog结构体，并加入到channel的阻塞写队列sendq
    gp := getg()
    mysg := acquireSudog()
    mysg.elem = ep
    mysg.waitlink = nil
    mysg.g = gp
    mysg.c = c
    gp.waiting = mysg
    gp.param = nil
    c.sendq.enqueue(mysg) // 入sendq等待队列
    
    atomic.Store8(&gp.parkingOnChan, 1)
    
    // 7.调用gopark将当前协程设置为等待状态并解锁，进入休眠，等待被唤醒，并触发协程调度
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
    
    // 8. 被唤醒之后执行清理工作并释放sudog结构体
    gp.waiting = nil
    gp.activeStackChans = false
    closed := !mysg.success // g被唤醒的原因是因为数据传递还是通道被关闭
    gp.param = nil
    mysg.c = nil
    releaseSudog(mysg)
    // 9.因关闭被唤醒则panic
    if closed {
        panic(plainError("send on closed channel"))
    }
    // 10.数据成功传递
    return true
}

  1. channel为nil检查。为空则死锁。

  2. 加锁

  3. 如果channel已关闭，直接panic。

  4. 当存在阻塞读协程，直接把数据发送给读协程，唤醒并将其放入协程可运行队列中等待调度运行。

  5. 当缓冲区未满时，将当前发送的数据拷贝到缓冲区。

  6. 当既没有阻塞读协程，缓冲区也没有剩余空间时，将协程加入阻塞写队列sendq。

  7. 调用gopark将当前协程设置为等待状态，进入休眠等待被唤醒，触发协程调度。

  8. 被唤醒之后执行清理工作并释放sudog结构体

  9. 唤醒之后检查，因channel被关闭导致协程唤醒则panic。

  10. 返回。

1.4 通道读

2种异常情况处理

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // 1.channel为nil
    if c == nil {
        // 否则，当前Goroutine阻塞挂起
        gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }

    lock(&c.lock)
    // 2.如果channel已关闭，并且缓冲区无元素，返回(true,false)
    if c.closed != 0 {
        if c.qcount == 0 {
            unlock(&c.lock)
            if ep != nil {
                //根据channel元素的类型清理ep对应地址的内存，即ep接收了channel元素类型的零值
                typedmemclr(c.elemtype, ep)
            }
            return true, false
        }
    }
}

  1. channel未初始化，读操作会死锁

  2. channel已关闭且缓冲区无数据，给读变量赋零值。

读时有阻塞写协程

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    lock(&c.lock)
    
    // Just found waiting sender with not closed.
    // 等待发送的队列sendq里存在Goroutine
    if sg := c.sendq.dequeue(); sg != nil {
        // Found a waiting sender. If buffer is size 0, receive value
        // directly from sender. Otherwise, receive from head of queue
        // and add sender's value to the tail of the queue (both map to
        // the same buffer slot because the queue is full).
        // 如果无缓冲区，那么直接从sender接收数据；否则，从buf队列的头部接收数据，并把sender的数据加到buf队列的尾部
        recv(c, sg, ep, func() { unlock(&c.lock) }, 3)
        return true, true // 接收成功
    }
    
    
}

// recv processes a receive operation on a full channel c.
func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    // channel无缓冲区，直接从sender读
    if c.dataqsiz == 0 {
        if ep != nil {
            // copy data from sender
            t := c.elemtype
            src := sg.elem
            typeBitsBulkBarrier(t, uintptr(ep), uintptr(src), t.size)
            memmove(dst, src, t.size)
        }
    } else {
        // 从队列读,sender再写入队列
        qp := chanbuf(c, c.recvx)
        // copy data from queue to receiver
        if ep != nil {
            typedmemmove(c.elemtype, ep, qp)
        }
        // copy data from sender to queue
        typedmemmove(c.elemtype, qp, sg.elem)
        c.recvx++
        if c.recvx == c.dataqsiz {
            c.recvx = 0
        }
        c.sendx = c.recvx // c.sendx = (c.sendx+1) % c.dataqsiz
    }
    // 唤醒sender队列协程sg
    sg.elem = nil
    gp := sg.g
    unlockf()
    gp.param = unsafe.Pointer(sg)
    sg.success = true
    // 唤醒协程
    goready(gp, skip+1)
}

  1. 加锁

  2. 从阻塞写队列取出sudog节点

  3. 假如channel为无缓冲区通道，则直接读取sudog对应写协程数据，唤醒写协程。

  4. 假如channel为缓冲区通道，从channel缓冲区头部(recvx)读数据，将sudog对应写协程数据，写入缓冲区尾部(sendx)，唤醒写协程。

  5. 解锁

读时无阻塞写协程且缓冲区有数据

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    lock(&c.lock)
    // 缓冲区buf中有元素,直接从buf拷贝元素到当前协程(在已关闭的情况下，队列有数据依然会读)
    if c.qcount > 0 {
        // Receive directly from queue
        qp := chanbuf(c, c.recvx)
        if ep != nil {
            typedmemmove(c.elemtype, ep, qp)// 将从buf中取出的元素拷贝到当前协程
        }
        typedmemclr(c.elemtype, qp) // 同时将取出的数据所在的内存清空
        c.recvx++
        if c.recvx == c.dataqsiz {
            c.recvx = 0
        }
        c.qcount--
        unlock(&c.lock)
        return true, true // 接收成功
    }
}

  1. 加锁

  2. 从环形缓冲区读数据。在channel已关闭的情况下，缓冲区有数据依然可以被读。

  3. 解锁

读时无阻塞写协程且缓冲区无数据

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    lock(&c.lock)

    // no sender available: block on this channel.
    // 阻塞模式，获取当前Goroutine，打包一个sudog，并加入到channel的接收队列recvq里
    gp := getg()
    mysg := acquireSudog()
    mysg.elem = ep
    gp.waiting = mysg
    mysg.g = gp
    mysg.c = c
    gp.param = nil
    c.recvq.enqueue(mysg) // 入接收队列recvq
    
    // 挂起当前Goroutine，设置为_Gwaiting状态，进入休眠等待被唤醒
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)

    // 因通道关闭或者读到数据被唤醒
    gp.waiting = nil
    success := mysg.success
    gp.param = nil
    mysg.c = nil
    releaseSudog(mysg)
    return true, success // 10.返回成功
}

  1. 加锁。

  2. 将当前协程gp封装成sudog节点，加入channel的阻塞读队列recvq。

  3. 调用gopark将当前协程设置为等待状态并解锁，触发调度其它协程运行。

  4. 因读到数据或者channel被关闭，协程从park中被唤醒，清理sudog结构。

  5. 返回

整体读流程

Golang channel底层是如何实现的？

// chanrecv receives on channel c and writes the received data to ep.
// ep may be nil, in which case received data is ignored.
// If block == false and no elements are available, returns (false, false).
// Otherwise, if c is closed, zeros *ep and returns (true, false).
// Otherwise, fills in *ep with an element and returns (true, true).
// A non-nil ep must point to the heap or the caller's stack.
func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // 1.channel为nil
    if c == nil {
        // 否则，当前Goroutine阻塞挂起
        gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }
    // 2.加锁
    lock(&c.lock)
    // 3.如果channel已关闭，并且缓冲区无元素，返回(true,false)
    if c.closed != 0 {
        if c.qcount == 0 {
            unlock(&c.lock)
            if ep != nil {
                //根据channel元素的类型清理ep对应地址的内存，即ep接收了channel元素类型的零值
                typedmemclr(c.elemtype, ep)
            }
            return true, false
        }
        // The channel has been closed, but the channel's buffer have data.
    } else {
        // Just found waiting sender with not closed.
        // 4.存在阻塞写协程
        if sg := c.sendq.dequeue(); sg != nil {
            // Found a waiting sender. If buffer is size 0, receive value
            // directly from sender. Otherwise, receive from head of queue
            // and add sender's value to the tail of the queue (both map to
            // the same buffer slot because the queue is full).
            // 如果无缓冲区，那么直接从sender接收数据；否则，从buf队列的头部接收数据，并把sender的数据加到buf队列的尾部
            recv(c, sg, ep, func() { unlock(&c.lock) }, 3)
            return true, true // 接收成功
        }
    }
    // 5.缓冲区buf中有元素,直接从buf拷贝元素到当前协程(在已关闭的情况下，队列有数据依然会读)
    if c.qcount > 0 {
        // Receive directly from queue
        qp := chanbuf(c, c.recvx)
        if ep != nil {
            typedmemmove(c.elemtype, ep, qp)// 将从buf中取出的元素拷贝到当前协程
        }
        typedmemclr(c.elemtype, qp) // 同时将取出的数据所在的内存清空
        c.recvx++
        if c.recvx == c.dataqsiz {
            c.recvx = 0
        }
        c.qcount--
        unlock(&c.lock)
        return true, true // 接收成功
    }

    // no sender available: block on this channel.
    // 6.获取当前Goroutine，封装成sudog节点，加入channel阻塞读队列recvq
    gp := getg()
    mysg := acquireSudog()
    mysg.elem = ep
    mysg.waitlink = nil
    gp.waiting = mysg
    mysg.g = gp
    mysg.c = c
    gp.param = nil
    c.recvq.enqueue(mysg) // 入接收队列recvq
    
    atomic.Store8(&gp.parkingOnChan, 1)
    // 7.挂起当前Goroutine，设置为_Gwaiting状态，进入休眠等待被唤醒
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)

    // 8.因通道关闭或者可读被唤醒
    gp.waiting = nil
    gp.activeStackChans = false
    success := mysg.success
    gp.param = nil
    mysg.c = nil
    releaseSudog(mysg)
    // 9.返回
    return true, success 
}

通道读流程如下:

  1. channel为nil检查。空则死锁。

  2. 加锁。

  3. 如果channel已关闭，并且缓冲区无数据，读变量赋零值，返回。

  4. 当存在阻塞写协程，如果缓冲区已满，则直接从sender接收数据；否则，从环形缓冲区头部接收数据，并把sender的数据加到环形缓冲区尾部。唤醒sender，将其放入协程可运行队列中等待调度运行，返回。

  5. 如果缓冲区中有数据，直接从缓冲区拷贝数据到当前协程，返回。

  6. 当既没有阻塞写协程，缓冲区也没有数据时，将协程加入阻塞读队列recvq。

  7. 调用gopark将当前协程设置为等待状态，进入休眠等待被唤醒，触发协程调度。

  8. 因通道关闭或者可读被唤醒。

  9. 返回。

1.5 通道关闭

func closechan(c *hchan) {
    // // 1.channel为nil则panic
    if c == nil {
        panic(plainError("close of nil channel"))
    }
    lock(&c.lock)
    // 2.已关闭的channel再次关闭则panic
    if c.closed != 0 {
        unlock(&c.lock)
        panic(plainError("close of closed channel"))
    }
    // 设置关闭标记
    c.closed = 1

    var glist gList
    // 遍历recvq和sendq中的协程放入glist
    // release all readers
    for {
        sg := c.recvq.dequeue()
        if sg == nil {
            break
        }
        if sg.elem != nil {
            typedmemclr(c.elemtype, sg.elem)
            sg.elem = nil
        }
        if sg.releasetime != 0 {
            sg.releasetime = cputicks()
        }
        gp := sg.g
        gp.param = unsafe.Pointer(sg)
        sg.success = false
        glist.push(gp)
    }

    // release all writers (they will panic)
    for {
        sg := c.sendq.dequeue()
        if sg == nil {
            break
        }
        sg.elem = nil
        if sg.releasetime != 0 {
            sg.releasetime = cputicks()
        }
        gp := sg.g
        gp.param = unsafe.Pointer(sg)
        sg.success = false
        glist.push(gp)
    }
    unlock(&c.lock)

    // 3.将glist中所有Goroutine的状态置为_Grunnable，等待调度器进行调度
    for !glist.empty() {
        gp := glist.pop()
        gp.schedlink = 0
        goready(gp, 3)
    }
}

  1. channel为nil检查。为空则panic

  2. 已关闭channel再次被关闭，panic

  3. 将sendq和recvq所有Goroutine的状态置为_Grunnable，放入协程调度队列等待调度器调度

2 高频面试题

  1. channel 的底层实现原理 （数据结构）

  2. nil、关闭的 channel、有数据的 channel，再进行读、写、关闭会怎么样？（各类变种题型）

  3. 有缓冲channel和无缓冲channel的区别

原文链接：https://reurl.cc/Wx26jD

最新文章 相关文章

Go语言web框架Gin响应客户端的方式

目录 前言 一、响应html页面 1、我们首先定义一个存放模板文件的templates文件夹 2、让程序进行页面渲染和加载 3、通过请求来响应页面 4、启动测试 5、静态文件处理

2024-10-20 21:49:39

Golang标准库之errors包应用方式

目录 一. errors的基本应用 二. 错误类型的比较 三. error的扩展 3.1 自定义error 3.2 Unwrap与Nested error 3.3 errors.Is方法与错误分类 3.4 errors.As方法与错误信

2024-10-20 21:49:21

Go语言标准错误error全面解析

目录 错误类型 新建错误 错误解析 错误处理 总结错误类型 errorString错误是程序中处理逻辑和系统稳定新的重要组成部分。在go语言中内置错误如下：// The error built-in int

2024-10-20 21:49:12

Go语言的io输入输出流方式

目录 Go语言的io输入输出流 go语言输入输出在io库中 上述只是输入输出流的基本用法 常用的类型有 总结 Go语言的io输入输出流Go语言的输入输出流不如其他语言那么直观

2024-10-20 21:49:02

Go中Vendo机制的使用

目录 1. 介绍 2. vendor 目录位置 3. 搜索顺序 4. vendor 的不足1. 介绍自 Go 1.6 起，vendor 机制正式启用，它允许把项目的依赖放到一个位于本项目的 vendor 目录中，这个 vendo

2024-10-18 23:12:01

go语言中io操作中的 io.Reader 和 io.Writer的获取方法

目录 go中Reader Writer接口定义 os.File对象中的RW实现代码 bufio.Reader中的RW实现代码 bytes.Buffer中的RW实现代码我们在对文件进行io操作的时候，经常看到需要我们传递一

2024-10-18 23:11:52

golang并发编程使用Select语句的实现

目录 select 语句的基本用法 示例代码 示例 1：从多个通道接收数据 示例 2：实现超时机制 示例 3：非阻塞的通道操作 select 语句的注意事项 高级用法 在 Go 语言中，select

2024-10-18 23:11:43

go语言time.After()的作用

目录 1.延迟执行、定时任务 2.超时控制 go time.After 定时器示例 3.time.Sleep和time.After的差异 time.After是一个非常实用的函数，它返回一个用于读取的单向通道（<-cha

2024-10-18 23:11:35

go实现一个内存缓存系统的示例代码

目录 面试内容：面试内容： 支持设定过期时间，精度到秒 支持设定最大内存，当内存超出时做出合适的处理 支持并发安全 要求按照以下接口实现SetMemory(size string) bool Set(key s

2024-10-18 23:11:26

Golang Map简介以及底层原理

目录 Map 简介 Map 定义 Map Iteration Map 的线程安全 map 底层原理 哈希函数 哈希冲突 Growing map扩容 双倍扩容 Growing过程 避免溢出 代码分析

2024-10-18 23:11:17

Go语言中的定时器原理与实战应用

目录 一、Timer定时器 1. 创建Timer 2. 停止Timer 3. 重置Timer 4. time.AfterFunc 5. time.After 二、Ticker定时器 1. 创建Ticker 2. 监听Ticker事件 3. 停止T

2024-10-14 19:47:39

Golang 错误处理：如何优雅地处理与外部 API 的错误

保证与外部 api 交互时的应用程序稳定性至关重要。go 提供了完善的错误处理机制，让您优雅地捕捉来自外部 api 的错误。首先使用 error 接口指示操作成功与否，其次 if 语句检查

2024-09-30 00:06:02

Go语言字符串处理库strings包详解

目录 Golang字符串处理库strings 1. 导入strings包 2. 字符串的查找 1. 判断字符串是否包含子串 2. 判断某个字符串是否包含了多个字符串中的某一个 3. 字符串计数 4.

2024-09-29 23:28:06

使用IDEA配置GO语言的开发环境备忘录

目录1. 安装GO1.1 下载&安装1.2 配置相关环境变量1.3 检查安装2. 配置IDEA2.1 安装GO插件2.2 配置GOROOT2.3 配置GOPATH3. GO HelloWorld总结1. 安装GO1.1 下载&安装进入GO

2024-08-28 19:53:16

Golang发送Get和Post请求的实现

目录Get请求Post请求最近在研究钉钉机器人，发现钉钉的第三方接口有时需要用Get或者Post请求访问，虽然说可以通过Apifox直接模拟发送请求，但是我还是想研究一个如何使用Golang来

2024-08-28 19:53:13

一文了解Go 并发与并行

目录并发（Concurrency）并行（Parallelism）关系与区别Go语言，由Google的Robert Griesemer、Rob Pike和Ken Thompson于2009年开发，是一种静态类型、垃圾回收、多线程并发的编程语言。

2024-08-28 19:53:11

go语言解决并发问题小结

目录一、选择GO的原因二、GO解决的并发问题方法1：使用sync.WaitGroup方法2：使用ErrGroup库一、选择GO的原因作为一个后端开发，日常工作中接触最多的两门语言就是PHP和GO了。无

2024-08-28 19:53:09

Golang使用切片实现单链表的示例代码

单链表（Single Linked List）是链表数据结构的一种实现方式，它包含一系列节点（Node），每个节点都包含一个数据域和一个指向下一个节点的指针。与数组相比，链表的一个主要优点是它们可

2024-08-28 19:53:07

Go语言使用MongoDB数据库详细步骤

目录MongoDB 安装(Docker)安装 MongoDB Go 驱动基础代码使用 Go Driver 连接到 MongoDB在 Go 里面使用 BSON 对象CRUD 操作插入文档更新文档查询文档删除文档下一步总结Mong

2024-08-28 19:53:05

Golang操作excel的技巧与方法

目录关键术语介绍创建表格读取表格修改表格样式设置关键术语介绍为了方便开源库的快速上手，我们先来了解 excel 中的几个关键术语，如下图所示，①为sheet，也就是表格中的页签；②为

2024-08-28 19:53:03

使用Go语言编写一个简单的Web框架

目录一、Go Web框架的基本原理二、编写一个简单的Web框架1. 创建HTTP服务器2. 实现路由3. 添加中间件4. 使用模板引擎一、Go Web框架的基本原理在编写Web框架之前，我们需要了

2024-08-28 19:53:00

图文详解Go程序如何编译并运行起来的

目录Go程序是如何编译的从hello RdrB1te开始Go 编译过程Go程序是如何运行起来的Go程序的入口？总结Go程序是如何编译的从hello RdrB1te开始package main import "fmt" f

2024-08-28 19:52:59

Go语言使用Json的方法实现

目录 1、使用标准库中的encoding/json包 2、使用第三方包3、decode 4、注意5、更灵活地使用JSON使用json.RawMessage使用interface{}在Go语言中，处理JSON数据通常涉及编码（将

2024-08-28 19:52:54

详解如何使用Golang实现自定义规则引擎

目录支持的语句逻辑与算术运算流程控制高级语句规则语法的解析定义规则语法编写解析器语法解析器生成语法树遍历语法树生成语句表达式规则语法的执行支持自定义对象注入支持

2024-08-28 19:52:52

go 微服务框架kratos使用中间件的方法

目录一、中间件的概念二、go原生http中使用中间件的方法三、go微服务框架Kratos使用中间件的方法一、中间件的概念在go语言中，中间件是一种用于处理http请求的开发模式，允许开

2024-08-28 19:52:50

golang开发 gorilla websocket的使用示例详解

目录websocket的简单使用改成自定义的协议生产的部署很多APP都需要主动向用户推送消息，这就需要用到长连接的服务，即我们通常提到的websocket，同样也是使用socket服务，通信协议

2024-08-28 19:52:47

Go中阻塞以及非阻塞操作实现(Goroutine和main Goroutine)

main函数本身也是一个Goroutine。在Go语言中，main函数是程序的入口点。当程序启动时，Go运行时会创建一个名为main的Goroutine，并在其中执行main函数的代码。这个main Goroutine

2024-08-28 19:52:41

Golang安全读写共享变量的方式详解

目录1. 使用互斥锁(Mutex)2. 使用channel3. 读写锁(sync.RWMutex)4. 原子操作(sync/atomic包)5. sync.Once1. 使用互斥锁(Mutex)互斥锁（Mutex）是一种常用的同步原语，用于防止多

2024-08-28 19:52:39

Go使用Viper库读取YAML配置文件的示例代码

安装 Viper： 首先，你需要确保已经安装了 Viper。可以通过运行以下命令来安装 Viper：go get github.com/spf13/viper创建 YAML 配置文件： 创建一个配置文件 config.yaml，包含数据

2024-08-28 19:52:37

使用Go语言实现接口继承的方式

目录如何使用Go语言实现接口继承？示例代码原因和解决方案总结如何使用Go语言实现接口继承？在Go语言中，接口（interface）是一种定义方法集合的类型，它并不包含方法的具体实现，只是规

2024-08-28 19:52:35

热点内容

goland2020.2.x永久激活码破解详细教程亲测可用(Windows Linux Mac)
2020-11-25
解决Goland 提示 Unresolved reference 错误的问题
2020-12-15
golang gorm 计算字段和获取sum()值的实现
2020-12-19
golang判断net.Conn 是否已关闭的操作
2020-12-24
go日志系统logrus显示文件和行号的操作
2020-11-10
golang获取网卡信息操作
2020-12-24
GoAdminGroup/go-admin的安装和运行的教程详解
2020-09-29
golang gorm多条件筛选查询操作
2020-12-19
如何解决go语言输出中文乱码的问题
2020-12-29
Goland调节字体大小的设置(编辑区,terminal区,页面字体)
2020-12-21
返回顶部
顶部