diskqueue第三篇 - 基本数据定义，运转核心ioloop()源码详解

本文链接：https://blog.csdn.net/yzf279533105/article/details/132651728

diskqueue是nsq消息持久化的核心，内容较多，故分为多篇

1. diskqueue第一篇 - 是什么，为什么需要它，整体架构图，对外接口

2. diskqueue第二篇 - 元数据文件，数据文件，启动入口，元数据文件的读写及保存

3. diskqueue第三篇 - 数据定义详解，运转核心ioloop()源码详解

4. diskqueue第四篇 - 怎么写入消息，怎么对外发送消息

5. diskqueue第五篇 - 追尾检测，错误处理，如何正常关闭

6. diskqueue第六篇 - 如何使用diskqueue

前面一篇博客 diskqueue的元数据文件，数据文件，启动入口，元数据文件读写和保存中我们讲了diskqueue的两种文件存储格式，diskqueue的启动入口，元数据文件的读取和保存，如果你还没了解过，建议先看一下

这篇博客，我们重点讲diskqueue的定义，以及最核心的ioloop循环

1. diskqueue的数据定义

先看下diskqueue的源码定义，如下(已加详细注释)

都是一些变量定义，已经加了详细的注释，这里不再一一介绍，只是总结下

1. 前面的5个变量 readPos, writePos, readFileNum, writeFileNum, depth不用多介绍，上一篇博客已经讲过了，都是元数据的字段，描述队列的整体信息

2. 至于name, dataPath,maxBytesPerFile, minMsgSize, maxMsgSize, syncEvery, syncTimieout，这7个变量都是diskqueue启动时外部传入的，主要是设置队列属性

3. maxBytesPerFileRead 不同于 maxBytesPerFile：

maxBytesPerFile 是所有消息数据文件的最大写入字节数，是个限制值，比如100M

maxBytesPerFileRead 是当前读文件的最大可读字节数，这个是实际值，每当读一个新文件时都会获取文件的实际大小，实际只能读这么多，比如文件实际是99.97M，那只能读这么多

4. needSync是标记是否需同步磁盘，读写次数超过限定的syncEvery时，或需新建写文件时都要置为true，ioloop()循环就会执行一次强制刷新到磁盘

5. nextReadPos和nextReadFileNum，我们一般会认为，数据读取后不就可以后移读位置了么？其实不是这样的，因为这里读取完毕后仅仅是尝试压入readChan，不代表外部真的接收了。举例：这里读取成功后尝试压入到readChan，readChan是个无缓冲的通道，但外部一直没接收最后还关闭了自己，下次再从这里读消息时我们还要投递这个消息，也就是说读取位置不能变；nextReadFileNum同理，只有上一个文件全部读取且外部接收成功了，这里才能读新文件

6. readChan和peekChan，对外提供的ReadChan()是获取一个只读通道，这里读取一个消息后压入readChan，等待外部接收后才返回，后移读位置，再读取下一个消息；对外提供的PeekChan()也是获取一个只读通道，等待外部接收后才返回，但是不后移读位置，也不会触发读下一个消息，也就是说PeekChan()正如其名，仅仅提供查看功能

2. diskqueue的核心ioloop()

我们先说下ioloop()函数的运作机制，这样大家先做到心里有数，再看源码就很轻松了

1. 建立一个定时器，触发时间为外部传入的syncTimeout，定时器触发时检测有没有读写发生，有则同步一次磁盘

2. writeChan是接收外部写入的通道，外部写入后，本函数会在select中读取到，调用writeOne()写入到当前的写文件(如果发现文件即将超上限，就新开一个文件写)，count值+1

3. readChan是给外部读取的通道，本函数总是会读取一个消息往readChan中压入，等待外部接收，外部接收成功后，本函数会在select中返回，就再读取下一个消息（如果发现当前读文件已读完，就读下一个文件），count值+1

4. 每读取一个消息，每写入一个消息，count都会加1，cout值达到外部传入的syncEvery，就同步一次磁盘

5. emptyChan 用来接收外部的清空信号，本函数的select中接收到就进行清空操作

6. exitChan 用来接收外部的退出信号，本函数的select中接收到就进行退出操作

好了，上面的6个操作就是ioloop()函数的核心了，现在贴代码（已添加详细注释）

// 独立协程运行
func (d *diskQueue) ioLoop() {
	var dataRead []byte		// 存储每次读取的数据
	var err 	error
	var count 	int64		// 每read，write一次，count值+1，满syncEvery则往磁盘同步一次
	var r 		chan []byte	// 对外的读消息通道（为nil时说明没有数据可读）
	var p 		chan []byte	// 对外的查看消息通道（为nil时说明没有数据可读）

	// 同步定时器
	syncTicker := time.NewTicker(d.syncTimeout)

	for {
		// count值够了就标记需同步
		if count == d.syncEvery {
			d.needSync = true
		}

		// 发现需同步
		if d.needSync {
			err = d.sync()	// 同步到磁盘（该函数在同步磁盘后会把needSync置为false）
			if err != nil {
				d.logf(ERROR, "DISKQUEUE(%s) failed to sync - %s", d.name, err)
			}
			count = 0		// count重新从0开始计
		}

		// 有消息可读的条件：读的是旧文件 或者 读的位置比写的位置小
		if (d.readFileNum < d.writeFileNum) || (d.readPos < d.writePos) {
			// 读位置已经移动(说明外部取走了数据)，才可读下一个消息
			if d.nextReadPos == d.readPos {
				dataRead, err = d.readOne()
				if err != nil {
					d.logf(ERROR, "DISKQUEUE(%s) reading at %d of %s - %s", d.name, d.readPos, d.fileName(d.readFileNum), err)
					// 读出错的处理
					d.handleReadError()
					continue
				}
			}
			// 赋值通道
			r = d.readChan
			p = d.peekChan
		} else {	// 不可读的时候，把r,p置为nil，确保下面的select会直接跳过，外部使用者在select中判断时也会跳过
			r = nil
			p = nil
		}

		// go中通道的特性决定：select中对为nil的chan的读/写操作会直接跳过，
		// 所以只有有数据可读的时候，p,r才有值(p指向peekChan，r指向readChan)
		select {
		case p <- dataRead:
			// 注意，这里什么都没做，因为p仅仅是查看通道，消息不算取走

		case r <- dataRead:	// 把读出来的这个消息压入到readChan，外部从readChan取走以后，这里会立即返回
			// 每取走一个消息，count值+1
			count++
			// 重新计算下次读位置，读文件号
			d.moveForward()

		case d.depthChan <- d.depth:	// 把最新的未读消息数压入对外通道
			// 什么都不做，外部取走未处理消息数跟本协程没关系

		case <-d.emptyChan:	// 收到清空队列的信号
			d.emptyResponseChan <- d.deleteAllFiles()	// 删除所有的文件(清空队列)，并把结果压入返回通道，因为外部调用者还在等结果
			count = 0 // 重新从0计数

		case dataWrite := <-d.writeChan: // 新接收到消息
			count++	// 每收到一个消息，count值+1
			d.writeResponseChan <- d.writeOne(dataWrite) // 消息写入到文件缓冲区，结果压入返回通道

		case <-syncTicker.C:// 同步定时器
			if count == 0 {
				continue	// 虽然时间到了，但数据没有变化，也不用同步
			}
			d.needSync = true // 这里仅标记，下次for循环会进行同步操作

		case <-d.exitChan:	// 退出信号
			goto exit
		}
	}

exit:
	d.logf(INFO, "DISKQUEUE(%s): closing ... ioLoop", d.name)
	syncTicker.Stop()

	// 退出完成，往exitSyncChan发信号，因为主协程还在等
	d.exitSyncChan <- 1
}

上面已经讲了ioloop()函数的运作机制，代码也添加了详细的注释，相信大家都能轻松看懂

我再啰嗦下几个值得注意的点

1. diskqueue的运作流程是一边新写入消息，一边读取处理，像生产者消费者机制一样

如果读慢写快，结果就是消息文件会一直新增，这倒没什么，反正消息已保存进文件了，后面再处理就是了

如果读快写慢，那么只要持续的时间够长，读的位置一定会追上写的位置，造成无消息可读，等于发生了读写追尾，这个时候读操作就要停止

所以总结下可读操作的条件：

要么读的文件号较小，写的文件号较大，读写不是同一个文件；

要么读写的是同一个文件，但读的位置比写的位置小；

2. 函数内：r表可读的通道，p表查看的通道，当不可读的时候，r,p均赋值为nil，本函数的select会直接跳过对值为nil通道的写入，外部接受者的select也会跳过对值为nil通道的读取，这是golang通道的特性之一，大家注意

3. diskqueue在退出/删除时会调用exit()函数，该函数会关闭通道exitChan，此时ioloop()的select就会返回，关闭ioloop的协程。注意：关闭通道时，所有监听该通道的select都会收到消息，这也是golang通道的特性之一