class CORE_API FRunnable
{
public:
    virtual bool Init(){ return true; }	// 初始化，成功返回true
    virtual uint32 Run() = 0; // 执行任务，被FRunnableThread调用
    virtual void Stop() { }	// 请求提前停止
    virtual void Exit() { }	// 退出，清理数据
    virtual class FSingleThreadRunnable* GetSingleThreadInterface(){ return nullptr; }
    virtual ~FRunnable() { }
};

class CORE_API FRunnableThread
{
public:
	static FRunnableThread* Create(const FRunnable* InRunnable, ...);
    virtual void Suspend(bool bShouldPause = true) = 0; // 暂停/继续 线程
	virtual bool Kill(bool bShouldWait = true) = 0; // 销毁线程
	FRunnableThread();
	virtual ~FRunnableThread();
protected:
	FRunnable* Runnable; // 执行体
private:
	virtual void Tick() {} // FakeThread才会调用
};

// 线程池内的线程单位
class FQueuedThread : public FRunnable
{
protected:
	FEvent* DoWorkEvent = nullptr; // 告诉线程有任务要执行
	TAtomic<bool> TimeToDie { false }; // 线程该退出了
	IQueuedWork* volatile QueuedWork = nullptr; // 线程正在执行的任务
	class FQueuedThreadPoolBase* OwningThreadPool = nullptr; // 属于的线程池
	FRunnableThread* Thread = nullptr; // 真正的线程
	virtual uint32 Run() override; // 平台线程调用
public:
	// 默认构造函数
	FQueuedThread() = default;
	// 初始化，创建线程
	virtual bool Create(class FQueuedThreadPoolBase* InPool,uint32 InStackSize = 0, EThreadPriority ThreadPriority=TPri_Normal, const TCHAR* ThreadName = nullptr);
	// 提前退出线程
	bool KillThread();
	// 执行线程池派来的任务，执行完后自行返回线程池
	// 在任务添加进线程池后且当前线程可用，才会被线程池调用(AddQueuedWork里)，正常是在Run函数里不断执行任务
	void DoWork(IQueuedWork* InQueuedWork);
};

// 线程池的抽象类，实现在FQueueThreadPoolBase里
class CORE_API FQueuedThreadPool
{
public:
	// 创建指定数量、栈大小和优先级的线程
	virtual bool Create(uint32 InNumQueuedThreads, uint32 StackSize = (32 * 1024), EThreadPriority ThreadPriority = TPri_Normal, const TCHAR* Name = TEXT("UnknownThreadPool")) = 0;
	// 清理所有后台线程
	virtual void Destroy() = 0;
	// 添加IQueueWork任务，如果有可用线程则立即执行，否则会排队
	virtual void AddQueuedWork( IQueuedWork* InQueuedWork, EQueuedWorkPriority InQueuedWorkPriority = EQueuedWorkPriority::Normal) = 0;
	// 收回之前指派的IQueueWork任务
	virtual bool RetractQueuedWork(IQueuedWork* InQueuedWork) = 0;
	// 获取池内线程数量
	virtual int32 GetNumThreads() const = 0;

public:
    FQueuedThreadPool();
	virtual	~FQueuedThreadPool();

public:
	// 创建线程池对象
	static FQueuedThreadPool* Allocate();
	// 重写栈大小
	static uint32 OverrideStackSize;
};

class FQueuedThreadPoolBase : public FQueuedThreadPool
{
protected:
    TArray<IQueuedWork*> QueuedWork; // 需要执行的任务列表
    TArray<FQueuedThread*> QueuedThreads; // 线程池内的可用线程
    TArray<FQueuedThread*> AllThreads;    // 线程池内的所有线程
    FCriticalSection* SynchQueue; // 同步临界区
    bool TimeToDie; // 超时标记

public:
    // ...这里主要是对FQueuedThreadPool里方法的实现

	// 返回线程池或者获取下一个任务
	IQueuedWork* ReturnToPoolOrGetNextJob(FQueuedThread* InQueuedThread);
};

// 线程池内执行的任务单位
class IQueuedWork
{
public:
	// 线程执行任务的地方
	virtual void DoThreadedWork() = 0;
	// 提前放弃该任务，清理数据
	virtual void Abandon() = 0;
	// 获取特殊的任务标记
	virtual EQueuedWorkFlags GetQueuedWorkFlags() const { return EQueuedWorkFlags::None; }
	// 返回任务执行中可能需要的最大内存大小
	virtual int64 GetRequiredMemory() const { return -1 /* Negative value means unknown */; }
public:
	virtual ~IQueuedWork() { }
}

template<typename TTask>
class FAsyncTask : public FAsyncTaskBase
{
	TTask Task;

	// ...

	// 尝试放弃任务
	bool TryAbandonTask() final
	{
		if (Task.CanAbandon())
		{
			Task.Abandon();
			return true;
		}
		return false;
	}

	// 执行Task
	void DoTaskWork() final { Task.DoWork(); }
};

class FBaseGraphTask
{
protected:
	// 构造函数
	FBaseGraphTask(int32 InNumberOfPrerequistitesOutstanding);
	// 设置任务执行在哪个类型的线程
	void SetThreadToExecuteOn(ENamedThreads::Type InThreadToExecuteOn);
	// 前置任务完成，或者部分完成
	void PrerequisitesComplete(ENamedThreads::Type CurrentThread, int32 NumAlreadyFinishedPrequistes, bool bUnlock = true);
	// 带条件(前置任务完成)地执行任务
	void ConditionalQueueTask(ENamedThreads::Type CurrentThread, bool& bWakeUpWorker);
	// 析构函数
	virtual ~FBaseGraphTask();
private:
	// Subclass API
	// 真正地执行任务，由子类实现
	virtual void ExecuteTask(TArray<FBaseGraphTask*>& NewTasks, ENamedThreads::Type CurrentThread, bool bDeleteOnCompletion)=0;
	// 清理数据
	virtual void DeleteTask() = 0;
	// 执行任务
	FORCEINLINE void Execute(TArray<FBaseGraphTask*>& NewTasks, ENamedThreads::Type CurrentThread, bool bDeleteOnCompletion);

	// Internal Use
	// 将任务加入排队队列
	void QueueTask(ENamedThreads::Type CurrentThreadIfKnown, bool bWakeUpWorker);
	ENamedThreads::Type	ThreadToExecuteOn; // 执行该任务地线程类型
	FThreadSafeCounter NumberOfPrerequistitesOutstanding; // 前置任务的数量，降为0时执行该任务
};

template<typename TTask>
class TGraphTask final : public FBaseGraphTask
{
public:
	// 构造任务的辅助类，任务构造器
	class FConstructor
	{
	public:
		// 构造TTask任务，设置TGraphTask数据，然后执行
		template<typename...T>
		FGraphEventRef ConstructAndDispatchWhenReady(T&&... Args);
		// 构造TTask任务，设置TGraphTask数据，然后Hold住
		template<typename...T>
		TGraphTask* ConstructAndHold(T&&... Args);
	private:
		TGraphTask*	Owner; // 构造器所在的TGraphTask
		const FGraphEventArray*	Prerequisites; // 前置任务
		ENamedThreads::Type	CurrentThreadIfKnown; // 当前线程或者为AnyThread
	};

	// 创建任务，返回的是构造器对象，以便对任务执行后续操作
	static FConstructor CreateTask(const FGraphEventArray* Prerequisites = NULL, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread);
	// 解锁任务(从Hold状态解锁)
	void Unlock(ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread);

private:
	// 实现执行任务
	// 1.执行TTask 
	// 2.销毁TTask 
	// 3.执行后续任务 
	// 4.销毁this指针
	void ExecuteTask(TArray<FBaseGraphTask*>& NewTasks, ENamedThreads::Type CurrentThread, bool bDeleteOnCompletion) override;

	// 设置前置任务，在Setup里调用
	// 1.创建任务完成事件 
	// 2.基于TTask设置要执行的线程
	// 3.尝试在每个前置任务(Prerequisites是前置任务数组)的后续任务里添加自己
	// 4.告诉基类，当前置任务完成后，就可以入队排队执行了
	void SetupPrereqs(const FGraphEventArray* Prerequisites, ENamedThreads::Type CurrentThreadIfKnown, bool bUnlock);

	// 设置任务，在FConstructor里调用，主要调用SetupPrereqs
	FGraphEventRef Setup(const FGraphEventArray* Prerequisites = NULL, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)
	// 设置任务，在FConstructor里调用，和Setup的区别就是还不允许执行任务，Hold住
	TGraphTask* Hold(const FGraphEventArray* Prerequisites = NULL, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)
	// 创建任务，主要用在前置任务完成后，执行后续任务时创建后续任务
	static FConstructor CreateTask(FGraphEventRef SubsequentsToAssume, const FGraphEventArray* Prerequisites = NULL, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)

	TAlignedBytes<sizeof(TTask),alignof(TTask)> TaskStorage; // 自己写的TTask，数据对齐
	bool TaskConstructed; // 任务是否已经被创建了
	FGraphEventRef Subsequents; // 指向后续任务的引用计数指针，列出了以我为前置任务的任务
};

class FGraphEvent 
{
public:
	// 创建GraphEvent的工厂方法
	static CORE_API FGraphEventRef CreateGraphEvent();
	// 尝试为当前任务添加后续任务，如果该后续任务已经完成则返回false，防止任务图出现闭环
	bool AddSubsequent(class FBaseGraphTask* Subsequent)；
	// 延迟当前任务，直到EventToWaitFor任务完成，只有这两个任务有关联时才合法
	void DontCompleteUntil(FGraphEventRef EventToWaitFor)
	// 执行后续任务，在TaskGraph中ExecuteTask第3步调用
	CORE_API void DispatchSubsequents(ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread);
	CORE_API void DispatchSubsequents(TArray<FBaseGraphTask*>& NewTasks, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread);
	// 等待此任务执行完毕
	void Wait(ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread);

private:
	TClosableLockFreePointerListUnorderedSingleConsumer<FBaseGraphTask, 0> SubsequentList; // 后续任务列表，线程安全
	FGraphEventArray EventsToWaitFor; // 前置任务列表，线程不安全
};

class FTaskThreadBase : public FRunnable, FSingleThreadRunnable
{
public:
	// 构造函数
	FTaskThreadBase();
	// 设置一些线程的基础数据，从主线程调用
	void Setup(ENamedThreads::Type InThreadId, uint32 InPerThreadIDTLSSlot, FWorkerThread* InOwnerWorker);

	// ------以下从当前线程调用------
	// 初始化
	void InitializeForCurrentThread();
	// 获取当前线程Id
	ENamedThreads::Type GetThreadId() const;
	// 用于NameThread的开始处理任务，直到退出
	virtual void ProcessTasksUntilQuit(int32 QueueIndex) = 0;
	virtual uint64 ProcessTasksUntilIdle(int32 QueueIndex);
	// 从当前线程添加任务到队列，假设任务要执行的线程和当前线程相同
	virtual void EnqueueFromThisThread(int32 QueueIndex, FBaseGraphTask* Task);

	// ------以下从任何线程调用------
	// 用与返回NamedThread或者关闭AnyThread
	virtual void RequestQuit(int32 QueueIndex) = 0;
	// 从其他线程添加任务到当前线程任务列表
	virtual bool EnqueueFromOtherThread(int32 QueueIndex, FBaseGraphTask* Task);
	// 唤醒线程
	virtual void WakeUp(int32 QueueIndex = 0);
	// 	当前线程是否正在处理任务
	virtual bool IsProcessingTasks(int32 QueueIndex) = 0;

	// ------单线程API(来自FSingleThreadRunnable)------
	// 初始化
	virtual bool Init() override;
	// 执行任务
	virtual uint32 Run() override
	// 提前退出
	virtual void Stop() override
	// 退出并清理数据
	virtual void Exit() override
	// 返回单线程接口
	virtual FSingleThreadRunnable* GetSingleThreadInterface() override

protected:
	ENamedThreads::Type	ThreadId; // 当前线程的Id
	uint32 PerThreadIDTLSSlot; // TLS(Thread Local Stage)插槽
	FThreadSafeCounter IsStalled; // 阻塞计数器，用来触发阻塞信号，大部分时间同步不安全
	TArray<FBaseGraphTask*> NewTasks; // 当前线程的任务列表
	FWorkerThread* OwnerWorker; // 指向所属的WorkerThread
};

class FNamedTaskThread : public FTaskThreadBase
{
public:
	// NamedThread处理任务
	virtual void ProcessTasksUntilQuit(int32 QueueIndex);
	virtual uint64 ProcessTasksUntilIdle(int32 QueueIndex);
	// 真正的处理任务
	uint64 ProcessTasksNamedThread(int32 QueueIndex, bool bAllowStall);
	// 一些FTaskThreadBase的方法实现......
	virtual void EnqueueFromThisThread(int32 QueueIndex, FBaseGraphTask* Task);
	virtual void RequestQuit(int32 QueueIndex);
	virtual bool EnqueueFromOtherThread(int32 QueueIndex, FBaseGraphTask* Task);
	virtual void WakeUp(int32 QueueIndex = 0);
	virtual bool IsProcessingTasks(int32 QueueIndex) = 0;

private:
	// 定义了一个任务队列
	struct FThreadTaskQueue
	{
		FStallingTaskQueue<FBaseGraphTask, PLATFORM_CACHE_LINE_SIZE, 2> StallQueue;	// 阻塞的任务队列
		uint32 RecursionGuard; // 防止循环(递归)调用
		bool QuitForReturn; // 是否执行了一个返回任务
		bool QuitForShutdown; // 是否执行了一个退出任务
		FEvent*	StallRestartEvent; // 当前线程满载时的阻塞事件

		FThreadTaskQueue();
		~FThreadTaskQueue();
	};

	// 返回索引为QueueIndex的任务队列
	FORCEINLINE FThreadTaskQueue& Queue(int32 QueueIndex);
	FORCEINLINE const FThreadTaskQueue& Queue(int32 QueueIndex) const;
	// 两个任务队列
	FThreadTaskQueue Queues[ENamedThreads::NumQueues];
};

class FTaskThreadAnyThread : public FTaskThreadBase
{
public:
	// 构造函数，并指定该线程优先级
	FTaskThreadAnyThread(int32 InPriorityIndex): PriorityIndex(InPriorityIndex) {};
	// AnyThread 处理任务
	virtual void ProcessTasksUntilQuit(int32 QueueIndex);
	virtual uint64 ProcessTasksUntilIdle(int32 QueueIndex);
	// 一些FTaskThreadBase的方法实现......
	virtual void RequestQuit(int32 QueueIndex);
	virtual void WakeUp(int32 QueueIndex = 0);
	virtual bool IsProcessingTasks(int32 QueueIndex) = 0;

private:
	// 真正的处理任务
	uint64 ProcessTasks();

	// 定义了一个任务队列，与NamedThread的有些许不同
	struct FThreadTaskQueue
	{
		FEvent* StallRestartEvent;　// 做完工作得阻塞事件
		uint32 RecursionGuard; // 防止循环(递归)调用
		bool QuitForShutdown; // 是否执行了一个退出任务
		bool bStallForTuning; // 是否需要暂停
		FCriticalSection StallForTuning; // 阻塞临界区

		FThreadTaskQueue()
		~FThreadTaskQueue()
	};

	// 从TaskGraph系统中获取任务
	FBaseGraphTask* FindWork()
	{
		return TaskGraphImplementationSingleton->FindWork(ThreadId);
	}

	FThreadTaskQueue Queue; // 任务队列
	int32 PriorityIndex; // 优先级
};

struct FWorkerThread
{
	FTaskThreadBase*	TaskGraphWorker; // FTaskThread对象，有可能是NamedThread或者AnyThread
	FRunnableThread*	RunnableThread; // 真正执行任务的线程
	bool				bAttached; // 线程是否已经附加到TaskGraph上，主要用在NamedThread

	FWorkerThread(): TaskGraphWorker(nullptr), RunnableThread(nullptr), bAttached(false) { }
};

class FTaskGraphImplementation final : public FTaskGraphInterface
{
public:
	// 单例
	static FTaskGraphImplementation& Get();
	// 构造函数
	FTaskGraphImplementation(int32);
	// 析构函数
	virtual ~FTaskGraphImplementation();

	// -------继承自FTaskGraphInterface------
	// 入队任务
	virtual void QueueTask(FBaseGraphTask* Task, bool bWakeUpWorker, ENamedThreads::Type ThreadToExecuteOn, ENamedThreads::Type InCurrentThreadIfKnown = ENamedThreads::AnyThread) final override;
	// 获取各种线程数量
	virtual int32 GetNumWorkerThreads() final override;
	virtual int32 GetNumForegroundThreads() final override;
	virtual int32 GetNumBackgroundThreads() final override;
	// 获取当前线程信息
	virtual bool IsCurrentThreadKnown() final override;
	virtual ENamedThreads::Type GetCurrentThreadIfKnown(bool bLocalQueue) final override;
	// 该线程是否正在运行任务
	virtual bool IsThreadProcessingTasks(ENamedThreads::Type ThreadToCheck) final override;

	// ------外部线程(主要是NamedThread)API-------
	// 附加线程到TaskGraph系统中
	virtual void AttachToThread(ENamedThreads::Type CurrentThread) final override;
	// 处理任务
	virtual uint64 ProcessThreadUntilIdle(ENamedThreads::Type CurrentThread) final override;
	virtual void ProcessThreadUntilRequestReturn(ENamedThreads::Type CurrentThread) final override;
	// 请求返回
	virtual void RequestReturn(ENamedThreads::Type CurrentThread) final override;
	// 等待任务执行完成
	virtual void WaitUntilTasksComplete(const FGraphEventArray& Tasks, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread) final override;
	virtual void TriggerEventWhenTasksComplete(FEvent* InEvent, const FGraphEventArray& Tasks, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread, ENamedThreads::Type TriggerThread = ENamedThreads::AnyHiPriThreadHiPriTask) final override;
	// 添加一个停止的回调
	virtual void AddShutdownCallback(TFunction<void()>& Callback);
	// 唤醒NamedThread
	virtual void WakeNamedThread(ENamedThreads::Type ThreadToWake) override;

	// ------调度工具------
	// 启动线程
	void StartTaskThread(int32 Priority, int32 IndexToStart);
	void StartAllTaskThreads(bool bDoBackgroundThreads);
	// 返回一个任务给线程，从AnyThread线程调用
	FBaseGraphTask* FindWork(ENamedThreads::Type ThreadInNeed) override;
	// 暂停线程
	void StallForTuning(int32 Index, bool Stall) override
	// 设置FRunnableThread的优先级
	void SetTaskThreadPriorities(EThreadPriority Pri)

private:
	// 返回一个线程
	FTaskThreadBase& Thread(int32 Index);
	// 获取当前线程Type
	ENamedThreads::Type GetCurrentThread()
	// 获取线程的优先级
	int32 ThreadIndexToPriorityIndex(int32 ThreadIndex)

	FWorkerThread WorkerThreads[MAX_THREADS]; // 工作线程，封装了FTaskThread和FRunnableThread
	int32 NumThreads; // 实际使用的线程数量
	int32 NumNamedThreads; // 实际使用的NamedThread数量
	int32 NumTaskThreadSets; // AnyThread线程集合数
	int32 NumTaskThreadsPerSet; // 每个Anythread线程集合里包含的线程数
	bool bCreatedHiPriorityThreads; // 是否有高优先级AnyThread
	bool bCreatedBackgroundPriorityThreads; // 是否有后台AnyThread
	ENamedThreads::Type LastExternalThread;
	FThreadSafeCounter ReentrancyCheck;
	uint32 PerThreadIDTLSSlot; // 每个线程的PLS插槽
	TArray<TFunction<void()>> ShutdownCallbacks; // 停止的回调们
	FStallingTaskQueue<FBaseGraphTask, PLATFORM_CACHE_LINE_SIZE, 2> IncomingAnyThreadTasks[MAX_THREAD_PRIORITIES]; // 任务列表，包含了NamedThread的也包含AnyThread的
};