async_task_manager

type AsyncTaskCallBack func(AsyncTaskInterface)

type AsyncTaskHandle interface {
	Start(AsyncTaskInterface)              // 开始执行任务
	Stop()                                 // 结束任务,然后拉起回调,返回enmu.UserStopError
	SetHandleCallBack(f AsyncTaskCallBack) // 配置执行的回调
}

type AsyncTaskInterface interface {
	GetTag() *TaskTag       // 任务全局唯一标识
	SetStartUnix(end int64) // 设置任务开始时间
	GetStartUnix() int64    // 获取任务开始时间
	SetEndUnix(end int64)   // 设置任务结束时间
	GetEndUnix() int64      // 获取任务结束时间
	SetStatus(s uint8)      // 设置当前任务状态
	GetStatus() uint8       // 获取当前任务状态
	SetError(e error)
	GetError() error
}

type AsyncTaskManagerInterface interface {
	Start()                                                                              // 开始
	Stop()                                                                               // 停止
	SetWaitListMaxLength(l int)                                                          // 设置等待队列的最大长度,默认:1000
	SetWorkPoolSize(s int)                                                               // 设置并行的数量,默认:100
	AddAsyncTask(t AsyncTaskInterface, h AsyncTaskHandle, cb ...AsyncTaskCallBack) error // 增加一个异步任务
	SetFinishCallBack(f func(*TaskManagerResult))                                        // 设置任务完成的回调,定长任务有效
	CheckTaskInWork(tag string) (bool, error)                                            // 查验任务是否在执行
	GetWaitLength() int                                                                  // 获取当前等待队列长度
	GetWorkerLength() int                                                                // 获取当前工作队列长度
	GetManagerStatus() uint8                                                             // 获取管理器状态
	SetTaskMaxLength(s int)                                                              // 设置最大任务数
	SetProgressCallBack(p int, cb ProgressCallBack)                                      // 设置进度回调,定长任务有效
}

type DefaultAsyncTask struct {
	Tag    *TaskTag
	Start  int64
	End    int64
	Status uint8
	Err    error
}

type DefaultAsyncTaskManager struct {
	// contains filtered or unexported fields
}

type DefaultOneToManyTask struct {
	*DefaultAsyncTask
	// contains filtered or unexported fields
}

type DefaultOneToManyTaskManager struct {
	// contains filtered or unexported fields
}

type OneToManyTaskHandleInterface interface {
	Start(AsyncTaskInterface)              // 开始执行任务
	Stop()                                 // 结束任务,然后拉起回调,返回enmu.UserStopError
	SetHandleCallBack(f AsyncTaskCallBack) // 配置执行的回调
	GetTarget() *TaskTag                   // 同一任务中唯一
}

type OneToManyTaskInterface interface {
	AsyncTaskInterface
	SetTaskTag(tag *TaskTag)
	GetHandleTag() *TaskTag
	SetHandleTag(tag *TaskTag)
	GetHandleResult() interface{}
	SetHandleResult(res interface{})
	Copy() OneToManyTaskInterface
}

type OneToManyTaskManagerInterface interface {
	Start()                                                                                                                  // 开始
	Stop()                                                                                                                   // 停止
	SetWaitListMaxLength(l int)                                                                                              // 设置等待队列的最大长度,默认:1000
	SetWorkPoolSize(s int)                                                                                                   // 设置并行的数量,默认:100
	AddAsyncTask(t OneToManyTaskInterface, cb func(res *OneToManyTaskResult), handles ...OneToManyTaskHandleInterface) error // 增加一个异步任务
	CheckTaskInWork(tag string) (bool, error)                                                                                // 查验任务是否在执行
	GetWaitLength() int                                                                                                      // 获取当前等待队列长度
	GetWorkerLength() int                                                                                                    // 获取当前工作队列长度
	GetManagerStatus() uint8                                                                                                 // 获取管理器状态
}

type OneToManyTaskResult struct {
	StartTime int64
	EndTime   int64
	Status    uint8
	Task      OneToManyTaskInterface
	ResultMap map[string]interface{}
}

type ProgressCallBack func(*TaskProgress)

type TaskManagerResult struct {
	StartTime int64
	EndTime   int64
	Length    uint64
	TagsMap   map[string]AsyncTaskInterface
	Status    uint8
}

type TaskProgress struct {
	WorkNum    int   // 任务并行数
	AllTaskNum int   // 总任务数,如果没有SetTaskMaxLength(),返回0
	Progress   int   // 当前完成个数
	ParentTime int64 // 上次进度回调的时间
}

type TaskTag struct {
	Id   string
	Mark string
}