JavaScript WeakRef va Havolalarni Sanash: Xotirani Boshqarishda Muvofiqlik

Xotirani boshqarish dasturiy ta'minotni ishlab chiqishning muhim jihati bo'lib, ayniqsa JavaScriptda chiqindilarni yig'uvchi (CY) endi ishlatilmayotgan xotirani avtomatik ravishda qaytarib oladi. Avtomatik CY ishlab chiqishni soddalashtirsa-da, u har doim ham yuqori samaradorlik talab qiladigan ilovalar yoki katta ma'lumotlar to'plamlari bilan ishlashda kerak bo'lgan nozik nazoratni ta'minlamaydi. Ushbu maqola JavaScriptda xotirani qo'lda boshqarishga oid ikkita asosiy tushuncha: WeakRef va havolalarni sanashni chuqur o'rganadi va ularni CY bilan birgalikda xotiradan foydalanishni optimallashtirish uchun qanday ishlatish mumkinligini ko'rib chiqadi.

JavaScript Chiqindilarni Yig'ish Tizimini Tushunish

WeakRef va havolalarni sanashga kirishishdan oldin, JavaScriptda chiqindilarni yig'ish qanday ishlashini tushunish juda muhim. JavaScript dvigateli asosan belgilash va tozalash algoritmidan foydalanadigan kuzatuvchi chiqindilarni yig'uvchini ishlatadi. Ushbu algoritm ildiz to'plamidan (global obyekt, chaqiruvlar steki va h.k.) endi erishib bo'lmaydigan obyektlarni aniqlaydi va ularning xotirasini qaytarib oladi.

Belgilash va Tozalash: CY obyektlar grafigini ildiz to'plamidan boshlab aylanib chiqadi. U barcha erishib bo'ladigan obyektlarni belgilaydi. Belgilashdan so'ng, u xotirani ko'zdan kechirib, belgilanmagan obyektlarni bo'shatadi. Bu jarayon vaqti-vaqti bilan takrorlanadi.

Ushbu avtomatik chiqindilarni yig'ish juda qulay bo'lib, dasturchilarni xotirani qo'lda ajratish va bo'shatishdan ozod qiladi. Biroq, bu oldindan aytib bo'lmaydigan bo'lishi va ma'lum bir stsenariylarda har doim ham samarali bo'lmasligi mumkin. Masalan, agar obyekt tasodifan adashgan havola tufayli tirik qolsa, bu xotira sizib chiqishiga olib kelishi mumkin.

WeakRef bilan tanishuv

WeakRef JavaScriptga (ECMAScript 2021) nisbatan yaqinda qo'shilgan bo'lib, u obyektga kuchsiz havola saqlash imkonini beradi. Kuchsiz havola sizga obyektga kirish imkonini beradi, ammo chiqindilarni yig'uvchining uning xotirasini qaytarib olishiga to'sqinlik qilmaydi. Boshqacha aytganda, agar obyektga bo'lgan yagona havolalar kuchsiz bo'lsa, CY ushbu obyektni yig'ib olishda erkin bo'ladi.

WeakRef Qanday Ishlaydi

Obyektga kuchsiz havola yaratish uchun siz WeakRef konstruktoridan foydalanasiz:

            const obj = { data: 'some data' };
const weakRef = new WeakRef(obj);

            

              
                Copy
              
            
          

Asosiy obyektga kirish uchun siz deref() metodidan foydalanasiz:

            const originalObj = weakRef.deref(); // Obyekt yig'ib olinmagan bo'lsa, uni qaytaradi, aks holda undefined qaytaradi.

if (originalObj) {
  console.log(originalObj.data); // Obyektning xususiyatlariga kirish.
} else {
  console.log('Obyekt chiqindilar qatorida yig\'ib olindi.');
}

            

              
                Copy
              
            
          

WeakRef uchun Foydalanish Holatlari

WeakRef obyektlarni chiqindilar qatorida yig'ilishiga to'sqinlik qilmasdan, obyektlar keshini saqlash yoki obyektlar bilan metama'lumotlarni bog'lash kerak bo'lgan holatlarda ayniqsa foydalidir.

• Keshlashtirish: Katta ma'lumotlar to'plamlariga tez-tez kiradigan murakkab ilova yaratayotganingizni tasavvur qiling. Tez-tez ishlatiladigan ma'lumotlarni keshlashtirish samaradorlikni sezilarli darajada oshirishi mumkin. Biroq, keshlangan obyektlar ilovaning boshqa qismlarida kerak bo'lmaganda, kesh CYning xotirani qaytarib olishiga to'sqinlik qilishini xohlamaysiz. WeakRef keshlangan obyektlarni kuchli havolalar yaratmasdan saqlashga imkon beradi, bu esa obyektlarga boshqa joyda kuchli havola qilinmaganda CYning xotirani qaytarib olishini ta'minlaydi. Masalan, veb-brauzer ekranda ko'rinmaydigan rasmlarni keshlashtirish uchun `WeakRef` dan foydalanishi mumkin.
• Metama'lumotlarni bog'lash: Ba'zan, siz obyektni o'zgartirmasdan yoki uning chiqindilar qatorida yig'ilishiga to'sqinlik qilmasdan, u bilan metama'lumotlarni bog'lashni xohlashingiz mumkin. Odatdagi stsenariy - DOM elementlariga hodisa tinglovchilari yoki boshqa konfiguratsiya ma'lumotlarini biriktirishdir. WeakMap (ichki qismida kuchsiz havolalardan foydalanadi) yoki WeakRef bilan maxsus yechimdan foydalanish, element DOMdan olib tashlanganda uning chiqindilar qatorida yig'ilishiga to'sqinlik qilmasdan metama'lumotlarni bog'lashga imkon beradi.
• Obyektni Kuzatishni Amalga Oshirish: WeakRef obyektni kuzatish namunalarini, masalan, kuzatuvchi namunasini, xotira sizib chiqishiga olib kelmasdan amalga oshirish uchun ishlatilishi mumkin. Kuzatuvchilar kuzatilayotgan obyektlarga kuchsiz havolalarni saqlashi mumkin, bu esa kuzatilayotgan obyektlar endi ishlatilmay qolganda kuzatuvchilarning avtomatik ravishda chiqindilar qatorida yig'ilishiga imkon beradi.

Misol: WeakRef bilan keshlashtirish

            class Cache {
  constructor() {
    this.cache = new Map();
  }

  get(key, factory) {
    const weakRef = this.cache.get(key);
    if (weakRef) {
      const value = weakRef.deref();
      if (value) {
        console.log('Kalit uchun kesh topildi:', key);
        return value;
      }
      console.log('Kalit uchun chiqindilarni yig\'ish tufayli kesh topilmadi:', key);
    }

    console.log('Kalit uchun kesh topilmadi:', key);
    const value = factory(key);
    this.cache.set(key, new WeakRef(value));
    return value;
  }
}

// Foydalanish:
const cache = new Cache();

const expensiveOperation = (key) => {
  console.log('Kalit uchun qimmat operatsiya bajarilmoqda:', key);
  // Vaqt talab qiladigan operatsiyani simulyatsiya qilish
  let result = {};
  for (let i = 0; i < 1000; i++) {
       result[i] = Math.random();
  }
  return {data: `Data for ${key}`}; // Katta obyekt yaratishni simulyatsiya qilish
};

const data1 = cache.get('item1', expensiveOperation);
console.log(data1);

const data2 = cache.get('item1', expensiveOperation); // Keshdan olish
console.log(data2);

// Chiqindilarni yig'ishni simulyatsiya qilish (bu JavaScriptda deterministik emas)
// Sinov uchun ba'zi muhitlarda buni qo'lda ishga tushirishingiz kerak bo'lishi mumkin.
// Ko'rgazma maqsadida, biz shunchaki data1 ga bo'lgan kuchli havolani tozalaymiz.
data1 = null;

// Chiqindilarni yig'ishdan so'ng keshdan yana olishga harakat qilish (yig'ib olinishi ehtimoli yuqori).
setTimeout(() => {
  const data3 = cache.get('item1', expensiveOperation); // Qayta hisoblash kerak bo'lishi mumkin
  console.log(data3);
}, 1000);

            

              
                Copy
              
            
          

Ushbu misol WeakRef keshga obyektlarni saqlashga qanday imkon berishini ko'rsatadi, ammo ularga kuchli havola qilinmaganda chiqindilar qatorida yig'ilishiga to'sqinlik qilmaydi. Agar data1 yig'ib olinsa, cache.get('item1', expensiveOperation) ga keyingi chaqiruv kesh topilmasligiga olib keladi va qimmat operatsiya yana bajariladi.

Havolalarni Sanash

Havolalarni sanash - bu har bir obyekt o'ziga ishora qiluvchi havolalar sonini saqlaydigan xotirani boshqarish usuli. Havolalar soni nolga tushganda, obyekt erishib bo'lmaydigan deb hisoblanadi va xotiradan bo'shatilishi mumkin. Bu oddiy, ammo muammoli bo'lishi mumkin bo'lgan usul.

Havolalarni Sanash Qanday Ishlaydi

1. Ishga tushirish: Obyekt yaratilganda, uning havolalar soni 1 ga o'rnatiladi.
2. Oshirish: Obyektga yangi havola yaratilganda (masalan, obyektni yangi o'zgaruvchiga tayinlash), havolalar soni oshiriladi.
3. Kamaytirish: Obyektga havola olib tashlanganda (masalan, havolani ushlab turgan o'zgaruvchiga yangi qiymat tayinlanganda yoki u ko'rinish doirasidan chiqqanda), havolalar soni kamaytiriladi.
4. Xotiradan bo'shatish: Havolalar soni nolga yetganda, obyekt erishib bo'lmaydigan deb hisoblanadi va xotiradan bo'shatilishi mumkin.

JavaScriptda Qo'lda Havolalarni Sanash

JavaScriptning avtomatik chiqindilarni yig'ish tizimi ko'pgina xotirani boshqarish vazifalarini bajarsa-da, siz ma'lum bir vaziyatlarda qo'lda havolalarni sanashni amalga oshirishingiz mumkin. Bu ko'pincha JavaScript dvigateli nazorati ostida bo'lmagan resurslarni, masalan, fayl identifikatorlari yoki tarmoq ulanishlarini boshqarish uchun qilinadi. Biroq, JavaScriptda havolalarni sanashni amalga oshirish siklik havolalar ehtimoli tufayli murakkab va xatolarga moyil bo'lishi mumkin.

Muhim eslatma: JavaScriptning chiqindilarni yig'uvchisi erishuvchanlik tahlilining bir shaklidan foydalansa-da, havolalarni sanashni tushunish JavaScript dvigateli tomonidan to'g'ridan-to'g'ri boshqarilmaydigan resurslarni boshqarish uchun foydali bo'lishi mumkin. Biroq, JavaScript obyektlari uchun *faqat* qo'lda havolalarni sanashga tayanish odatda tavsiya etilmaydi, chunki bu CYga uni avtomatik ravishda boshqarishga ruxsat berishga qaraganda murakkablik va xatolar ehtimolini oshiradi.

Misol: Havolalarni Sanashni Amalga Oshirish

            class RefCounted {
  constructor() {
    this.refCount = 0;
  }

  acquire() {
    this.refCount++;
    return this;
  }

  release() {
    this.refCount--;
    if (this.refCount === 0) {
      this.dispose();
    }
  }

  dispose() {
    // Resurslarni bo'shatish uchun ushbu metodni qayta yozing.
    console.log('Obyekt yo\'q qilindi.');
  }

  getRefCount() {
    return this.refCount;
  }
}

class Resource extends RefCounted {
    constructor(name) {
        super();
        this.name = name;
        console.log(`Resource ${this.name} yaratildi.`);
    }

    dispose() {
        console.log(`Resource ${this.name} yo\'q qilindi.`);
        // Resursni tozalash, masalan, faylni yoki tarmoq ulanishini yopish
    }
}

// Foydalanish:
const resource = new Resource('File1').acquire();
console.log(`Havolalar soni: ${resource.getRefCount()}`);

const anotherReference = resource.acquire();
console.log(`Havolalar soni: ${resource.getRefCount()}`);

resource.release();
console.log(`Havolalar soni: ${resource.getRefCount()}`);

anotherReference.release();

// Barcha havolalar bo'shatilgandan so'ng, obyekt yo'q qilinadi.

            

              
                Copy
              
            
          

Ushbu misolda, RefCounted sinfi havolalarni sanash uchun asosiy mexanizmni ta'minlaydi. acquire() metodi havolalar sonini oshiradi, release() metodi esa kamaytiradi. Havolalar soni nolga yetganda, resurslarni bo'shatish uchun dispose() metodi chaqiriladi. Resource sinfi RefCounted sinfini kengaytiradi va haqiqiy resurslarni tozalashni amalga oshirish uchun dispose() metodini qayta yozadi.

Siklik Havolalar: Asosiy Xavf

Havolalarni sanashning muhim kamchiligi uning siklik havolalarni boshqara olmasligidir. Siklik havola ikki yoki undan ortiq obyektlar bir-biriga havola saqlaganida, sikl hosil qilganda yuzaga keladi. Bunday hollarda, obyektlarning havolalar soni, hatto ular ildiz to'plamidan erishib bo'lmaydigan bo'lsa ham, hech qachon nolga yetmaydi. Bu xotira sizib chiqishiga olib kelishi mumkin.

            // Siklik havolaga misol
const objA = {};
const objB = {};

objA.reference = objB;
objB.reference = objA;

// Agar objA va objB endi ildiz to'plamidan erishib bo'lmaydigan bo'lsa ham,
// ularning havolalar soni 1 da qoladi, bu esa ularning chiqindilar qatorida yig'ilishiga to'sqinlik qiladi

// Siklik havolani uzish uchun:
objA.reference = null;
objB.reference = null;

            

              
                Copy
              
            
          

Ushbu misolda, objA va objB bir-biriga havola saqlab, siklik havola yaratadi. Hatto bu obyektlar ilovada endi ishlatilmasa ham, ularning havolalar soni 1 da qoladi, bu esa ularning chiqindilar qatorida yig'ilishiga to'sqinlik qiladi. Bu sof havolalarni sanashdan foydalanganda siklik havolalar sabab bo'lgan xotira sizib chiqishining klassik misolidir. Shuning uchun JavaScript bu siklik havolalarni aniqlay oladigan va yig'a oladigan kuzatuvchi chiqindilarni yig'uvchidan foydalanadi.

WeakRef va Havolalarni Sanashni Birlashtirish

Ular raqobatdosh g'oyalarga o'xshasa-da, WeakRef va havolalarni sanash ma'lum bir stsenariylarda birgalikda ishlatilishi mumkin. Masalan, siz asosan havolalarni sanash bilan boshqariladigan obyektga havola saqlash uchun WeakRef dan foydalanishingiz mumkin. Bu sizga obyektning hayot siklini uning havolalar soniga aralashmasdan kuzatish imkonini beradi.

Misol: Havolalari Sanaladigan Obyektni Kuzatish

            class RefCounted {
  constructor() {
    this.refCount = 0;
    this.observers = []; // Kuzatuvchilarga WeakRef'lar massivi.
  }

  addObserver(observer) {
    this.observers.push(new WeakRef(observer));
  }

  removeCollectedObservers() {
    this.observers = this.observers.filter(weakRef => weakRef.deref() !== undefined);
  }

  notifyObservers() {
    this.removeCollectedObservers(); // Avval yig'ib olingan kuzatuvchilarni tozalash.
    this.observers.forEach(weakRef => {
      const observer = weakRef.deref();
      if (observer) {
        observer.update(this);
      }
    });
  }

  acquire() {
    this.refCount++;
    this.notifyObservers(); // Olinganda kuzatuvchilarni xabardor qilish.
    return this;
  }

  release() {
    this.refCount--;
    this.notifyObservers(); // Bo'shatilganda kuzatuvchilarni xabardor qilish.
    if (this.refCount === 0) {
      this.dispose();
    }
  }

  dispose() {
    // Resurslarni bo'shatish uchun ushbu metodni qayta yozing.
    console.log('Obyekt yo\'q qilindi.');
  }

  getRefCount() {
    return this.refCount;
  }
}

class Observer {
  update(subject) {
    console.log(`Kuzatuvchi xabardor qilindi: subyektning havolalar soni ${subject.getRefCount()}`);
  }
}

// Foydalanish:
const refCounted = new RefCounted();
const observer1 = new Observer();
const observer2 = new Observer();

refCounted.addObserver(observer1);
refCounted.addObserver(observer2);

refCounted.acquire(); // Kuzatuvchilar xabardor qilinadi.
refCounted.release(); // Kuzatuvchilar yana xabardor qilinadi.

            

              
                Copy
              
            
          

Ushbu misolda, RefCounted sinfi kuzatuvchilarga WeakReflar massivini saqlaydi. Havolalar soni o'zgarganda (acquire() yoki release() tufayli), kuzatuvchilar xabardor qilinadi. WeakReflar kuzatuvchilarning RefCounted obyekti havolalar soni nolga yetganda yo'q qilinishiga to'sqinlik qilmasligini ta'minlaydi.

Qo'lda Xotirani Boshqarishga Alternativalar

Qo'lda xotirani boshqarish usullarini amalga oshirishdan oldin, alternativalarni ko'rib chiqing:

• Mavjud Kodni Optimallashtirish: Ko'pincha, xotira sizib chiqishi va samaradorlik muammolarini mavjud kodni optimallashtirish orqali hal qilish mumkin. Kodingizni keraksiz obyekt yaratish, katta ma'lumotlar tuzilmalari va samarasiz algoritmlar uchun ko'rib chiqing.
• Profilaktika Vositalaridan Foydalanish: JavaScript profilaktika vositalari sizga xotira sizib chiqishi va samaradorlikning zaif nuqtalarini aniqlashga yordam beradi. Ilovangiz xotiradan qanday foydalanayotganini tushunish va yaxshilanish uchun sohalarni aniqlash uchun ushbu vositalardan foydalaning.
• Kutubxonalar va Freymvorklarni Ko'rib Chiqish: Ko'pgina JavaScript kutubxonalari va freymvorklari o'rnatilgan xotirani boshqarish xususiyatlariga ega. Masalan, React DOM manipulyatsiyalarini minimallashtirish va xotira sizib chiqishi xavfini kamaytirish uchun virtual DOMdan foydalanadi.
• WebAssembly: Juda yuqori samaradorlik talab qiladigan vazifalar uchun WebAssembly'dan foydalanishni ko'rib chiqing. WebAssembly sizga C++ yoki Rust kabi tillarda kod yozishga imkon beradi, bu esa xotirani boshqarish ustidan ko'proq nazoratni ta'minlaydi va uni brauzerda bajarish uchun WebAssembly'ga kompilyatsiya qiladi.

JavaScriptda Xotirani Boshqarish uchun Eng Yaxshi Amaliyotlar

JavaScriptda xotirani boshqarish uchun ba'zi eng yaxshi amaliyotlar:

• Global O'zgaruvchilardan Qoching: Global o'zgaruvchilar ilovaning butun hayot sikli davomida saqlanib qoladi va agar ular katta obyektlarga havola saqlasa, xotira sizib chiqishiga olib kelishi mumkin. Global o'zgaruvchilardan foydalanishni minimallashtiring va ma'lumotlarni inkapsulyatsiya qilish uchun yopilmalar yoki modullardan foydalaning.
• Hodisa Tinglovchilarini O'chiring: Element DOMdan olib tashlanganda, u bilan bog'liq bo'lgan barcha hodisa tinglovchilarini o'chirganingizga ishonch hosil qiling. Hodisa tinglovchilari elementning chiqindilar qatorida yig'ilishiga to'sqinlik qilishi mumkin.
• Siklik Havolalarni Uzing: Agar siklik havolalarga duch kelsangiz, havolalardan birini null ga o'rnatib, ularni uzing.
• WeakMap va WeakSet'lardan Foydalaning: WeakMap va WeakSetlar obyektlarni chiqindilar qatorida yig'ilishiga to'sqinlik qilmasdan, ular bilan ma'lumotlarni bog'lash imkonini beradi. Kuchli havolalar yaratmasdan metama'lumotlarni saqlash yoki obyekt munosabatlarini kuzatish kerak bo'lganda ulardan foydalaning.
• Kodingizni Profilaktika Qiling: Xotira sizib chiqishi va samaradorlikning zaif nuqtalarini aniqlash uchun kodingizni muntazam ravishda profilaktika qiling.
• Yopilmalarga E'tiborli Bo'ling: Yopilmalar tasodifan o'zgaruvchilarni ushlab qolishi va ularning chiqindilar qatorida yig'ilishiga to'sqinlik qilishi mumkin. Yopilmalarda ushlab qolgan o'zgaruvchilarga e'tiborli bo'ling va keraksiz ravishda katta obyektlarni ushlab qolishdan saqlaning.
• Obyektlarni Jamlashni Ko'rib Chiqing: Tez-tez obyektlar yaratiladigan va yo'q qilinadigan stsenariylarda, obyektlarni jamlashdan foydalanishni ko'rib chiqing. Obyektlarni jamlash yangilarini yaratish o'rniga mavjud obyektlarni qayta ishlatishni o'z ichiga oladi, bu esa chiqindilarni yig'ish yukini kamaytirishi mumkin.

Xulosa

JavaScriptning avtomatik chiqindilarni yig'ish tizimi xotirani boshqarishni soddalashtiradi, ammo qo'lda aralashuv zarur bo'lgan vaziyatlar mavjud. WeakRef va havolalarni sanash xotiradan foydalanish ustidan nozik nazorat uchun vositalarni taklif qiladi. Biroq, bu usullar ehtiyotkorlik bilan ishlatilishi kerak, chunki ular murakkablik va xatolar ehtimolini keltirib chiqarishi mumkin. Qo'lda xotirani boshqarish usullarini amalga oshirishdan oldin har doim alternativalarni ko'rib chiqing va foydalarni xavflarga solishtiring. JavaScriptning xotirani boshqarish nozikliklarini tushunib va eng yaxshi amaliyotlarga rioya qilib, siz yanada samarali va mustahkam ilovalar yaratishingiz mumkin.