JavaScripti WeakRef'i puhastus: mäluhalduse ja finaliseerimise meisterlik valdamine globaalsetele arendajatele

            
// Klass, mis esindab objekti, mida tahame hallata
class ExpensiveResource {
  constructor(id) {
    this.id = id;
    console.log(`ExpensiveResource ${this.id} loodud.`);
  }

  // Meetod ressursi puhastamise simuleerimiseks
  cleanup() {
    console.log(`Puhastan ExpensiveResource ${this.id}.`);
  }
}

// Loo objekt
let resource = new ExpensiveResource(1);

// Loo nõrk viide objektile
let weakResource = new WeakRef(resource);

// Muuda algne viide prügikoristuseks kõlblikuks
// eemaldades tugeva viite
resource = null;

// Sel hetkel on 'resource' objekt kättesaadav ainult nõrga viite kaudu.
// Prügikoristaja võib selle peagi vabastada.

// Objekti juurde pääsemiseks (kui seda pole veel kogutud):
setTimeout(() => {
  const dereferencedResource = weakResource.deref();
  if (dereferencedResource) {
    console.log('Ressurss on endiselt elus. ID:', dereferencedResource.id);
    // Siin saate ressurssi kasutada, kuid pidage meeles, et see võib igal hetkel kaduda.
    dereferencedResource.cleanup(); // Meetodi kasutamise näide
  } else {
    console.log('Ressurss on prügikoristatud.');
  }
}, 2000); // Kontrolli 2 sekundi pärast

// Reaalses stsenaariumis käivitaksite tõenäoliselt testimiseks GC käsitsi,
// või jälgiksite käitumist aja jooksul. GC ajastus on mittedeterministlik.

            

              
                Copy
              
            
          

            
// Eeldame, et ExpensiveResource klass on defineeritud nagu varem

// Loo FinalizationRegistry. Saame siin valikuliselt edastada puhastusfunktsiooni,
// mida kutsutakse kõigi registreeritud objektide jaoks, kui spetsiifilist tagasikutset pole määratud.
const registry = new FinalizationRegistry(value => {
  console.log('Registreeritud objekt finaliseeriti. Tõend:', value);
  // Siin on 'value' tõend, mille me registreerimisel edastasime.
  // Kui 'value' on objekt, mis sisaldab ressursipõhiseid andmeid,
  // saate siin sellele puhastamiseks juurde pääseda.
});

// Kasutusnäide:
function createAndRegisterResource(id) {
  const resource = new ExpensiveResource(id);
  
  // Registreeri ressurss tõendiga. Tõend võib olla ükskõik mis,
  // kuid tavaline on kasutada objekti, mis sisaldab ressursi üksikasju.
  // Saame sellele registreerimisele määrata ka spetsiifilise tagasikutse,
  // alistades registri loomisel pakutud vaikeväärtuse.
  registry.register(resource, `Resource_ID_${id}`, {
    cleanupLogic: () => {
      console.log(`Teostan spetsiifilise puhastuse ressursi ID ${id} jaoks`);
      resource.cleanup(); // Kutsu välja objekti puhastusmeetod
    }
  });

  return resource;
}

let resource1 = createAndRegisterResource(101);
let resource2 = createAndRegisterResource(102);

// Nüüd muudame need GC jaoks kõlblikuks
resource1 = null;
resource2 = null;

// Register kutsub automaatselt välja puhastusloogika, kui
// 'resource' objektid on prügikoristaja poolt finaliseeritud.
// Ajastus on endiselt mittedeterministlik.

// Saate registris kasutada ka WeakRef'e:
const resource3 = new ExpensiveResource(103);
const weakRef3 = new WeakRef(resource3);

// Registreeri WeakRef. Kui tegelik ressursiobjekt on prügikoristatud,
// kutsutakse tagasikutse välja.
registry.register(weakRef3, 'WeakRef_Resource_103', {
  cleanupLogic: () => {
    console.log('WeakRef objekt finaliseeriti. Tõend: WeakRef_Resource_103');
    // Me ei saa siin otse resource3 meetodeid kutsuda, kuna see võib olla prügikoristatud
    // Selle asemel võib tõend ise sisaldada teavet või me tugineme asjaolule,
    // et registreerimise sihtmärk oli WeakRef ise, mis tühjendatakse.
    // Levinum muster on algse objekti registreerimine:
    console.log('Finaliseerin WeakRef'iga seotud objekti.');
  }
});

// GC simuleerimiseks testimise eesmärgil võite kasutada:
// if (global && global.gc) { global.gc(); } // Node.js'is
// Brauserites haldab GC-d mootor.

// Jälgimiseks kontrollime mõne viivituse järel:
setTimeout(() => {
  console.log('Kontrollin finaliseerimise staatust viivituse järel...');
  // Te ei näe siin registri töö otsest väljundit,
  // kuid puhastusloogika konsoolilogid ilmuvad, kui GC toimub.
}, 3000);

            

              
                Copy
              
            
          

            
// Näide: Lihtne vahemälu kulukate andmete jaoks, mis on toodud globaalsest API-st
class DataCache {
  constructor() {
    this.cache = new Map();
    // Registreeri vahemälu kirjete puhastusmehhanism
    this.registry = new FinalizationRegistry(key => {
      console.log(`Vahemälu kirje võtmele ${key} on finaliseeritud ja eemaldatakse.`);
      this.cache.delete(key);
    });
  }

  get(key, fetchDataFunction) {
    if (this.cache.has(key)) {
      const entry = this.cache.get(key);
      const weakRef = entry.weakRef;
      const dereferencedData = weakRef.deref();

      if (dereferencedData) {
        console.log(`Vahemälust leitud võtmele: ${key}`);
        return Promise.resolve(dereferencedData);
      } else {
        console.log(`Vahemälu kirje võtmele ${key} oli aegunud (prügikoristatud), toon uuesti.`);
        // Vahemälu kirje ise võib olla prügikoristatud, kuid võti on endiselt map'is.
        // Peame selle ka map'ist eemaldama, kui WeakRef on tühi.
        this.cache.delete(key);
      }
    }

    console.log(`Vahemälust ei leitud võtit: ${key}. Tõmban andmeid...`);
    return fetchDataFunction().then(data => {
      // Salvesta WeakRef ja registreeri võti puhastamiseks
      const weakRef = new WeakRef(data);
      this.cache.set(key, { weakRef });
      this.registry.register(data, key); // Registreeri tegelikud andmed selle võtmega
      return data;
    });
  }
}

// Kasutusnäide:
const myCache = new DataCache();

const fetchGlobalData = async (country) => {
  console.log(`Simuleerin andmete toomist riigile ${country}...`);
  // Simuleeri aeganõudvat võrgupäringut
  await new Promise(resolve => setTimeout(resolve, 500));
  return { country: country, data: `Mõned andmed riigi ${country} kohta` };
};

// Too andmed Saksamaa kohta
myCache.get('DE', () => fetchGlobalData('Germany')).then(data => console.log('Saadud:', data));

// Too andmed Jaapani kohta
myCache.get('JP', () => fetchGlobalData('Japan')).then(data => console.log('Saadud:', data));

// Hiljem, kui 'data' objektidele pole enam tugevaid viiteid,
// puhastab register need 'myCache.cache' Map'ist, kui GC toimub.

            

              
                Copy
              
            
          

            
// Näide: Dünaamilise elemendi sündmuste kuulaja haldamine
function setupButtonListener(buttonId) {
  const button = document.getElementById(buttonId);
  if (!button) return;

  const handleClick = () => {
    console.log(`Nupule ${buttonId} klõpsati!`);
    // Teosta selle nupuga seotud toiming
  };

  button.addEventListener('click', handleClick);

  // Kasuta FinalizationRegistry't kuulaja eemaldamiseks, kui nupp on prügikoristatud
  // (nt kui element eemaldatakse dünaamiliselt DOM-ist)
  const registry = new FinalizationRegistry(targetNode => {
    console.log(`Puhastan kuulajat elemendile:`, targetNode);
    // Eemalda konkreetne sündmuste kuulaja. See eeldab viite hoidmist handleClick'ile.
    // Levinud muster on käsitleja salvestamine WeakMap'i.
    const handler = handlerMap.get(targetNode);
    if (handler) {
      targetNode.removeEventListener('click', handler);
      handlerMap.delete(targetNode);
    }
  });

  // Salvesta sõlmega seotud käsitleja hilisemaks eemaldamiseks
  const handlerMap = new WeakMap();
  handlerMap.set(button, handleClick);

  // Registreeri nupu element registriga. Kui nupp
  // element on prügikoristatud (nt DOM-ist eemaldatud), toimub puhastus.
  registry.register(button, button); 

  console.log(`Kuulaja seadistatud nupule: ${buttonId}`);
}

// Selle testimiseks teeksite tavaliselt järgmist:
// 1. Loo dünaamiliselt nupu element: document.body.innerHTML += 'Click Me';
// 2. Kutsu setupButtonListener('testBtn');
// 3. Eemalda nupp DOM-ist: const btn = document.getElementById('testBtn'); if (btn) btn.remove();
// 4. Lase GC-l käivituda (või käivita see testimiseks, kui võimalik).

            

              
                Copy
              
            
          

            
// Näide: Hüpoteetilise natiivse failikäepideme haldamine Node.js'is

// Reaalses stsenaariumis hõlmaks see C++ lisandmooduleid või Bufferi operatsioone.
// Demonstratsiooniks simuleerime klassi, mis vajab puhastamist.
class NativeFileHandle {
  constructor(filePath) {
    this.filePath = filePath;
    this.handleId = Math.random().toString(36).substring(7);
    console.log(`[NativeFileHandle ${this.handleId}] Avatud fail: ${filePath}`);
    // Reaalsel juhul omandaksite siin natiivse käepideme.
  }

  read() {
    console.log(`[NativeFileHandle ${this.handleId}] Loen failist ${this.filePath}`);
    // Simuleeri andmete lugemist
    return `Andmed failist ${this.filePath}`;
  }

  close() {
    console.log(`[NativeFileHandle ${this.handleId}] Sulgen faili: ${this.filePath}`);
    // Reaalsel juhul vabastaksite siin natiivse käepideme.
    // Veenduge, et see meetod on idempotentne (seda saab ohutult mitu korda kutsuda).
  }
}

// Loo register natiivsete ressursside jaoks
const nativeResourceRegistry = new FinalizationRegistry(handleId => {
  console.log(`[Register] Finaliseerin NativeFileHandle ID-ga: ${handleId}`);
  // Tegeliku ressursi sulgemiseks vajame viisi selle otsimiseks.
  // Levinud on WeakMap, mis seob käepidemed nende sulgemisfunktsioonidega.
  const handle = activeHandles.get(handleId);
  if (handle) {
    handle.close();
    activeHandles.delete(handleId);
  }
});

// WeakMap aktiivsete käepidemete ja nendega seotud puhastuse jälgimiseks
const activeHandles = new WeakMap();

function useNativeFile(filePath) {
  const handle = new NativeFileHandle(filePath);
  
  // Salvesta käepide ja selle puhastusloogika ning registreeri finaliseerimiseks
  activeHandles.set(handle.handleId, handle);
  nativeResourceRegistry.register(handle, handle.handleId);

  console.log(`Kasutan natiivset faili: ${filePath} (ID: ${handle.handleId})`);
  return handle;
}

// Simuleeri failide kasutamist
let file1 = useNativeFile('/path/to/global/data.txt');
let file2 = useNativeFile('/path/to/another/resource.dat');

// Pääse andmetele juurde
console.log(file1.read());
console.log(file2.read());

// Muuda need GC jaoks kõlblikuks
file1 = null;
file2 = null;

// Kui file1 ja file2 objektid on prügikoristatud, siis register
// kutsub välja seotud puhastusloogika (handle.close() activeHandles'i kaudu).
// Võite proovida seda käivitada Node.js'is ja käivitada GC käsitsi --expose-gc abil
// ja seejärel kutsuda global.gc().

// Näide käsitsi GC käivitamisest Node.js'is:
// if (typeof global.gc === 'function') {
//   console.log('Käivitan prügikoristuse...');
//   global.gc();
// } else {
//   console.log('Käsitsi GC käivitamiseks käivitage --expose-gc lipuga.');
// }

            

              
                Copy