UE资源热重载方案

APSchmidt

问题说明：

手游项目中资源热更是非常频繁的，很多项目会在运行过程中支持资源热更。
但是资源热更后，要不就强迫用户重启app，要不就app内重新启动。
方案说明：

接触Unreal后，我也一直在思考app内热重启的方案，这里给大家分享一下我的做法：
首先，热重启最重要问题就是：该如何释放呢？
释放主要方面：
1.释放UnLua
   清理luastate，清理UnLua组件
2.UGameInstance释放，参考PIE的Play&Stop
    主要是调用其Shutdown()接口进行清理，并不会释放UGameInstance对象
3.空场景释放资源，Unmount所有pak
4.最后通过GC进行UObject清理（分帧做两次强制GC，第二次GC是为了阻塞完成回收第一次GC收集的不可达对象）
    为了减少资源的引用，然后通过GC尽可能多释放UObject
方案思路解释：

方案的核心主要是UGameInstance::Shutdown()，而为什么是UGameInstance呢？为什么不是更高级的UEngine或者是更低级的AGameMode呢？
首先，选择UGameInstance是因为参考的PIE的Play&Stop。从Unity转到Unreal的同学应该发现一个问题：
      同样是PIE(Play in Editor)，Unity得益于.Net平台在每次Play都可以新建一个完全独立的虚拟机进行代码托管，而Unreal使用C++每次Play都是同一个执行环境。使用Unity开发基本不需要考虑Stop后的清理释放流程，而Unreal则需要谨慎处理Stop时数据缓存和委托监听等清理释放问题。
万事都有双面性，虽然这这点上Unreal没有Unity那样方便，但也得益于Unreal这个问题，促使我们在开发中要保证Stop时进行充分的清理，否则开发阶段就会出现问题。
由此，也可以得出，参考PIE的Stop&Play过程是不是也可以实现我们App中的Stop&Play了呢。


"怎么来的"(分析PIE的Stop流程,比较啰嗦,可以直接跳到后面怎么来的分割线):
调试PIE的Stop，就发现最终就会执行到UGameInstance::Shutdown()。
那我们就仔细看看PIE的Stop做了什么.
Stop后，实际是调用了RequestEndPlayMap
查看RequestEndPlayMap的代码，发现主要是设置了bRequestEndPlayMapQueued=true
至于这个bRequestEndPlayMapQueued会触发什么逻辑呢？
1.暂停播放音频，只是暂停，不是释放，所以我们不关心
2.调用EndPlayMap
好了，重点看一下EndPlayMap，篇幅有限，省略部分部分代码，下面以中文注释进行解释：

1. void UEditorEngine::EndPlayMap()
2. {
3.         FlushAsyncLoading();  //阻塞完成所有异步加载请求------[必要]
5.         //VR,AR,MR的重置操作,这只是PIE的Stop需要--------------[不需要]
6.         if (GEngine->XRSystem.IsValid() && !bIsSimulatingInEditor)
7.         {
8.                 GEngine->XRSystem->OnEndPlay(*GEngine->GetWorldContextFromWorld(PlayWorld));
9.         }
10.         
11.         //清理Viewport,这只是PIE的Stop需要，热重启并不希望-----[不需要]
12.         // clean up any previous Play From Here sessions
13.         if ( GameViewport != NULL && GameViewport->Viewport != NULL )
14.         {
15.                 // Remove debugger commands handler binding
16.                 GameViewport->OnGameViewportInputKey().Unbind();
18.                 // Remove close handler binding
19.                 GameViewport->OnCloseRequested().Remove(ViewportCloseRequestedDelegateHandle);
21.                 GameViewport->CloseRequested(GameViewport->Viewport);
22.         }
23.         CleanupGameViewport();
25.         //清理所有World，热重启并不希望清理当前World-----[不需要]
26.         // Clean up each world individually
27.         TArray<FName> OnlineIdentifiers;
28.         TArray<UWorld*> WorldsBeingCleanedUp;
29.         bool bSeamlessTravelActive = false;
30.         for (int32 WorldIdx = WorldList.Num()-1; WorldIdx >= 0; --WorldIdx)
31.         {
32.                 FWorldContext &ThisContext = WorldList[WorldIdx];
33.                 if (ThisContext.WorldType == EWorldType::PIE)
34.                 {
35.                         if (ThisContext.World())
36.                         {
37.                                 WorldsBeingCleanedUp.Add(ThisContext.World());
38.                         }
40.                         if (ThisContext.SeamlessTravelHandler.IsInTransition())
41.                         {
42.                                 bSeamlessTravelActive = true;
43.                         }
45.                         if (ThisContext.World())
46.                         {
47.                                 //但是这里有个例外，这里使用WorldContext进行TeardownPlaySession，
48.                                 //WorldContext在UE里主要是代表一个LocalPlayer，
49.                                 //做的事情可能并不止于World内，
50.                                 //所以需要留意，后面会展开解释 --------------------------- [必要]
51.                                 TeardownPlaySession(ThisContext);
53.                                 ShutdownWorldNetDriver(ThisContext.World());
54.                         }
56.                         // Cleanup online subsystems instantiated during PIE
57.                         FName OnlineIdentifier = UOnlineEngineInterface::Get()->GetOnlineIdentifier(ThisContext);
58.                         if (UOnlineEngineInterface::Get()->DoesInstanceExist(OnlineIdentifier))
59.                         {
60.                                 // Stop ticking and clean up, but do not destroy as we may be in a failed online delegate
61.                                 UOnlineEngineInterface::Get()->ShutdownOnlineSubsystem(OnlineIdentifier);
62.                                 OnlineIdentifiers.Add(OnlineIdentifier);
63.                         }
64.                
65.                         // Remove world list after online has shutdown in case any async actions require the world context
66.                         WorldList.RemoveAt(WorldIdx);
67.                 }
68.         }
70.         // SeamlessTravel相关，我们热重启的时候会切换到一个稳定的空场景，
71.         //所以不需要考虑SeamlessTravel ----- [不需要]
72.         // If seamless travel is happening then there is likely additional PIE worlds that need tearing down so seek them out
73.         if (bSeamlessTravelActive)
74.         {
75.                 for (TObjectIterator<UWorld> WorldIt; WorldIt; ++WorldIt)
76.                 {
77.                         if (WorldIt->IsPlayInEditor())
78.                         {
79.                                 WorldsBeingCleanedUp.AddUnique(*WorldIt);
80.                         }
81.                 }
82.         }
83.         
84.         //清理World的时候产生的OnlineIdentifiers，所以不考虑  ---- [不需要]
85.         if (OnlineIdentifiers.Num())
86.         {
87.                 UE_LOG(LogPlayLevel, Display, TEXT("Shutting down PIE online subsystems"));
88.                 // Cleanup online subsystem shortly as we might be in a failed delegate
89.                 // have to do this in batch because timer delegate doesn't recognize bound data
90.                 // as a different delegate
91.                 FTimerDelegate DestroyTimer;
92.                 DestroyTimer.BindUObject(this, &UEditorEngine::CleanupPIEOnlineSessions, OnlineIdentifiers);
93.                 GetTimerManager()->SetTimer(CleanupPIEOnlineSessionsTimerHandle, DestroyTimer, 0.1f, false);
94.         }
95.        
96.         //广播EndPlayMap委托事件，因为我们是模拟Stop，并不想在PIE的时候真的触发了EndPlay ----- [不需要]
97.         FGameDelegates::Get().GetEndPlayMapDelegate().Broadcast();
98.        
99.          //清理outer带PKG_PlayInEditor标签的standalone UObject  --- [不需要]
100.         // find objects like Textures in the playworld levels that won't get garbage collected as they are marked RF_Standalone
101.         for (FObjectIterator It; It; ++It)
102.         {
103.                 UObject* Object = *It;
105.                 if (Object->GetOutermost()->HasAnyPackageFlags(PKG_PlayInEditor))
106.                 {
107.                         if (Object->HasAnyFlags(RF_Standalone))
108.                         {
109.                                 // Clear RF_Standalone flag from objects in the levels used for PIE so they get cleaned up.
110.                                 Object->ClearFlags(RF_Standalone);
111.                         }
112.                         // Close any asset editors that are currently editing this object
113.                         GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->CloseAllEditorsForAsset(Object);
114.                 }
115.         }
117.         //不是释放逻辑,我们不关心    ---- [不需要]
118.         EditorWorld->bAllowAudioPlayback = true;
119.         EditorWorld = nullptr;
121.         //清理World带来的逻辑   --------------- [不需要]
122.         // mark everything contained in the PIE worlds to be deleted
123.         for (UWorld* World : WorldsBeingCleanedUp)
124.         {
125.                 // Occasionally during seamless travel the Levels array won't yet be populated so mark this world first
126.                 // then pick up the sub-levels via the level iterator
127.                 World->MarkObjectsPendingKill();
128.                
129.                 // Because of the seamless travel the world might still be in the root set too, so also clear that
130.                 World->RemoveFromRoot();
132.                 for (auto LevelIt(World->GetLevelIterator()); LevelIt; ++LevelIt)
133.                 {
134.                         if (const ULevel* Level = *LevelIt)
135.                         {
136.                                 // We already picked up the persistent level with the top level mark objects
137.                                 if (Level->GetOuter() != World)
138.                                 {
139.                                         CastChecked<UWorld>(Level->GetOuter())->MarkObjectsPendingKill();
140.                                 }
141.                         }
142.                 }
144.                 for (ULevelStreaming* LevelStreaming : World->GetStreamingLevels())
145.                 {
146.                         // If an unloaded levelstreaming still has a loaded level we need to mark its objects to be deleted as well
147.                         if (LevelStreaming->GetLoadedLevel() && (!LevelStreaming->ShouldBeLoaded() || !LevelStreaming->ShouldBeVisible()))
148.                         {
149.                                 CastChecked<UWorld>(LevelStreaming->GetLoadedLevel()->GetOuter())->MarkObjectsPendingKill();
150.                         }
151.                 }
152.         }
154.         //强制清理GameInstance中的所有UObject，我们只是考虑模拟Shutdown，并不需要强制清理 --- [不需要]
155.         // mark all objects contained within the PIE game instances to be deleted
156.         for (TObjectIterator<UGameInstance> It; It; ++It)
157.         {
158.                 auto MarkObjectPendingKill = [](UObject* Object)
159.                 {
160.                         Object->MarkPendingKill();
161.                 };
162.                 ForEachObjectWithOuter(*It, MarkObjectPendingKill, true, RF_NoFlags, EInternalObjectFlags::PendingKill);
163.         }
165.         // 清理Slate的所有渲染状态，由于是在稳定的空场景里面，展示的UI也是不需要释放的，所以 --- [不需要]
166.         // Flush any render commands and released accessed UTextures and materials to give them a chance to be collected.
167.         if ( FSlateApplication::IsInitialized() )
168.         {
169.                 FSlateApplication::Get().FlushRenderState();
170.         }
172.          //只是做一下检查，检查结果打印一下而已，不涉及到释放  ---- [不需要]
173.         // Make sure that all objects in the temp levels were entirely garbage collected.
174.         for( FObjectIterator ObjectIt; ObjectIt; ++ObjectIt )
175.         {
176.                 UObject* Object = *ObjectIt;
177.                 if( Object->GetOutermost()->HasAnyPackageFlags(PKG_PlayInEditor))
178.                 {
179.                         UWorld* TheWorld = UWorld::FindWorldInPackage(Object->GetOutermost());
180.                         if ( TheWorld )
181.                         {
182.                                 StaticExec(nullptr, *FString::Printf(TEXT("OBJ REFS CLASS=WORLD NAME=%s"), *TheWorld->GetPathName()));
183.                         }
184.                         else
185.                         {
186.                                 UE_LOG(LogPlayLevel, Error, TEXT("No PIE world was found when attempting to gather references after GC."));
187.                         }
189.                         FReferenceChainSearch RefChainSearch(Object, EReferenceChainSearchMode::Shortest);
191.                         FFormatNamedArguments Arguments;
192.                         Arguments.Add(TEXT("Path"), FText::FromString(RefChainSearch.GetRootPath()));
193.                                
194.                         // We cannot safely recover from this.
195.                         FMessageLog(NAME_CategoryPIE).CriticalError()
196.                                 ->AddToken(FUObjectToken::Create(Object, FText::FromString(Object->GetFullName())))
197.                                 ->AddToken(FTextToken::Create(FText::Format(LOCTEXT("PIEObjectStillReferenced", "Object from PIE level still referenced. Shortest path from root: {Path}"), Arguments)));
198.                 }
199.         }
201.         // Final cleanup/reseting
202.         FWorldContext& EditorWorldContext = GEditor->GetEditorWorldContext();
203.         UPackage* Package = EditorWorldContext.World()->GetOutermost();
205.         // 重置Stereo状态，不涉及到释放  --- [不需要]
206.         //ensure stereo rendering is disabled in case we need to re-enable next PIE run (except when the editor is running in VR)
207.         bool bInVRMode = IVREditorModule::Get().IsVREditorModeActive();
208.         if (GEngine->StereoRenderingDevice && !bInVRMode)
209.         {
210.                 GEngine->StereoRenderingDevice->EnableStereo(false);
211.         }
212.       
213.         //热重启不应该涉及到Viewport的清理，所以不需要   ---- [不需要]
214.         // Restores realtime viewports that have been disabled for PIE.
215.         RemoveViewportsRealtimeOverride();
216.       
217.         //重新注册音频组件，不涉及到释放  --- [不需要]
218.         for(TObjectIterator<UAudioComponent> It; It; ++It)
219.         {
220.                 UAudioComponent* AudioComp = *It;
221.                 if (AudioComp->GetWorld() == EditorWorldContext.World())
222.                 {
223.                         AudioComp->ReregisterComponent();
224.                 }
225.         }
227.         //清理所有的Play回话,热重启不需要  --- [不需要]
228.         // no longer queued
229.         CancelRequestPlaySession();
230.         bRequestEndPlayMapQueued = false;
231. }

复制代码

最后总结需要在热重启里面做只剩下两个：
     1.FlushAsyncLoading()
     2.TeardownPlaySession(ThisContext);


其中FlushAsyncLoading()就不多说了，继续研究一下TeardownPlaySession：

1. void UEditorEngine::TeardownPlaySession(FWorldContext& PieWorldContext)
2. {
3.         //销毁World，因为热重启会在一个稳定的空场景里，所以不需要销毁World   ---[不需要]
4.         check(PieWorldContext.WorldType == EWorldType::PIE);
5.         PlayWorld = PieWorldContext.World();
6.         PlayWorld->BeginTearingDown();
8.         if (!PieWorldContext.RunAsDedicated)
9.         {
10.                 // Slate data for this pie world
11.                 FSlatePlayInEditorInfo* const SlatePlayInEditorSession = SlatePlayInEditorMap.Find(PieWorldContext.ContextHandle);
13.                 //销毁ViewPort，热重启不希望销毁Viewport，所以不需要   ----[不需要]
14.                 // Destroy Viewport
15.                 if ( PieWorldContext.GameViewport != NULL && PieWorldContext.GameViewport->Viewport != NULL )
16.                 {
17.                         PieWorldContext.GameViewport->CloseRequested(PieWorldContext.GameViewport->Viewport);
18.                 }
19.                 CleanupGameViewport();
20.        
21.                 //清理PIEviewport   -------------------------------[不需要]
22.                 // Clean up the slate PIE viewport if we have one
23.                 if (SlatePlayInEditorSession)
24.                 {
25.                         if (SlatePlayInEditorSession->DestinationSlateViewport.IsValid())
26.                         {
27.                                 TSharedPtr<IAssetViewport> Viewport = SlatePlayInEditorSession->DestinationSlateViewport.Pin();
29.                                 if(PlayInEditorSessionInfo->OriginalRequestParams.WorldType == EPlaySessionWorldType::PlayInEditor)
30.                                 {
31.                                         // Set the editor viewport location to match that of Play in Viewport if we aren't simulating in the editor, we have a valid player to get the location from (unless we're going back to VR Editor, in which case we won't teleport the user.)
32.                                         if (bLastViewAndLocationValid == true && !GEngine->IsStereoscopic3D( Viewport->GetActiveViewport() ) )
33.                                         {
34.                                                 bLastViewAndLocationValid = false;
35.                                                 Viewport->GetAssetViewportClient().SetViewLocation( LastViewLocation );
37.                                                 if( Viewport->GetAssetViewportClient().IsPerspective() )
38.                                                 {
39.                                                         // Rotation only matters for perspective viewports not orthographic
40.                                                         Viewport->GetAssetViewportClient().SetViewRotation( LastViewRotation );
41.                                                 }
42.                                         }
43.                                 }
45.                                 // No longer simulating in the viewport
46.                                 Viewport->GetAssetViewportClient().SetIsSimulateInEditorViewport( false );
48.                                
49.                                 FEditorModeRegistry::Get().UnregisterMode(FBuiltinEditorModes::EM_Physics);
50.                                
52.                                 // Clear out the hit proxies before GC'ing
53.                                 Viewport->GetAssetViewportClient().Viewport->InvalidateHitProxy();
54.                         }
55.                         else if (SlatePlayInEditorSession->SlatePlayInEditorWindow.IsValid())
56.                         {
57.                                 // Unregister the game viewport from slate.  This sends a final message to the viewport
58.                                 // so it can have a chance to release mouse capture, mouse lock, etc.               
59.                                 FSlateApplication::Get().UnregisterGameViewport();
61.                                 // Viewport client is cleaned up.  Make sure its not being accessed
62.                                 SlatePlayInEditorSession->SlatePlayInEditorWindowViewport->SetViewportClient(NULL);
64.                                 // The window may have already been destroyed in the case that the PIE window close box was pressed
65.                                 if (SlatePlayInEditorSession->SlatePlayInEditorWindow.IsValid())
66.                                 {
67.                                         // Destroy the SWindow
68.                                         FSlateApplication::Get().DestroyWindowImmediately(SlatePlayInEditorSession->SlatePlayInEditorWindow.Pin().ToSharedRef());
69.                                 }
70.                         }
71.                 }
72.        
73.                 //LocalPlayer是玩家实例，代表一个本地玩家 ---- [不需要]
74.                 // Disassociate the players from their PlayerControllers.
75.                 // This is done in the GameEngine path in UEngine::LoadMap.
76.                 // But since PIE is just shutting down, and not loading a
77.                 // new map, we need to do it manually here for now.
78.                 //for (auto It = GEngine->GetLocalPlayerIterator(PlayWorld); It; ++It)
79.                 for (FLocalPlayerIterator It(GEngine, PlayWorld); It; ++It)
80.                 {
81.                         if(It->PlayerController)
82.                         {
83.                                 if(It->PlayerController->GetPawn())
84.                                 {
85.                                         PlayWorld->DestroyActor(It->PlayerController->GetPawn(), true);
86.                                 }
87.                                 PlayWorld->DestroyActor(It->PlayerController, true);
88.                                 It->PlayerController = NULL;
89.                         }
90.                 }
92.         }
94.         // Change GWorld to be the play in editor world during cleanup.
95.         ensureMsgf( EditorWorld == GWorld, TEXT("TearDownPlaySession current world: %s"), GWorld ? *GWorld->GetName() : TEXT("No World"));
96.         GWorld = PlayWorld;
97.         GIsPlayInEditorWorld = true;
98.        
99.         // Remember Simulating flag so that we know if OnSimulateSessionFinished is required after everything has been cleaned up.
100.         bool bWasSimulatingInEditor = PlayInEditorSessionInfo->OriginalRequestParams.WorldType == EPlaySessionWorldType::SimulateInEditor;
101.        
102.         //重置音频   --------------------------------------------------------- [不需要]
103.         // Stop all audio and remove references to temp level.
104.         if (FAudioDevice* AudioDevice = PlayWorld->GetAudioDeviceRaw())
105.         {
106.                 AudioDevice->Flush(PlayWorld);
107.                 AudioDevice->ResetInterpolation();
108.                 AudioDevice->OnEndPIE(false); // TODO: Should this have been bWasSimulatingInEditor?
109.                 AudioDevice->SetTransientMasterVolume(1.0f);
110.         }
112.         //LevelStreaming相关,热重启所在的场景是空场景,不会有LevelStreaming   --- [不需要]
113.         // Clean up all streaming levels
114.         PlayWorld->bIsLevelStreamingFrozen = false;
115.         PlayWorld->SetShouldForceUnloadStreamingLevels(true);
116.         PlayWorld->FlushLevelStreaming();
118.         //LevelStreaming相关,热重启所在的场景是空场景,不会有LevelStreaming   --- [不需要]
119.         // cleanup refs to any duplicated streaming levels
120.         for ( int32 LevelIndex=0; LevelIndex<PlayWorld->GetStreamingLevels().Num(); LevelIndex++ )
121.         {
122.                 ULevelStreaming* StreamingLevel = PlayWorld->GetStreamingLevels()[LevelIndex];
123.                 if( StreamingLevel != NULL )
124.                 {
125.                         const ULevel* PlayWorldLevel = StreamingLevel->GetLoadedLevel();
126.                         if ( PlayWorldLevel != NULL )
127.                         {
128.                                 UWorld* World = Cast<UWorld>( PlayWorldLevel->GetOuter() );
129.                                 if( World != NULL )
130.                                 {
131.                                         // Attempt to move blueprint debugging references back to the editor world
132.                                         if( EditorWorld != NULL && EditorWorld->GetStreamingLevels().IsValidIndex(LevelIndex) )
133.                                         {
134.                                                 const ULevel* EditorWorldLevel = EditorWorld->GetStreamingLevels()[LevelIndex]->GetLoadedLevel();
135.                                                 if ( EditorWorldLevel != NULL )
136.                                                 {
137.                                                         UWorld* SublevelEditorWorld  = Cast<UWorld>(EditorWorldLevel->GetOuter());
138.                                                         if( SublevelEditorWorld != NULL )
139.                                                         {
140.                                                                 World->TransferBlueprintDebugReferences(SublevelEditorWorld);
141.                                                         }       
142.                                                 }
143.                                         }
144.                                 }
145.                         }
146.                 }
147.         }
149.         //Editor相关   -------------------------------- [不需要]
150.         // Construct a list of editors that are active for objects being debugged. We will refresh these when we have cleaned up to ensure no invalid objects exist in them
151.         TArray< IBlueprintEditor* > Editors;
152.         UAssetEditorSubsystem* AssetEditorSubsystem = GEditor->GetEditorSubsystem<UAssetEditorSubsystem>();
153.         const UWorld::FBlueprintToDebuggedObjectMap& EditDebugObjectsPre = PlayWorld->GetBlueprintObjectsBeingDebugged();
154.         for (UWorld::FBlueprintToDebuggedObjectMap::TConstIterator EditIt(EditDebugObjectsPre); EditIt; ++EditIt)
155.         {
156.                 if (UBlueprint* TargetBP = EditIt.Key().Get())
157.                 {
158.                         if(IBlueprintEditor* EachEditor = static_cast<IBlueprintEditor*>(AssetEditorSubsystem->FindEditorForAsset(TargetBP, false)))
159.                         {
160.                                 Editors.AddUnique( EachEditor );
161.                         }
162.                 }
163.         }
165.         //通知Actor即将销毁,热重启场景是一个稳定的空场景,不存在需要销毁的Actor  ----- [不需要]
166.         // Go through and let all the PlayWorld Actor's know they are being destroyed
167.         for (FActorIterator ActorIt(PlayWorld); ActorIt; ++ActorIt)
168.         {
169.                 ActorIt->RouteEndPlay(EEndPlayReason::EndPlayInEditor);
170.         }
171.    
172.         //GameInstance::Shutdown     ---------------- [需要]
173.         PieWorldContext.OwningGameInstance->Shutdown();
175.         //Editor相关     --------- [不需要]
176.         // Move blueprint debugging pointers back to the objects in the editor world
177.         PlayWorld->TransferBlueprintDebugReferences(EditorWorld);
179.         //物理系统的虚拟场景清理,由于我们不会清理当前场景   ----  [不需要]
180.         FPhysScene* PhysScene = PlayWorld->GetPhysicsScene();
181.         if (PhysScene)
182.         {
183.                 PhysScene->WaitPhysScenes();
184.                 PhysScene->KillVisualDebugger();
185.         }
187.         //清理场景,热重启的空场景不需要清理    ------  [不需要]
188.         // Clean up the temporary play level.
189.         PlayWorld->CleanupWorld();
190.         // Remove from root (Seamless travel may have done this)
191.         PlayWorld->RemoveFromRoot();
192.         PlayWorld = NULL;
193.    
194.          //Editor相关 ---------------------------------------------------------------[不需要]
195.         // Refresh any editors we had open in case they referenced objects that no longer exist.
196.         for (int32 iEditors = 0; iEditors <  Editors.Num(); iEditors++)
197.         {
198.                 Editors[ iEditors ]->RefreshEditors();
199.         }
200.        
201.         // Restore GWorld.
202.         GWorld = EditorWorld;
203.         GIsPlayInEditorWorld = false;
205.         FWorldContext& EditorWorldContext = GEditor->GetEditorWorldContext();
207.         //依然是清理Viewport,不需要清理Viewport      -------- [不需要]
208.         // Let the viewport know about leaving PIE/Simulate session. Do it after everything's been cleaned up
209.         // as the viewport will play exit sound here and this has to be done after GetAudioDevice()->Flush
210.         // otherwise all sounds will be immediately stopped.
211.         if (!PieWorldContext.RunAsDedicated)
212.         {
213.                 // Slate data for this pie world
214.                 FSlatePlayInEditorInfo* const SlatePlayInEditorSession = SlatePlayInEditorMap.Find(PieWorldContext.ContextHandle);
215.                 if (SlatePlayInEditorSession && SlatePlayInEditorSession->DestinationSlateViewport.IsValid())
216.                 {
217.                         TSharedPtr<IAssetViewport> Viewport = SlatePlayInEditorSession->DestinationSlateViewport.Pin();
219.                         if( Viewport->HasPlayInEditorViewport() )
220.                         {
221.                                 Viewport->EndPlayInEditorSession();
222.                         }
224.                         // Let the Slate viewport know that we're leaving Simulate mode
225.                         if( bWasSimulatingInEditor )
226.                         {
227.                                 Viewport->OnSimulateSessionFinished();
228.                         }
230.                         StaticCast<FLevelEditorViewportClient&>(Viewport->GetAssetViewportClient()).SetReferenceToWorldContext(EditorWorldContext);
231.                 }
233.                 // Remove the slate info from the map (note that the UWorld* is long gone at this point, but the WorldContext still exists. It will be removed outside of this function)
234.                 SlatePlayInEditorMap.Remove(PieWorldContext.ContextHandle);
235.         }
236. }

复制代码

看来TeardownPlaySession中只有OwningGameInstance->Shutdown();是我们关心的。


最终总结一下,模拟PIE的Stop流程中需要注意的只有两个调用:
1.FlushAsyncLoading().
2.OwningGameInstance->Shutdown();
而FlushAsyncLoading()是阻塞加载所有异步请求没什么好说的,我们就主要看看UGameInstance::Shutdown()
-------------------------------"怎么来的" 结束分割线----------------------------------------
"怎么做呢":
让我们来看看UGameInstance::Shutdown()：
注意看中文注释(忽略误选中的选中框)
再对比一下UGameInstance::Init()
注意看中文注释(忽略误选中的选中框)
对比:

Shutdown:	Init:
1.通知蓝图Shutdown	1.通知蓝图Init
2.清理网络回话对象	2.创建网络回话对象
3.清理所有LocalPlayer	3.XXXXXXXXXXXXX
4.清理所有GameInstanceSubsystem	4.初始化所有GameInstanceSubsystem
5.清理网路错误委托监听	5.绑定网络错误委托监听
6.清理WorldContext	6.XXXXXXXXXXXX

可见，Shutdown相对Init多了：清理所有LocalPlayer，清理WorldContext。什么概念呢? 就是Shutdown做了些事情，而且是在再次Init后都没办法恢复。
1.清理LocalPlayer: LocalPlayer代表一个用户端,一般手游都是只有一个LocalPlayer,主机游戏可能会通过分屏方式出现两个或者四个LocalPlayer。清理LocalPlayer后如果不进行恢复,用户端的输入将无效,包括Console Command.
2.清理WorldContext: WorldContext即是World上下文,与UWorld有关系,并且会影响到一些需要区别多个LocalPlayer的接口.
这个时候,有人可能会问"既然是模拟Shutdown，是不是可以直接把Shutdown逻辑拷贝一下就行?"，当然这也是一个办法。但是每个项目都会继承UGameInstance，那每层继承都要拷贝，修改的时候还要注意修改两处，维护起来是很麻烦。所以使用UGameInstance的Shutdown和Init会更方便维护。
下面是模拟逻辑ShutdownOnlyForReload和InitOnlyForReload，最终都会调用到Shutdown和Init.

1. void UMGameInstance::ShutdownOnlyForReload()
2. {
3.         UE_LOG(LogTemp,Log,TEXT("UMGameInstance::ShutdownOnlyForReload....Start"));
5.         FWorldContext* WorldContextOld = WorldContext;  //记录一下WorldContext,Shutdown中置空后再复制回去即可.
7.         Shutdown();                              //调用UMGameInstance::Shutdown,在里面还会进行UnLua释放
8.        
9.         GameInstance = this;
10.         WorldContext = WorldContextOld;          //还原WorldContext
12.         FString OutError;
13.         CreateInitialPlayer(OutError);                  //恢复LocalPlayer
15.         UE_LOG(LogTemp,Log,TEXT("UMGameInstance::ShutdownOnlyForReload....End"));
16. }
18. void UMGameInstance::InitOnlyForReload()
19. {
20.         UE_LOG(LogTemp,Log,TEXT("UMGameInstance::InitOnlyForReload....Start"));
21.        
22.         Init();                                  //调用UMGameInstance::Init
23.        
24.         FBasicMainEntry::InitLua(GetWorld());      //初始化Lua.
25.        
26.         UE_LOG(LogTemp,Log,TEXT("UMGameInstance::InitOnlyForReload....End"));
27. }

复制代码

"怎么验证"
1.Lua: Shutdown过程会把Lua_State释放，所以Lua里的数据Cache和UObject引用都会释放掉了.
2.非UObject实例/静态实例: 这里并没有验证方法，但是文章开头就说了，模拟PIE的Stop&Play流程，开发阶段就要保证重复Stop&Play能正常运作的，这是很正常的项目规范要求。加上非UObject实例/静态对象都不会影响UObject的GC。而回归到需求，只是进行资源重新加载，所以不需要保证这些对象都被清理干净，只需要保证重复Stop&Play正常工作即可。
3.UObject实例: 在Shutdown和UnMount所有资源后,中止重启流程,遍历打印所有的UObject，并人肉检查UObject的释放情况。遍历打印代码如下:

1. //bNeedClass 是否显示Class并参与排序
2. //bNoReflectionObj 是否不收集UFunction/UClass/UStruct这些UObject
3. //bOnlyContent 是否只打印工程资源.
4. void DumpAllObj(bool bNeedClass,bool bNoReflectionObj,bool bOnlyContent)
5. {
6.         TArray<FString> strObjs;
7.         for (TObjectIterator<UObject> It; It; ++It)
8.         {
9.                 UObject* Obj = *It;
10.                
11.                 if (!bNoReflectionObj || (Cast<UField>(Obj) == nullptr
12. #if ENGINE_MINOR_VERSION < 25
13.                         && Cast<UProperty>(Obj) == nullptr
14. #endif
15.                         && Cast<UFunction>(Obj) == nullptr
16.                         && Cast<UClass>(Obj) == nullptr
17.                         && Cast<UStruct>(Obj) == nullptr))
18.                 {
19.                         if (!bOnlyContent || (Obj->GetPathName().StartsWith("/Game/")))
20.                         {
21.                                 if (bNeedClass)
22.                                         strObjs.Add(Obj->GetFullName());
23.                                 else
24.                                         strObjs.Add(Obj->GetPathName());
25.                         }
26.                 }
27.         }
29.         strObjs.Sort();
31.         FString DumpLogFile = FString::Format(TEXT("{0}/DumpAllObj_{1}_{2}_{3}.txt"), { FPaths::ConvertRelativePathToFull(FPaths::ProjectPersistentDownloadDir()),bNeedClass,bNoReflectionObj,bOnlyContent });
32.         FFileHelper::SaveStringArrayToFile(strObjs, *DumpLogFile, FFileHelper::EEncodingOptions::ForceUTF8);
33. }

复制代码

"怎么解决":
验证后，发现问题该怎么解决呢?
非UObject问题: 主要是通过项目规范进行约束。
UObject问题: 可能会打印出来上万个没有正常释放的UObject，如果逐一人肉排查引用关系，是很恐怖的事。这里有个小经验，可以先从引用集合UObject开始排查，像DataTable和DataAsset，因为UObject会带来很多引用，释放掉DataTable，UObject数量能大幅度减少。
查找引用代码：

1. void PrintAllReferencers(FString ObjName)
2. {
3.         TMap<UObject*,FObjReferencers> AllReferencers = GetAllReferencers(ObjName);
5.         UE_LOG(LogTemp,Log,TEXT("---------Start Print All References of %s"),*ObjName);
6.        
7.         for(TMap<UObject*,FObjReferencers>::TIterator Iter = AllReferencers.CreateIterator();Iter;++Iter)
8.         {
9.                 UObject* ReferenceeObj = Iter->Key;
10.                 UE_LOG(LogTemp,Log,TEXT("Referencers Of %s (%s):"),*(ReferenceeObj->GetFName().ToString()),*(ReferenceeObj->GetClass()->GetFName().ToString()));
12.                 FObjReferencers ReferencersInfo = Iter->Value;
13.                 for(TArray<UObject*>::TIterator Iter2 = ReferencersInfo.Referencers.CreateIterator();Iter2;++Iter2)
14.                 {
15.                         UObject* ReferencerObj =  *Iter2;
16.                         UE_LOG(LogTemp,Log,TEXT("%30s (%s)"),*(ReferencerObj->GetFName().ToString()),*(ReferencerObj->GetClass()->GetFName().ToString()));
17.                 }
19.                 UE_LOG(LogTemp,Log,TEXT("--------------------------"));
20.         }
22.         UE_LOG(LogTemp,Log,TEXT("---------End Print All References of %s"),*ObjName);
23. }

复制代码

--------------------------------------------------------------------------------------------
这个方案已经在项目里使用，为了增加测试的机会，我把游戏账号登出也改成了重启XD。