Go Chan's underlying principles

Go chan The underlying principle of

What is? channel？

chan yes Go A special type of the , Different processes can be achieved through channel To interact with data .

channel There are two kinds of buffer and no buffer .

No buffer chan

If the current process has no buffer chan Send a message , But this chan When there is no ready receiving process , The current process will be blocked , Until a receiver collaboration is ready , And from chan Receive this message in .

There are buffers chan

After the buffer is filled , Try to chan The process of sending messages will be blocked . When the number of messages in the buffer is 0 when , Try from chan The process of reading messages in will be blocked .

channel The underlying implementation of

channel It is based on ring queue .

type hchan struct {
    
  qcount uint          //  Number of elements remaining in the current queue 
  dataqsiz uint        //  Ring queue length （ The number of elements that can be stored ）
  buf unsafe.Pointer   //  Ring queue pointer 
  elemsize uint16      //  Of each element ⼤⼩
  closed uint32        //  Identify the closed state 
  elemtype *_type      //  Element type 
  sendx uint           //  team 列 Subscript , Indicates where the element is stored in the queue when it is written  x
  recvx uint           //  Queue subscript , Indicates that the element is read from this position in the queue  
  recvq waitq          //  Queue of processes waiting to read messages 
  sendq waitq          //  The team waiting to write a message 列
  lock mutex           //  The mutex ,chan Concurrent reading and writing are not allowed 
} 

The circular queue （buf）

from buf The pointer points to the ring queue , All access to chan All the data will be stored in the ring queue .

Waiting in line （recvq / sendq）

• Waiting queue for reading messages （recvq）：
  If it's time to chan Buffer is empty , Or should chan There is no buffer , Then the current message reading process will be blocked . The blocked message reading process will be put into the message reading process waiting queue .

• Waiting queue for the process of writing messages （sendq）：
  If it's time to chan Buffer full , Or should chan There is no buffer , Then the current message writing process will be blocked . The blocked write message process will be put into the wait queue of the write message process .

Write data flow

picture source ：https://www.jianshu.com/p/359a6e1ccd94

Read data flow

picture source ：https://www.jianshu.com/p/359a6e1ccd94

Wake up the process

• The process blocked by reading will be directed to chan Wake up by writing data .

• The protocol blocked by writing will be removed from chan Wake up by reading data .

In general recvq and sendq At least one queue is empty . There is only one exception , That is, the same process uses select Statement to chan Read data while writing data .

channel Under what circumstances will Panic？

• To the closed chan Writing data will happen Panic
• Close the closed again chan It's going to happen Panic
• Close a value of nil Of chan It's going to happen Panic

Article reference ：https://www.jianshu.com/p/359a6e1ccd94