对Channel的使用方法和底层机制进行记录。



### 1 数据结构

channel 的内部实现是在`src/runtime/chan.go`文件里的 hchan 结构体。很多别的 builtin 函数，结构的源代码也在这个位置。

![image.png](https://www.misaka19327.cc/static/img/27a385130e91199eea49844d2999b4a8.image.png)

总体上来说，channel 是利用了一个环形数组来以队列的形式存储管道里的数据（之后所说的环形数组、队列和缓冲区，所指的就是这个数据结构），并且利用两个队列来存储等待中的待读协程和待写协程。

一个 channel，其内部有如下数据：

``` go
type hchan struct {
	qcount   uint           // total data in the queue
	dataqsiz uint           // size of the circular queue
	buf      unsafe.Pointer // points to an array of dataqsiz elements
	elemsize uint16
	closed   uint32
	elemtype *_type // element type
	sendx    uint   // send index
	recvx    uint   // receive index
	recvq    waitq  // list of recv waiters
	sendq    waitq  // list of send waiters

	// lock protects all fields in hchan, as well as several
	// fields in sudogs blocked on this channel.
	//
	// Do not change another G's status while holding this lock
	// (in particular, do not ready a G), as this can deadlock
	// with stack shrinking.
	lock mutex
}
```

- qcount，uint，当前队列中剩余的元素个数。
- dataqsiz，uint，环形数组长度，即总共可以存放的元素个数（make时传入的那个长度）。
- buf，unsafe.Pointer，指向环形数组的那个指针。
- elemsize，uint16，环形数组中每个元素的大小（或者说创建channel时指定的类型的实例的大小）。
- closed，uint32，用于标识channel是否关闭。
- elemtype，*_type，元素类型。
- sendx，uint，队列下标，它所指向的是元素写入时应该被存放的位置。
- recvx，uint，同sendx，但是指向的是要被读取元素的位置。
- recvq，waitq，等待读取的被阻塞的协程队列。
- sendq，waitq，等待写入的被阻塞的协程队列。
- lock，mutex，互斥锁。在同一时刻下，channel。只会被一个协程读写。

创建 channel 时，所调用的`make(chan int，10)`语句中，int 对应的即为 elemtype，10对应的即为dataqsiz 。

### 2 使用方法

1. 初始化

初始化一个 channel 有两种方法：`var c chan int`，该 channel 会被初始化为 nil；`c := make(chan int，10)`，它会创建一个对应的 channel 赋值给c，该 channel 是有缓冲区的。如果传入 make 函数的长度为0，那么该 channel 是无缓冲区的。

2. 操作符

`<-` 为channel的操作符。如果 channel 变量在左表示数据进入 channel ，反之 channel 变量在右则表示数据从 channel 中读取。该操作符还可以限制 channel 的读写类型。函数参数中可以有`<- channel`类型的参数和`channel <-`类型的参数，分别是在函数内只能读和只能写的 channel。

另外，从上文的数据结构中可以看出来，go 的底层并没有对 channel 的读写做限制，所以这里只是一个类型限制。

3. 读写数据

- 如果是无缓冲区的 channel，那么读写只有在存在另一个协程进行对应的操作时才不会被阻塞，反之，都会被阻塞。假设有a，b两个协程和c这个无缓冲区的 channel，a先试图向c中写入数据，那么a会被阻塞，直到b来读取c的数据时被唤醒；反之，b先来读取数据的时候也会被阻塞，直到a来写入数据时被唤醒。
- 如果是有缓冲区的channel，在channel自身的数据没存满缓冲区时，写不会被阻塞。如果数据已经存满缓冲区，那么写操作和无缓冲区的channel相同。类似的，如果缓冲区内没有数据，那么读取操作也和无缓冲区channel相同。
- 如果channel未被初始化，那么无论读写都会被**永久阻塞**。
- 读取数据有两种方式：`a := <- c`和 `a, ok := <- c`。ok变量用于指示数据是否读取成功，但并不指示 channel 是否关闭。如果 channel 为开启状态，那么读取要么有数据要么阻塞。反之，channel 为关闭状态，如果 channel 内还有数据，那么读取成功。只有在 channel 被关闭且 channel 内无数据，ok才会为false。

5. 关闭channel
- 可以通过 close 函数来关闭一个 channel，关闭之后的 channel 仍然可读，但是试图写入会引发 panic。

6. 其他操作

- len 函数可以获取 channel 内部元素的个数，cap 函数可以获取 channel 缓冲区大小。

### 3 读写原理

互斥锁加锁解锁就不说了，每次操作都会有。

channel 在写入时如果缓冲区有空间可以写，那么数据会进入缓冲区。反之，如果没有空间，那么协程会进入等待写入队列并且被休眠。如果等待读取队列不为空，那么数据会直接返回给等待读取的协程，而不进入缓冲区。

相同的，对 channel 进行读取时，如果缓冲区有数据可以读，那就从缓冲区取出数据，否则，读取协程进入等待队列睡眠，等待唤醒。如果待写队列不为空，那么数据会直接进入读取协程，不再进入缓冲区。

关闭 channel 时，待读队列内的所有协程会被唤醒，并且获取到 channel 对应类型的默认值；待写队列内的所有协程也会被唤醒，但是会引发 panic。如果关闭一个已经被关闭的 channel，也会引发 panic。

### 4 其他信息

1. for-range 语句可以用于从 channel 中读取数据，channel 中没有数据时该协程会被阻塞。
2. select 可以用于监控多个 channel，当其中一个 channel 可用时触发对应分支，否则进入 default。
3. **缓冲区长度为1的 channel，可以当互斥锁用**。没有缓冲区的 channel，可以当作两个 goroutine 进行同步的小工具。

Go 底层/特性解析 | Channel

MisakaOJ项目，第四次记录内容



### 1 删除分类接口

该接口按情况分，需要一次性彻底删除的（包括分类下的所有题目全部删除和所有子分类的父级id置零）的情况和只删除分类本身（如果分类下有东西就停止删除）的情况要分别处理。

:::tip{title="提示"}
注意，gorm的`ErrRecordNotFound`错误只会在传入的是单个结构体或者结构体指针才会触发，如果传入的是切片则不会触发该错误。该结论对`First`，`Last`，`Find`等函数都有效。

另外，`Find`，`First`差距很小，`First`可以视作按主键排序后再加一个`Limit(1)`的`Find`。

``` go
// First finds the first record ordered by primary key, matching given conditions conds
func (db *DB) First(dest interface{}, conds ...interface{}) (tx *DB) {
	tx = db.Limit(1).Order(clause.OrderByColumn{
		Column: clause.Column{Table: clause.CurrentTable, Name: clause.PrimaryKey},
	})
	if len(conds) > 0 {
		if exprs := tx.Statement.BuildCondition(conds[0], conds[1:]...); len(exprs) > 0 {
			tx.Statement.AddClause(clause.Where{Exprs: exprs})
		}
	}
	tx.Statement.RaiseErrorOnNotFound = true
	tx.Statement.Dest = dest
	return tx.callbacks.Query().Execute(tx)
}
```
:::

:::tip{title="提示"}
gorm对于启用了`gorm.Model`的模型，所使用的都是软删除。即删除时并不真正删除数据，而是在delete_at字段下留下删除时间。如果要真的将某条记录删除，需要这样：

``` go
err := DB.Unscoped().Delete(&Question{}, "identity = ?", identity).Error
if err != nil {
    // 处理错误
}
```
:::

Handler层：

``` go
// RemoveCategory
// @Tags 管理员接口
// @Summary 删除分类信息
// @Param authorization header string true "authorization"
// @Param category_id query int true "category_id"
// @Param is_cascade query bool true "is_cascade"
// @Success 200 {data} json "{"code": "200", "message": ""}"
// @Router /admin/remove_category [delete]
func RemoveCategory(c *gin.Context) {
	categoryId, e := strconv.Atoi(c.Query("category_id"))
	if e != nil {
		ErrorHandler(c, constants.ParameterParseErr.Error()+"category_id: "+e.Error())
		return
	}
	if categoryId < 0 {
		ErrorHandler(c, constants.ParameterParseErr.Error()+"category_id: less than 0")
		return
	}
	
	// 把isCascade参数解析出来
	var isCascade bool
	isCascadeString := c.Query("is_cascade")
	if isCascadeString == "" {
		ErrorHandler(c, constants.ParameterMissingErr.Error()+"is_cascade")
		return
	}
	if isCascadeString == "true" {
		isCascade = true
	} else if isCascadeString == "false" {
		isCascade = false
	} else {
		ErrorHandler(c, constants.ParameterParseErr.Error()+"is_cascade")
		return
	}
	
	// 先把要改的Category查出来
	deleteCategory := &models.Category{}
	tx := models.GetCategoryByColumn("id", categoryId)
	e = tx.First(deleteCategory).Error
	if e != nil {
		if errors.Is(e, gorm.ErrRecordNotFound) {
			ErrorHandler(c, constants.CategoryNotExistErr.Error()+"id "+string(rune(categoryId)))
			return
		}
		ErrorHandler(c, errors.Join(constants.DataBaseQueryErr, e).Error())
		return
	}
	
	// 把相联的题目和子分类全查出来
	// 先查子分类
	childrenCategory := make([]*models.Category, 0)
	tx = models.GetCategoryByColumn("parent_id", deleteCategory.ID)
	e = tx.Find(&childrenCategory).Error
	// find first 等函数传入的是数组时 不会报ErrRecordNotFound
	if e != nil {
		ErrorHandler(c, errors.Join(constants.DataBaseQueryErr, e).Error())
		return
	}
	// 查题目
	relatedQuestion := make([]*models.Question, 0)
	tx = models.GetQuestionList("", strconv.Itoa(int(deleteCategory.ID)))
	e = tx.Preload("TestCases").Find(&relatedQuestion).Error
	if e != nil {
		ErrorHandler(c, errors.Join(constants.DataBaseQueryErr, e).Error())
		return
	}
	//
	
	// 开始删除
	if isCascade {
		// 要级联删除所有信息 相关问题全部删除 子分类的父级id置零
		// 先将子分类的父级id置零
		for i := range childrenCategory {
			childrenCategory[i].ParentId = 0
			e = models.ModifyCategory(childrenCategory[i])
			if e != nil {
				ErrorHandler(c, errors.Join(constants.DataBaseUpdateErr, e).Error())
				return
			}
		}
		
		// 再删除相关问题
		for i := range relatedQuestion {
			// 删除问题分类关联表里的记录
			e = models.DeleteQCByQuestionId(relatedQuestion[i].ID)
			if e != nil {
				ErrorHandler(c, errors.Join(constants.DataBaseUpdateErr, e).Error())
				return
			}
			
			// 删除对应的测试用例
			e = models.DeleteTestCaseByQuestionId(relatedQuestion[i].Identity)
			if e != nil {
				ErrorHandler(c, errors.Join(constants.DataBaseUpdateErr, e).Error())
				return
			}
			
			// 删除对应的提交记录
			e = models.DeleteSubmitByQuestionId(relatedQuestion[i].Identity)
			if e != nil {
				ErrorHandler(c, errors.Join(constants.DataBaseUpdateErr, e).Error())
				return
			}
			
			// 最后删除问题
			e = models.DeleteQuestion(relatedQuestion[i])
			if e != nil {
				ErrorHandler(c, errors.Join(constants.DataBaseUpdateErr, e).Error())
				return
			}
		}
		
	} else {
		// 仅删除分类时 必须检查
		if len(childrenCategory) != 0 || len(relatedQuestion) != 0 {
			// 不能删除
			ErrorHandler(c, constants.CategoryCanNotCascadeDelErr.Error())
			return
		}
	}
	
	// 最后删除分类
	e = models.DeleteCategory(deleteCategory)
	if e != nil {
		ErrorHandler(c, errors.Join(constants.DataBaseDeleteErr, e).Error())
		return
	}
	
	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "Delete Category Successfully! ",
	})
}
```

对应的几个Model层函数，就挑两个作为示例：

``` go
// DeleteCategory 删除分类 传入的category只能是有数据的
func DeleteCategory(category *Category) error {
	return DB.Delete(category).Error
}

func DeleteQCByQuestionId(questionId uint) error {
	return DB.Where("question_id = ?", questionId).Delete(&QuestionCategory{}).Error
}
```

MisakaOJ | 第四次记录

MisakaOJ | 第三次记录

MisakaOJ | 第二次记录

MisakaOJ项目，第一次记录内容



### 1 建表

1. 题目表
    - identity，varchar，长度36，作为题目的唯一标识
    - cid，varchar，长度255，作为题目的分类
    - title，varchar，长度255，作为题目的标题
    - content，varchar，长度255，作为题目的正文
    - max_runtime，int，长度11，题目最大运行时间
    - max_memory，int，长度11，题目最大运行内存

``` go
type Question struct {
	gorm.Model
	Identity   string `gorm:"column:identity;type:varchar(36);" json:"identity"`        // 题目唯一标识
	CategoryId string `gorm:"column:category_id;type:varchar(255);" json:"category_id"` // 分类ID 以逗号分割
	Title      string `gorm:"column:title;type:varchar(255);" json:"title"`             // 题目标题
	Content    string `gorm:"column:content;type:text;" json:"content"`                 // 题目正文
	MaxRuntime int    `gorm:"column:max_runtime;type:int(11)" json:"max_runtime"`       // 最大运行时长
	MaxMem     int    `gorm:"column:max_memory;type:int(11)" json:"max_mem"`            // 最大允许内存
}

func (table *Question) TableName() string {
	return "question"
}
```

2. 用户表
    - identity，varchar，长度36，唯一标识
    - name，varchar，长度100，用户名
    - password，varchar，长度32，用户密码，md5加密
    - phone，varchar，长度20，用户手机号
    - mail，varchar，长度100，用户邮箱

``` go
type User struct {
	gorm.Model
	Identity string `gorm:"column:identity;type:varchar(36);" json:"identity"` // 用户唯一标识
	Name     string `gorm:"column:user;type:varchar(100);" json:"name"`        // 用户名
	Password string `gorm:"column:password;type:varchar(32);" json:"password"` // 密码 加密后
	Phone    string `gorm:"column:phone;type:varchar(20)" json:"phone"`        // 手机号
	Mail     string `gorm:"column:mail;type:varchar(100);" json:"mail"`        // 邮箱地址
}

func (table *User) TableName() string {
	return "user"
}
```

3. 分类表
    - identity，varchar，长度36，唯一标识
    - name，varchar，长度100，分类名称
    - parent_id，int，长度11，父级id，自身为顶级时默认为0

``` go
type Category struct {
	gorm.Model
	Identity string `gorm:"column:identity;type:varchar(36);" json:"identity"`        // 分类唯一标识
	Name     string `gorm:"column:user;type:varchar(100);" json:"name"`               // 分类名称
	ParentId int    `gorm:"column:parent_id;type:int(11);default:0" json:"parent_id"` // 父级ID 自身为顶级是默认为0
}

func (table *Category) TableName() string {
	return "category"
}
```

4. 提交记录表
    - identity，varchar，长度36，唯一标识
    - problem_identity，varchar，长度36，问题唯一标识
    - user_identity，varchar，长度36，用户唯一标识
    - path，varchar，长度255，代码保存位置路径
    - status，tinyint，长度1，提交记录状态，默认为0待判断，1为答案正确，2为答案错误，3运行超时，4运行超过最大内存

``` go
type Submit struct {
	gorm.Model
	Identity        string `gorm:"column:identity;type:varchar(36);" json:"identity"`                 // 提交记录唯一标识
	ProblemIdentity string `gorm:"column:problem_identity;type:varchar(36);" json:"problem_identity"` // 问题唯一标识
	UserIdentity    string `gorm:"column:user_identity;type:varchar(36);" json:"user_identity"`       // 用户唯一标识
	Path            string `gorm:"column:path;type:varchar(255);" json:"path"`                        // 保存提交代码位置的路径
	Status          int    `gorm:"column:status;type:tinyint(1);default:0;" json:"status"`            // 提交记录状态
}

func (table *Submit) TableName() string {
	return "submit"
}
```

### 2 Swagger-Gin使用

**安装**：

``` bash
go get -u github.com/swaggo/gin-swagger
go install github.com/swaggo/swag/cmd/swag@latest
go get -u github.com/swaggo/files
```

**使用**：

1. 命令行输入`swag init`即可在该位置下快速生成/更新docs包以及其中的文件
2. 命令行输入`swag -v`查看swag版本号
3. 在gin的路由器上加入swagger：`r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))`，并且在include中以匿名方式加入刚才生成的docs包。URL路径可以自己指定。
4. 运行即可在`xxxxx/swagger/index.html`下访问Swagger文档。

**为一个接口编写注释以快速生成Swagger**：

假设现在有这么一个接口：

``` go
func GetQuestionList(c *gin.Context) {
	page, err := strconv.Atoi(c.DefaultQuery("page", constants.DefaultPage))
	if err != nil {
		log.Println("Get Param Error: ", err)
		return
	}
	size, err := strconv.Atoi(c.DefaultQuery("size", constants.DefaultSize))
	if err != nil {
		log.Println("Get Param Error: ", err)
		return
	}
	keyword := c.Query("keyword")
	// 中间省略
	c.JSON(http.StatusOK, gin.H{
		"code": 200,
		"data": gin.H{
			"list":  result,
			"count": count,
		},
	})
}
```

为其添加注解可以帮助Swagger-Gin快速生成文档，比如：

``` go
// @Tags 公共方法
// @Summary 获取问题列表
// @Param page query int false "page"
// @Param size query int false "size"
// @Param keyword query string false "keyword"
// @Success 200 {data} json "{"code": "200", "data": ""}"
// @Router /question-list [get]
func GetQuestionList(c *gin.Context) {
	page, err := strconv.Atoi(c.DefaultQuery("page", constants.DefaultPage))
	if err != nil {
		log.Println("Get Param Error: ", err)
		return
	}
	size, err := strconv.Atoi(c.DefaultQuery("size", constants.DefaultSize))
	if err != nil {
		log.Println("Get Param Error: ", err)
		return
	}
	keyword := c.Query("keyword")
	// 中间省略
	c.JSON(http.StatusOK, gin.H{
		"code": 200,
		"data": gin.H{
			"list":  result,
			"count": count,
		},
	})
}
```

可以通过注解被添加到文档中的信息有以下类别：

| 注解 | 含义 | 示例 |
| --- | --- | --- |
| description | 该接口的详细说明 | @Description xxx |
| tags | 该接口的类别 | @Tags xxx |
| summary | 该接口的简短说明 | @Summary xxx |
| accept | 该接口接受数据类型 | @Accept json |
| produce | 该接口返回的数据的类型 | @Produce json |
| param | 该接口的参数 这个注解可以有多行 每一行代表一种参数 | @Param 参数名 参数类型 数据类型 是否必须 注释 属性（可选） |
| success | 该接口成功返回的结果 | @Success 返回码 {参数类型} 数据类型 注释 |
| failure | 该接口失败返回的结果 | 同success |
| response | 该接口返回结果说明 | 同success |
| router | 该接口的路径 | @Router xxx |

更多信息可以查看[官方文档](https://github.com/swaggo/swag?tab=readme-ov-file#general-api-info)

### 3 获取题目列表

``` go
// GetQuestionList
// @Tags 公共方法
// @Summary 获取问题列表
// @Param page query int false "page"
// @Param size query int false "size"
// @Param keyword query string false "keyword"
// @Success 200 {data} json "{"code": "200", "data": ""}"
// @Router /question-list [get]
func GetQuestionList(c *gin.Context) {
	page, err := strconv.Atoi(c.DefaultQuery("page", constants.DefaultPage))
	if err != nil {
		log.Println("Get Param Error: ", err)
		return
	}
	size, err := strconv.Atoi(c.DefaultQuery("size", constants.DefaultSize))
	if err != nil {
		log.Println("Get Param Error: ", err)
		return
	}
	page = (page - 1) * size // page到offset的转换
	keyword := c.Query("keyword")
	var count int64
	
	// tx是transaction的缩写
	tx := models.GetQuestionList(keyword)
	result := make([]*models.Question, 0)
	err = tx.Count(&count).Omit("content").Offset(page).Limit(size).Find(&result).Error
        // Omit 指定一行要忽略的数据
	if err != nil {
		log.Println("Get Problem List Error: ", err)
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"code": 200,
		"data": gin.H{
			"list":  result,
			"count": count,
		},
	})
}

func GetQuestionList(keyword string) *gorm.DB {
	return DB.Model(new(Question)).Where("title like ? OR content like ?", "%"+keyword+"%", "%"+keyword+"%")
}
```