ArkTS內存管理：避免內存泄漏的9大策略

2024-12-04 09:49 更新

ArkTS 是鴻蒙生態(tài)的應用開發(fā)語言，它在 TypeScript 的基礎上進行了優(yōu)化和定制，以適應鴻蒙系統(tǒng)的需求。

以下是在 ArkTS 中進行有效的內存管理和避免內存泄漏：

1. 使用 const 和 let 合理聲明變量：

  • 使用 const 聲明那些不會重新賦值的變量，這有助于確保變量的不變性，并可能讓編譯器進行更多的優(yōu)化。

  • 使用 let 聲明那些需要重新賦值的變量，避免使用 var，因為 var 會導致變量提升到函數作用域的頂部，可能會引起意外的錯誤。

    在 ArkTS 中，const 和 let 是用來聲明變量的關鍵字，它們在作用域和可變性方面有所不同。以下是使用 const 和 let 合理聲明變量的示例代碼對比：

使用 const 聲明不變的變量：

// 正確的使用方式：使用 const 聲明一個不會被重新賦值的變量
const PI = 3.14159; // PI 是一個常量，不應該被重新賦值


// 嘗試重新賦值將會導致編譯錯誤
// PI = 3.14; // Error: Cannot assign to 'PI' because it is a read-only property.

使用 let 聲明可變的變量：

// 正確的使用方式：使用 let 聲明一個可能會被重新賦值的變量
let count = 0; // count 是一個變量，可以被重新賦值


// 可以重新賦值
count = 1;
console.log(count); // 輸出：1

對比示例：

function vgFunction() {
  // 使用 const 聲明一個常量，表示這個變量不應該被修改
  const name = "VG";
  console.log(name); // 輸出：VG


  // 使用 let 聲明一個變量，表示這個變量可能會被修改
  let age = 18;
  console.log(age); // 輸出：18，永遠18


  // 根據某些條件修改變量
  if (age < 30) {
    age = 30;
  }
  console.log(age); // 輸出：30
}


vgFunction();

在這個例子中，name 被聲明為常量，表示它的值不應該改變，而 age 被聲明為變量，表示它的值可能會改變。使用 const 和 let 可以清晰地表達出變量的預期用途，有助于代碼的可讀性和維護性。

避免使用 var 的示例：

// 不推薦使用 var，因為它會提升變量到函數作用域的頂部
function exampleFunction() {
  var globalVar = "I name is VG"; // 這實際上是一個全局變量
  console.log(globalVar); // 輸出：I name is VG
}


exampleFunction();
console.log(globalVar); // 輸出：I name is VG

在這個例子中，使用 var 聲明的 globalVar 實際上是一個全局變量，即使它在函數內部聲明。這可能會導致意外的副作用，因為全局變量可以在程序的任何地方被訪問和修改。因此，推薦使用 const 或 let 來替代 var。

2. 避免全局變量：

  • 盡量減少全局變量的使用，因為全局變量在整個應用生命周期中都存在，難以管理，容易造成內存泄漏。

全局變量是指在全局作用域中聲明的變量，它們可以在整個程序的任何地方被訪問和修改。過度使用全局變量可能會導致代碼難以維護、理解和調試，因為它們可以在任何地方被改變，增加了代碼的耦合性。以下是避免全局變量的示例代碼對比：

使用全局變量的示例：

// 全局變量
var globalCounter = 0;


function increment() {
  globalCounter++; // 直接修改全局變量
}


function decrement() {
  globalCounter--; // 直接修改全局變量
}


increment();
console.log(globalCounter); // 輸出：1
decrement();
console.log(globalCounter); // 輸出：0

在這個例子中，globalCounter 是一個全局變量，可以在 increment 和 decrement 函數中被直接訪問和修改。這可能會導致在程序的其他部分不小心修改了這個變量，從而產生難以追蹤的錯誤。

避免使用全局變量的示例：

// 避免使用全局變量，改為使用局部變量和參數傳遞
function counterManager() {
  let counter = 0; // 局部變量


  function increment() {
    counter++; // 修改局部變量
  }


  function decrement() {
    counter--; // 修改局部變量
  }


  return {
    increment: increment,
    decrement: decrement,
    getCount: function () {
      return counter;
    }
  };
}


const counter = counterManager(); // 創(chuàng)建一個局部變量 counter 來持有管理器對象
counter.increment();
console.log(counter.getCount()); // 輸出：1
counter.decrement();
console.log(counter.getCount()); // 輸出：0

在這個例子中，我們創(chuàng)建了一個 counterManager 函數，它返回一個對象，包含 increment、decrement 和 getCount 方法。這些方法操作的是 counterManager 函數內部的局部變量 counter，而不是全局變量。這樣，counter 的值就被封裝在 counterManager 函數的作用域內，不會影響到全局作用域中的其他變量。

通過這種方式，我們減少了全局變量的使用，提高了代碼的封裝性和模塊化，使得代碼更易于維護和理解。同時，這也有助于避免全局變量可能引起的命名沖突和意外的副作用。

3. 使用弱引用（Weak References）：

  • 對于不需要長期持有的對象，可以使用弱引用，這樣垃圾回收器可以更容易地回收這些對象。

在 ArkTS 或 TypeScript 中，并沒有內置的弱引用（Weak References）概念，這是因為 JavaScript 引擎（包括 V8，即 Node.js 和大多數瀏覽器的 JavaScript 引擎）默認就是使用垃圾回收來管理內存的。弱引用通常是指那些不阻止垃圾回收器回收其所引用對象的引用。

然而，我們可以通過一些設計模式來模擬弱引用的行為，尤其是在處理大型對象或者循環(huán)引用時。如何避免循環(huán)引用導致的內存泄漏，來看這個例子：

可能導致內存泄漏的循環(huán)引用示例：

class Person {
  name: string;
  friends: Person[]; // 朋友列表


  constructor(name: string) {
    this.name = name;
    this.friends = [];
  }


  addFriend(friend: Person) {
    this.friends.push(friend);
    // 這里創(chuàng)建了一個循環(huán)引用，friend.friends.push(this) 會使得 person 和 friend 互相引用
    friend.friends.push(this);
  }
}


const personA = new Person("VG");
const personB = new Person("Vin");
personA.addFriend(personB);
// 此時，personA 和 personB 互相引用，形成了循環(huán)引用

在這個例子中，Person 類的每個實例都維護了一個朋友列表，當一個 Person 實例被添加到另一個 Person 實例的朋友列表時，同時也將后者添加到前者的朋友列表中，形成了循環(huán)引用。

避免循環(huán)引用的示例：

為了避免循環(huán)引用，我們可以不直接在 Person 類中添加彼此的引用，而是通過其他方式來管理這種關系，比如使用一個外部的映射或者服務來管理朋友關系。

class Person {
  name: string;
  friends: string[]; // 朋友列表，只存儲名字而不是直接引用對象


  constructor(name: string) {
    this.name = name;
    this.friends = [];
  }


  addFriend(name: string) {
    this.friends.push(name);
    // 這里不再創(chuàng)建循環(huán)引用，而是將朋友的名字添加到列表中
  }
}


const personA = new Person("VG");
const personB = new Person("Vin");
personA.addFriend(personB.name);
// 此時，personA 的 friends 列表中只有 personB 的名字，不會造成循環(huán)引用

在這個改進的例子中，我們不再直接將 Person 對象添加到朋友列表中，而是只存儲朋友的名字。這樣，即使 Person 對象之間有多個連接，也不會形成循環(huán)引用，從而避免了潛在的內存泄漏問題。

如何通過設計模式來避免循環(huán)引用，這是在 JavaScript 和 TypeScript 中管理內存和避免內存泄漏的一種常用方法。在某些特定的 JavaScript 環(huán)境中，如 Node.js，可以使用弱引用（WeakRef）和弱映射（WeakMap）這樣的內置對象來更直接地實現弱引用。但在大多數前端 JavaScript 環(huán)境中，這些對象并不可用。

4. 及時清理不再使用的對象：

  • 當對象不再需要時，應該手動將其設置為 null 或刪除其引用，這樣垃圾回收器可以回收這部分內存。

在 JavaScript 或 TypeScript 中，及時清理不再使用的對象是避免內存泄漏的重要策略。這通常涉及到移除事件監(jiān)聽器、取消網絡請求、銷毀定時器等操作。以下是一個業(yè)務場景的示例代碼對比，展示如何及時清理不再使用的對象：

未及時清理不再使用的對象示例：

// 假設我們有一個組件，它在加載時訂閱了一個事件
class Component {
  private eventListener: () => void;


  constructor() {
    this.eventListener = () => {
      console.log('Event triggered');
    };
    document.addEventListener('customEvent', this.eventListener);
  }


  // 組件被銷毀時，應該清理事件監(jiān)聽器
  destroy() {
    // 忘記移除事件監(jiān)聽器
    // document.removeEventListener('customEvent', this.eventListener);
  }
}


const myComponent = new Component();
// 當組件不再需要時，應該調用 destroy 方法
// myComponent.destroy();

在這個例子中，Component 類在構造時添加了一個事件監(jiān)聽器，但在 destroy 方法中忘記移除這個監(jiān)聽器。如果 myComponent 被銷毀而沒有調用 destroy 方法，事件監(jiān)聽器仍然存在，這將導致內存泄漏，因為 myComponent 和它的 eventListener 方法仍然被事件監(jiān)聽器引用。

及時清理不再使用的對象示例：

class Component {
  private eventListener: () => void;


  constructor() {
    this.eventListener = () => {
      console.log('Event triggered');
    };
    document.addEventListener('customEvent', this.eventListener);
  }


  // 組件被銷毀時，及時清理事件監(jiān)聽器
  destroy() {
    document.removeEventListener('customEvent', this.eventListener);
  }
}


const myComponent = new Component();
// 當組件不再需要時，調用 destroy 方法
myComponent.destroy();

在這個改進的例子中，Component 類在 destroy 方法中正確地移除了事件監(jiān)聽器。這樣，當組件不再需要時，通過調用 destroy 方法，可以確保不會有任何遺留的引用，從而避免內存泄漏。

使用定時器時及時清理示例：

class TimerComponent {
  private timerId: number;


  constructor() {
    this.timerId = window.setInterval(() => {
      console.log('Timer tick');
      // 定時器執(zhí)行的代碼
    }, 1000);
  }


  // 組件被銷毀時，清除定時器
  destroy() {
    clearInterval(this.timerId);
  }
}


const myTimerComponent = new TimerComponent();
// 當定時器組件不再需要時，調用 destroy 方法
// myTimerComponent.destroy();

在這個例子中，TimerComponent 類使用 setInterval 創(chuàng)建了一個定時器。在 destroy 方法中，使用 clearInterval 清除了定時器，這樣可以避免定時器繼續(xù)執(zhí)行并引用 TimerComponent 實例，從而避免內存泄漏。

我們可以看到及時清理不再使用的對象對于防止內存泄漏是多么重要。在實際開發(fā)中，我們應該養(yǎng)成良好的習慣，確保在對象不再需要時，清理所有相關的資源。

5. 使用事件監(jiān)聽時注意移除監(jiān)聽器：

  • 在添加事件監(jiān)聽器時，確保在不需要監(jiān)聽時移除它們，否則即使對象本身不再被使用，事件監(jiān)聽器也會保持對象的引用，導致內存泄漏。

在 JavaScript 或 TypeScript 中，使用事件監(jiān)聽是常見的交互方式，但如果沒有在適當的時候移除監(jiān)聽器，可能會導致內存泄漏。如何正確地添加和移除事件監(jiān)聽器，上代碼：

未移除事件監(jiān)聽器的示例：

class Widget {
  private element: HTMLElement;


  constructor(selector: string) {
    this.element = document.querySelector(selector)!;
    this.element.addEventListener('click', this.handleClick);
  }


  // 處理點擊事件的方法
  handleClick = () => {
    console.log('Widget clicked');
  }


  // 假設有一個方法來銷毀 Widget 實例，但沒有移除事件監(jiān)聽器
  destroy() {
    // 應該在這里移除事件監(jiān)聽器，但被遺漏了
    // this.element.removeEventListener('click', this.handleClick);
  }
}


const widget = new Widget('#myWidget');
// 當 widget 不再需要時，應該調用 destroy 方法
// widget.destroy();

在這個例子中，Widget 類在構造函數中為元素添加了一個點擊事件監(jiān)聽器。然而，在 destroy 方法中，我們忘記了移除這個監(jiān)聽器。如果 widget 實例被銷毀而沒有調用 destroy 方法，事件監(jiān)聽器仍然存在，這將導致 Widget 實例和它的 handleClick 方法被持續(xù)引用，從而造成內存泄漏。

正確移除事件監(jiān)聽器的示例：

class Widget {
  private element: HTMLElement;


  constructor(selector: string) {
    this.element = document.querySelector(selector)!;
    this.element.addEventListener('click', this.handleClick);
  }


  // 處理點擊事件的方法
  handleClick = () => {
    console.log('Widget clicked');
  }


  // 銷毀 Widget 實例，并移除事件監(jiān)聽器
  destroy() {
    this.element.removeEventListener('click', this.handleClick);
  }
}


const widget = new Widget('#myWidget');
// 當 widget 不再需要時，調用 destroy 方法
widget.destroy();

在這個改進的例子中，Widget 類在 destroy 方法中正確地移除了點擊事件監(jiān)聽器。這樣，當 widget 實例不再需要時，通過調用 destroy 方法，可以確保不會有任何遺留的引用，從而避免內存泄漏。

使用事件委托的示例：

class WidgetManager {
  private container: HTMLElement;


  constructor(selector: string) {
    this.container = document.querySelector(selector)!;
    this.container.addEventListener('click', this.handleClick);
  }


  // 使用事件委托來處理子元素的點擊事件
  handleClick = (event: MouseEvent) => {
    const target = event.target as HTMLElement;
    if (target.classList.contains('widget')) {
      console.log('Widget clicked');
    }
  }


  // 銷毀 WidgetManager 實例，并移除事件監(jiān)聽器
  destroy() {
    this.container.removeEventListener('click', this.handleClick);
  }
}


const widgetManager = new WidgetManager('#widgetsContainer');
// 當 widgetManager 不再需要時，調用 destroy 方法
widgetManager.destroy();

在這個例子中，WidgetManager 類使用事件委托來處理所有子元素的點擊事件。這樣做的好處是，即使子元素是后來動態(tài)添加的，我們也不需要為它們單獨添加事件監(jiān)聽器。當 widgetManager 實例不再需要時，通過調用 destroy 方法，可以移除事件監(jiān)聽器，避免內存泄漏。

我們可以看到在適當的時候移除事件監(jiān)聽器對于防止內存泄漏是多么重要。在實際開發(fā)中，我們應該確保在組件或對象銷毀時，清理所有相關的事件監(jiān)聽器。

6. 合理使用閉包：

  • 閉包可以持續(xù)訪問函數外部的變量，如果不當使用，可能會導致內存泄漏。確保在不需要閉包時釋放相關資源。

    閉包是一個強大的特性，它允許一個函數訪問其定義時的作用域鏈。然而，不當使用閉包可能會導致內存泄漏，因為閉包會保持對外部作用域的引用，從而阻止垃圾回收。

不當使用閉包的示例：

// 假設我們有一個函數，用于創(chuàng)建計數器
function createCounter() {
  let count = 0;
  return function() {
    console.log(++count);
  };
}


const counter = createCounter();
counter(); // 輸出：1
counter(); // 輸出：2


// 假設我們不再需要這個計數器，但是由于閉包，count 變量仍然被引用
// 這可能會導致內存泄漏，如果 createCounter 被頻繁調用

在這個例子中，每次調用 createCounter 都會創(chuàng)建一個新的閉包，它捕獲了 count 變量。如果 createCounter 被頻繁調用，每個閉包都會保持對 count 的引用，即使 counter 函數不再被使用。

合理使用閉包的示例：

// 改進后的計數器函數，使用一個外部對象來存儲計數
const counter = (function() {
  let count = 0;
  return {
    increment: function() {
      console.log(++count);
    },
    value: function() {
      return count;
    }
  };
})();


counter.increment(); // 輸出：1
counter.increment(); // 輸出：2


// 當計數器不再需要時，可以將其設置為 null，幫助垃圾回收器回收內存
counter = null;

在這個改進的例子中，我們使用了一個立即執(zhí)行的函數表達式（IIFE）來創(chuàng)建一個包含 count 變量的對象。這樣，所有的計數器都共享同一個 count 變量，而不是每個閉包都有自己的副本。當計數器不再需要時，我們可以將 counter 設置為 null，這有助于垃圾回收器回收內存。

使用閉包進行數據綁定的示例：

// 一個簡單的數據綁定函數
function bindData(element, data) {
  const template = document.createElement('div');
  template.innerHTML = `<strong>${data.name}</strong>: ${data.value}`;
  element.appendChild(template);


  // 使用閉包來更新數據
  return function update(newData) {
    template.innerHTML = `<strong>${newData.name}</strong>: ${newData.value}`;
  };
}


const dataWidget = bindData(document.body, { name: 'Initial', value: 'Data' });
dataWidget({ name: 'Updated', value: 'Data' });
// 當數據綁定不再需要時，可以將其設置為 null
dataWidget = null;

在這個例子中，bindData 函數創(chuàng)建了一個閉包，用于更新綁定到 DOM 元素的數據。當數據更新時，我們調用返回的 update 函數。當數據綁定不再需要時，我們可以將 dataWidget 設置為 null，這有助于垃圾回收器回收內存。

我們應該確保在不需要閉包時釋放相關資源，以避免不必要的內存占用。

7. 利用垃圾回收機制：

  • 理解 ArkTS 的垃圾回收機制，合理組織代碼結構，以便于垃圾回收器高效工作。

在 ArkTS 中，利用垃圾回收機制同樣重要，因為它可以幫助開發(fā)者管理內存，避免內存泄漏：

不利用垃圾回收機制的示例：

@Entry
@Component
struct MyComponent {
  private resource: any;


  build() {
    // 假設這里加載了一個資源，但沒有提供釋放資源的方法
    this.resource = this.loadResource('resource.json');
  }


  private loadResource(url: string): any {
    // 資源加載邏輯
    return new ResourceData();
  }


  // 組件銷毀時，沒有釋放資源
  onDestroy() {
    // 應該在這里釋放資源，但被遺漏了
  }
}

在這個例子中，MyComponent 組件在 build 方法中加載了一個資源，但沒有提供釋放資源的方法。在組件銷毀時，也沒有釋放資源，這可能會導致內存泄漏。

利用垃圾回收機制的示例：

@Entry
@Component
struct MyComponent {
  private resource: any;


  build() {
    // 假設這里加載了一個資源，并提供了釋放資源的方法
    this.resource = this.loadResource('resource.json');
  }


  private loadResource(url: string): any {
    // 資源加載邏輯
    return new ResourceData();
  }


  private releaseResource() {
    // 釋放資源邏輯
    this.resource = null;
  }


  // 組件銷毀時，釋放資源
  onDestroy() {
    this.releaseResource();
  }
}

在這個改進的例子中，MyComponent 組件在 build 方法中加載了一個資源，并在 releaseResource 方法中提供了釋放資源的邏輯。在組件銷毀時，調用 releaseResource 方法來釋放資源，這樣可以幫助垃圾回收器回收資源占用的內存。

利用垃圾回收機制的另一個示例：

@Entry
@Component
struct MyComponent {
  private timerId: number;


  build() {
    // 設置一個定時器，用于定期執(zhí)行某些操作
    this.timerId = setInterval(() => {
      this.performTask();
    }, 1000);
  }


  private performTask() {
    // 執(zhí)行某些任務
    console.log('Task performed');
  }


  // 組件銷毀時，清除定時器
  onDestroy() {
    clearInterval(this.timerId);
  }
}

在這個例子中，MyComponent 組件在 build 方法中設置了一個定時器。在組件銷毀時，調用 clearInterval 來清除定時器，這樣可以避免定時器繼續(xù)執(zhí)行并引用組件，從而避免內存泄漏。

我們可以看到在 ArkTS 中如何通過編寫良好的代碼習慣來配合垃圾回收機制，確保及時釋放不再需要的資源。

8. 避免不必要的對象創(chuàng)建：

  • 在循環(huán)或頻繁調用的函數中，避免創(chuàng)建不必要的新對象，這會增加垃圾回收的負擔。

在 ArkTS 中，避免不必要的對象創(chuàng)建是優(yōu)化性能和內存使用的一個重要方面。如何在 ArkTS 中避免不必要的對象創(chuàng)建呢，來看一下代碼示例：

不必要的對象創(chuàng)建示例：

@Entry
@Component
struct MyComponent {
  build() {
    for (let i = 0; i < 1000; i++) {
      // 在循環(huán)中創(chuàng)建了1000個不必要的新對象
      const data = this.createDataObject(i);
      console.log(data);
    }
  }


  private createDataObject(index: number): DataObject {
    // 假設 DataObject 是一個復雜的對象
    return new DataObject(index);
  }
}


class DataObject {
  constructor(public index: number) {
    // 構造函數中可能包含一些初始化邏輯
  }
}

在這個例子中，MyComponent 組件的 build 方法在循環(huán)中創(chuàng)建了1000個 DataObject 實例。如果這些對象在循環(huán)之后不再需要，這種創(chuàng)建和立即丟棄的做法會導致不必要的內存分配和潛在的性能問題。

避免不必要的對象創(chuàng)建示例：

@Entry
@Component
struct MyComponent {
  private dataObjects: DataObject[] = [];


  build() {
    for (let i = 0; i < 1000; i++) {
      // 復用已有的對象，而不是在每次迭代中創(chuàng)建新對象
      if (!this.dataObjects[i]) {
        this.dataObjects[i] = this.createDataObject(i);
      } else {
        this.dataObjects[i].update(i); // 假設 DataObject 有一個更新方法
      }
      console.log(this.dataObjects[i]);
    }
  }


  private createDataObject(index: number): DataObject {
    return new DataObject(index);
  }
}


class DataObject {
  constructor(public index: number) {
  }


  update(newIndex: number) {
    this.index = newIndex;
  }
}

在這個改進的例子中，MyComponent 組件維護了一個 DataObject 數組。在循環(huán)中，它首先檢查是否已經存在對象，如果不存在，則創(chuàng)建新對象；如果已存在，則調用 update 方法更新對象的數據。這種方式避免了在每次迭代中創(chuàng)建新對象，從而減少了內存分配和提高了性能。

使用對象池模式避免不必要的對象創(chuàng)建示例：

@Entry
@Component
struct MyComponent {
  private objectPool: DataObject[] = new Array(1000).fill(null).map(() => new DataObject());


  build() {
    for (let i = 0; i < 1000; i++) {
      // 從對象池中獲取對象，而不是每次都創(chuàng)建新對象
      const data = this.objectPool[i];
      data.update(i);
      console.log(data);
    }
  }
}


class DataObject {
  constructor(public index: number) {
  }


  update(newIndex: number) {
    this.index = newIndex;
  }
}

在這個例子中，MyComponent 組件使用了一個對象池來管理 DataObject 實例。對象池在組件初始化時一次性創(chuàng)建了足夠數量的對象，并在循環(huán)中復用這些對象。這種方法可以顯著減少對象創(chuàng)建和銷毀的開銷，特別是在對象生命周期短且頻繁創(chuàng)建銷毀的場景中。

開發(fā)中，我們要考慮對象的生命周期和使用場景，盡可能地復用對象，或者使用對象池模式來管理對象的創(chuàng)建和銷毀。

9. 使用對象池模式：

  • 對于頻繁創(chuàng)建和銷毀的對象，可以考慮使用對象池模式來重用對象，減少內存分配和回收的開銷。

對象池模式是一種常用的優(yōu)化技術，特別是在處理大量短生命周期對象時，它可以幫助減少內存分配和垃圾回收的開銷。我以游戲場景為例，來講一下如何使用對象池模式：

未使用對象池模式的示例：

@Entry
@Component
struct GameComponent {
  private poolSize: number = 10;


  build() {
    for (let i = 0; i < this.poolSize; i++) {
      this.spawnEnemy();
    }
  }


  private spawnEnemy() {
    // 創(chuàng)建一個新的敵人對象
    const enemy = new Enemy();
    // 將敵人添加到游戲世界
    this.addEnemyToGameWorld(enemy);
  }


  private addEnemyToGameWorld(enemy: Enemy) {
    // 添加到游戲世界的邏輯
    console.log('Enemy added to game world:', enemy);
  }
}


class Enemy {
  constructor() {
    // 敵人對象的初始化邏輯
    console.log('Enemy created');
  }
}

在這個例子中，GameComponent 組件在 build 方法中循環(huán)創(chuàng)建了10個 Enemy 對象。每次調用 spawnEnemy 方法都會創(chuàng)建一個新的 Enemy 實例，這在創(chuàng)建大量敵人時可能會導致性能問題。

使用對象池模式的示例：

@Entry
@Component
struct GameComponent {
  private enemyPool: Enemy[] = [];
  private poolSize: number = 10;


  onCreate() {
    // 初始化敵人對象池
    for (let i = 0; i < this.poolSize; i++) {
      this.enemyPool.push(new Enemy());
    }
  }


  build() {
    for (let i = 0; i < this.poolSize; i++) {
      this.spawnEnemy();
    }
  }


  private spawnEnemy() {
    // 從對象池中獲取一個敵人對象
    const enemy = this.enemyPool.shift(); // 移除并獲取數組的第一個元素
    if (enemy) {
      // 將敵人添加到游戲世界
      this.addEnemyToGameWorld(enemy);
    } else {
      // 如果對象池為空，則創(chuàng)建一個新的敵人對象
      const newEnemy = new Enemy();
      this.addEnemyToGameWorld(newEnemy);
      this.enemyPool.push(newEnemy); // 將新創(chuàng)建的敵人對象放回池中
    }
  }


  private addEnemyToGameWorld(enemy: Enemy) {
    // 添加到游戲世界的邏輯
    console.log('Enemy added to game world:', enemy);
  }
}


class Enemy {
  constructor() {
    // 敵人對象的初始化邏輯
    console.log('Enemy created');
  }


  reset() {
    // 重置敵人對象的狀態(tài)，以便再次使用
    console.log('Enemy reset for reuse');
  }
}

在這個改進的例子中，GameComponent 組件使用了一個 enemyPool 數組作為對象池來管理 Enemy 對象。在 onCreate 方法中，我們預先創(chuàng)建了一定數量的 Enemy 對象并放入池中。當需要創(chuàng)建新的敵人時，我們首先嘗試從對象池中獲取一個現有的對象。如果對象池為空，我們才創(chuàng)建一個新的敵人對象，并在添加到游戲世界后將其放回池中。此外，我們添加了一個 reset 方法來重置敵人對象的狀態(tài)，以便它可以被重復使用。

使用對象池模式可以顯著減少在游戲或動畫中創(chuàng)建和銷毀對象的次數，從而提高性能和減少內存壓力。在 ArkTS 中，這種模式尤其適用于那些頻繁創(chuàng)建和銷毀對象的場景，如粒子系統(tǒng)、游戲中的敵人、子彈等。

最后

有效地管理 ArkTS 應用中的內存使用，減少內存泄漏的風險，并提高應用的性能和穩(wěn)定性，這在 ArkTS編碼中同樣至關重要，你在使用 ArkTS的過程中，還有其它有效管理內存的經驗嗎，歡迎評論區(qū)告訴我，國產替代，支持鴻蒙，我們都是一份子。

以上內容是否對您有幫助：
在線筆記
App下載
App下載

掃描二維碼

下載編程獅App

公眾號
微信公眾號

編程獅公眾號