ജാവ പ്രകടനം ഒപ്റ്റിമൈസ് ചെയ്യുന്നു: മാലിന്യ സ്വതന്ത്ര ഒബ്ജക്റ്റ് പൂളുകൾ നടപ്പിലാക്കുന്നു

കാര്യക്ഷമമായ ജാവ ആപ്ലിക്കേഷനുകൾക്കായി മാസ്റ്ററിംഗ് ഒബ്ജക്റ്റ് പൂളിംഗ്

ഉയർന്ന പ്രകടനത്തിൽ ജാവ ആപ്ലിക്കേഷനുകൾ, അമിതമായ മാലിന്യ ശേഖരണം (ജിസി) ഉത്തരവാദിത്തവും തേവിപ്പറയും ഗണ്യമായി തരംതാഴ്ത്താൻ കഴിയും. ജെവിഎം മെമ്മറി മാനേജുമെന്റിൽ വളരെയധികം സമ്മർദ്ദം ചെലുത്തുന്ന ഹ്രസ്വകാല വസ്തുക്കളുടെ പതിവ് സൃഷ്ടിക്കയും പക്കലുമുള്ള ഒരു കോമൺ കുറ്റവാളിയാണ്. പതനം

ഈ പ്രശ്നം കൈകാര്യം ചെയ്യാൻ, ഡവലപ്പർമാർ പലപ്പോഴും ഒബ്ജക്റ്റ് പൂളിംഗ് ആയി തിരിയുന്നു - അവ നിരന്തരം അനുവദിക്കുന്നതിനും ഡീലിസ്റ്റേറ്റിംഗ് ചെയ്യുന്നതിനും പകരം വസ്തുക്കൾ വീണ്ടും നടത്തുന്ന ഒരു സാങ്കേതികത. നന്നായി ഒരു ഘടനാപരമായ ഒബ്ജക്റ്റ് പൂൾ നടപ്പിലാക്കുന്നതിലൂടെ, അപ്ലിക്കേഷനുകൾക്ക് ജിസി പ്രവർത്തനം കുറയ്ക്കും, മെമ്മറി വിഘടനം കുറയ്ക്കുക, ഒപ്പം റൺടൈം കാര്യക്ഷമത മെച്ചപ്പെടുത്തുക.

എന്നിരുന്നാലും, എല്ലാ ഒബ്ജക്റ്റ് പൂളിംഗ് തന്ത്രങ്ങളും തുല്യമല്ല. ആപ്ലിക്കേഷൻ ലോഡ് ഉപയോഗിച്ച് ചലനാത്മകമായി സ്കെയിലുകൾ രൂപീകരിക്കുന്ന ഒരു കുളം രൂപകൽപ്പന ചെയ്യുന്നതിലാണ് വെല്ലുവിളി സ്ഥിതിചെയ്യുന്നത്, അനാവശ്യമായ ഒബ്ജക്റ്റ് കർചിശ്വാസത്തെ തടയുകയും മാലിന്യ ഉത്പാദിപ്പിക്കുകയും ചെയ്യുന്നു. ശരിയായ സമീപനം തിരഞ്ഞെടുക്കുന്നത് ഒപ്റ്റിമൽ പ്രകടനം നിലനിർത്തുന്നതിൽ നിർണ്ണായകമാണ്.

കൂടാതെ, മാറ്റമില്ലാത്ത വസ്തുക്കൾ, ഇതുപോലുള്ളവർ ചരട് സംഭവങ്ങൾ, എളുപ്പത്തിൽ വീണ്ടും ഉപയോഗിക്കാൻ കഴിയാത്തതിനാൽ ഇപ്പോഴത്തെ അദ്വിതീയ വെല്ലുവിളികൾ. ഇതര തന്ത്രങ്ങൾ പോലുള്ള-കാഷിംഗ് അല്ലെങ്കിൽ ഇന്റർനാഷണൽ-മെമ്മറി ഒപ്റ്റിമൈസേഷനായി ഗെയിം മാറ്റുന്നതായി കണ്ടെത്തുന്നു. ഈ ഗൈഡിൽ, മാലിന്യരഹിത ഒബ്ജക്റ്റ് പൂളുകൾ നടപ്പിലാക്കുന്നതിനും നിങ്ങളുടെ ജാവ ആപ്ലിക്കേഷന്റെ കാര്യക്ഷമത വർദ്ധിപ്പിക്കുന്നതിനുമുള്ള ഫലപ്രദമായ സാങ്കേതികതകൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. പതനം

ഒബ്ജക്റ്റ് പൂളുകൾ ഉപയോഗിച്ച് ജാവ മെമ്മറി മാനേജുമെന്റ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു

ജാവ അപേക്ഷകളിൽ, പതിവായി ഒബ്ജക്റ്റ് സൃഷ്ടിക്കും നാശത്തിനും അമിതമായി നയിക്കും മാലിന്യ ശേഖരണം, പ്രതികൂല പ്രകടനത്തെ പ്രതികൂലമായി ബാധിക്കുന്നു. ആവർത്തിച്ച് അനുവദിക്കുന്ന മെമ്മറിക്ക് പകരം വീണ്ടും ഉപയോഗിക്കുന്നതിലൂടെ ഒബ്ജക്റ്റ് പൂളിംഗ് രീതി ഇത് ലഘൂകരിക്കാൻ സഹായിക്കുന്നു. ആദ്യ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് ഒരു അടിസ്ഥാന ഒബ്ജക്റ്റ് പൂളിനെ സൂചിപ്പിക്കുന്നു തടഞ്ഞു, ഒരു ബഹുരാഷ്ട്ര അന്തരീക്ഷത്തിൽ കാര്യക്ഷമമായ ഒബ്ജക്റ്റ് വീണ്ടും ഉപയോഗിക്കുന്നത് ഉറപ്പാക്കുന്നു. ഒബ്ജക്റ്റുകൾ കുളത്തിലേക്ക് പ്രീലോഡുചെയ്യുന്നതിലൂടെ, ഇത് അനാവശ്യ മെമ്മറി ചുണങ്ങു കുറയ്ക്കുകയും മാലിന്യ ശേഖരണത്തെ പതിവായി പരിപാലിക്കുകയും ചെയ്യുന്നു. പതനം

ചലനാത്മകമായി സ്കേലബിൾ ഒരു ഒബ്ജക്റ്റ് പൂൾ അവതരിപ്പിച്ചുകൊണ്ട് രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് ഈ ആശയം വിപുലീകരിക്കുന്നു. ഒരു സ്ഥിര പൂൾ വലുപ്പം നിലനിർത്തുന്നതിനുപകരം, മെമ്മറി കാര്യക്ഷമത ഉറപ്പാക്കുമ്പോൾ ഡിമാൻഡിനെ അടിസ്ഥാനമാക്കിയാണ് ഇത് ക്രമീകരിക്കുന്നത്. ന്റെ ഉപയോഗം ആറ്റോമിസിന്യർ ഒബ്ജക്റ്റ് എണ്ണങ്ങളുടെ കൃത്യമായ ട്രാക്കിംഗിനായി അനുവദിക്കുന്നു, റേസ് അവസ്ഥകൾ തടയുന്നു. അപ്ലിക്കേഷന് കഴിയാത്ത വിഭവങ്ങൾ അവസാനിപ്പിക്കാതെ ഒപ്റ്റിമൽ പ്രകടനം ഉറപ്പാക്കുന്നതിനാൽ ഉയർന്ന ലോഡ് സാഹചര്യങ്ങളിൽ ഈ സമീപനം പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

പ്രധാന കമാൻഡുകൾ വോട്ടെടുപ്പ് () കൂടെ ഓഫർ () ആപ്ലിക്കേഷൻ തടയാതെ ഒബ്ജക്റ്റ് ലഭ്യത കൈകാര്യം ചെയ്യുന്നതിനുള്ള നിർണായകമാണ്. ഒരു വസ്തു കടമെടുക്കുമ്പോൾ, അത് കുളത്തിൽ നിന്ന് നീക്കംചെയ്യുമ്പോൾ, അത് വീണ്ടും അവതരിപ്പിക്കുമ്പോൾ, ഇത് ഭാവിയിലെ ഉപയോഗത്തിനായി ലഭ്യമാക്കുന്നു. പൂൾ ശൂന്യമായി പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, മൊത്തം വലുപ്പം പരിധിയിൽ തുടരുമ്പോൾ ഒരു പുതിയ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കപ്പെടുന്നു. ഈ തന്ത്രം മെമ്മറി വിഘടനം കുറയ്ക്കുകയും പ്രതികരണ സമയം മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു. പതനം

സ്ട്രിംഗുകൾ പോലുള്ള മാറ്റമില്ലാത്ത വസ്തുക്കൾ, അവരുടെ അവസ്ഥയ്ക്ക് പോസ്റ്റ്-സൃഷ്ടിക്കൽ പരിഷ്ക്കരിക്കാനാവില്ല എന്നതിനുശേഷം, പൂളിംഗ് ഫലപ്രദമല്ല. പകരം, ഇതുപോലെയുള്ള സാങ്കേതിക വിദ്യകൾ മേല്വിലുന്നത് അല്ലെങ്കിൽ പ്രത്യേക കാഷുകൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കണം. കാര്യക്ഷമമായ പൂളിംഗ് തന്ത്രങ്ങളും ചലനാത്മക സ്കെയിലിംഗും സ്വാധീനിക്കുന്നതിലൂടെ, ജാവ ആപ്ലിക്കേഷനുകൾ മാലിന്യ ശേഖരം ഓവർഹെഡ് ഗണ്യമായി കുറയ്ക്കാൻ കഴിയും, ഇത് സുഗമവും കൂടുതൽ പ്രതികരിക്കുന്ന പ്രകടനത്തിലേക്ക് നയിക്കുന്നു. ഉയർന്ന കൺസുറൻസിനും വ്യത്യസ്ത ജോലിഭാരങ്ങൾക്കും കീഴിൽ പോലും അപ്ലിക്കേഷൻ കാര്യക്ഷമമായി തുടരുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class ObjectPool<T> {
    private final BlockingQueue<T> pool;
    private final ObjectFactory<T> factory;
    public ObjectPool(int size, ObjectFactory<T> factory) {
        this.pool = new LinkedBlockingQueue<>(size);
        this.factory = factory;
        for (int i = 0; i < size; i++) {
            pool.offer(factory.create());
        }
    }
    public T borrowObject() throws InterruptedException {
        return pool.take();
    }
    public void returnObject(T obj) {
        pool.offer(obj);
    }
    public interface ObjectFactory<T> {
        T create();
    }
}

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.ArrayBlockingQueue;
public class ScalableObjectPool<T> {
    private final ArrayBlockingQueue<T> pool;
    private final ObjectFactory<T> factory;
    private final AtomicInteger size;
    private final int maxSize;
    public ScalableObjectPool(int initialSize, int maxSize, ObjectFactory<T> factory) {
        this.pool = new ArrayBlockingQueue<>(maxSize);
        this.factory = factory;
        this.size = new AtomicInteger(initialSize);
        this.maxSize = maxSize;
        for (int i = 0; i < initialSize; i++) {
            pool.offer(factory.create());
        }
    }
    public T borrowObject() {
        T obj = pool.poll();
        if (obj == null && size.get() < maxSize) {
            obj = factory.create();
            size.incrementAndGet();
        }
        return obj;
    }
    public void returnObject(T obj) {
        if (!pool.offer(obj)) {
            size.decrementAndGet();
        }
    }
    public interface ObjectFactory<T> {
        T create();
    }
}

ജാവയിൽ കാര്യക്ഷമമായ ഒബ്ജക്റ്റ് പൂളിംഗിനായുള്ള വിപുലമായ സാങ്കേതികത

അടിസ്ഥാന ഒബ്ജക്റ്റ് പൂളിംഗിനപ്പുറം, നൂതന സാങ്കേതിക വിദ്യകൾക്ക് മെമ്മറി മാനേജുമെന്റും പ്രകടനവും കൂടുതൽ ഒപ്റ്റിമൈസ് ചെയ്യാൻ കഴിയും. അത്തരം ഒരു സമീപനം നടപ്പിലാക്കുന്നു ത്രെഡ്-ലോക്കൽ ഒബ്ജക്റ്റ് പൂളുകൾ. ഈ പൂൾസ് ഒരു ത്രെഡിന് ഒബ്ജക്റ്റ് ചെയ്യുന്നു, തർക്കവും കാഷെ പ്രസാതി മെച്ചപ്പെടുത്തുന്നതും. ഒന്നിലധികം ത്രെഡുകൾ പതിവായി വസ്തുക്കൾ അഭ്യർത്ഥിക്കുന്ന ഉയർന്ന കൺകറൻസി അപ്ലിക്കേഷനുകളിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. ഓരോ ത്രെഡും സ്വന്തം വസ്തുക്കൾ അധികാരപ്പെടുത്തുന്നുവെന്ന് ഉറപ്പാക്കുന്നതിലൂടെ, ആപ്ലിക്കേഷൻ സമന്വയ ഓവർഹെഡ് കുറയ്ക്കുകയും അനാവശ്യ മാലിന്യ ശേഖരം കുറയ്ക്കുകയും ചെയ്യുന്നു.

മറ്റൊരു നിർണായക പരിഗണന ഉപയോഗിക്കുന്നു അലസമായ സമാരംഭം യഥാർത്ഥത്തിൽ ആവശ്യമുള്ളതുവരെ വസ്തുക്കൾ അനുവദിക്കുന്നത് ഒഴിവാക്കാൻ. സംഭവങ്ങളുള്ള കുളം പ്രെലോഡുചെയ്യുന്നതിനുപകരം, വസ്തുക്കൾ ഡിമാൻഡും ഭാവി പുന ഉത്തേജിപ്പിക്കുന്നതിനായി സംഭരിച്ചിരിക്കുന്നു. അപേക്ഷാ ഉപയോഗം പ്രവചനാതീതമായ സാഹചര്യങ്ങളിൽ അമിതമായി അനുവദിക്കുന്ന സാഹചര്യത്തിൽ ഈ രീതി അവസാനിക്കുന്നു. എന്നിരുന്നാലും, പതിവ് ഒബ്ജക്റ്റ് സൃഷ്ടി കാരണം പ്രകടന തടസ്സങ്ങൾ ഒഴിവാക്കാൻ ആവശ്യമായപ്പോൾ വസ്തുക്കൾ എളുപ്പത്തിൽ ലഭ്യമാകുമെന്ന് ഉറപ്പാക്കാൻ സന്തുലിതമായിരിക്കണം.

വലിയ വസ്തുക്കളോ റിസോഴ്സ്-ഹെവി സംഭവങ്ങളോ കൈകാര്യം ചെയ്യുന്ന അപ്ലിക്കേഷനുകൾക്കായി ദുർബലമായ പരാമർശങ്ങൾ അഥവാ സോഫ്റ്റ് റഫറൻസുകൾ പ്രയോജനകരമാകും. ഒരു കാഷിംഗ് സംവിധാനം നൽകുമ്പോൾ ആവശ്യമെങ്കിൽ ആവശ്യമെങ്കിൽ മെമ്മറി വീണ്ടെടുക്കാൻ ഈ റഫറൻസുകൾ ജെവിഎമ്മിനെ അനുവദിക്കുന്നു. മെമ്മറി സമ്മർദ്ദം ചലനാത്മകമായി വ്യത്യാസപ്പെടുന്ന സാഹചര്യങ്ങളിൽ ഇത് പ്രത്യേകിച്ചും ഫലപ്രദമാണ്. ഈ തന്ത്രങ്ങളുടെ സംയോജനം നടപ്പിലാക്കുന്നതിലൂടെ, ജാവ ആപ്ലിക്കേഷനുകൾക്ക് ഉയർന്ന കാര്യക്ഷമമായ ഒബ്ജക്റ്റ് മാനേജുമെന്റ് നേടാൻ കഴിയും, കുറഞ്ഞ മാലിന്യ ശേഖരം ഓവർഹെഡ് ഉറപ്പുനൽകുന്നത്, റൺടൈം പ്രകടനത്തെ പരമാവധി വർദ്ധിപ്പിക്കുക. പതനം