Object resurrection
કચરો સંગ્રહ સાથે ઓબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ ભાષાઓમાં, ઓબ્જેક્ટ પુનરુત્થાન એ છે કે જ્યારે ઓબ્જેક્ટ વિનાશની પ્રક્રિયા દરમિયાન કોઈ ઓબ્જેક્ટ જીવંત થાય છે, જે ફાઇનલાઇઝર ચલાવવાની આડઅસર તરીકે થાય છે. ઓબ્જેક્ટ પુનરુત્થાન સંખ્યાબંધ સમસ્યાઓનું કારણ બને છે, ખાસ કરીને કે ઓબ્જેક્ટ પુનરુત્થાનની સંભાવના-ભલે તે ન થાય-કચરો સંગ્રહને નોંધપાત્ર રીતે વધુ જટિલ અને ધીમું બનાવે છે, અને તે એક મુખ્ય કારણ છે કે અંતિમ સ્વરૂપ આપનારાઓને નિરાશ કરવામાં આવે છે. ભાષાઓ વસ્તુ પુનરુત્થાન સાથે વિવિધ રીતે વ્યવહાર કરે છે. દુર્લભ સંજોગોમાં, ઑબ્જેક્ટ પુનરુત્થાનનો ઉપયોગ ચોક્કસ ડિઝાઇન પેટર્નને અમલમાં મૂકવા માટે થાય છે, ખાસ કરીને ઑબ્જેક્ટ પૂલ, જ્યારે અન્ય સંજોગોમાં પુનરુત્થાન એ અંતિમ સ્વરૂપમાં ભૂલને કારણે અનિચ્છનીય ભૂલ છે, અને સામાન્ય રીતે પુનરુત્થાનને નિરુત્સાહિત કરવામાં આવે છે. પ્રક્રિયા ઓબ્જેક્ટ પુનરુત્થાન નીચેની પ્રક્રિયા દ્વારા થાય છે. પ્રથમ, કોઈ વસ્તુ કચરો બની જાય છે જ્યારે તે પ્રોગ્રામમાંથી હવે પહોંચી શકાતી નથી, અને તેને એકત્રિત કરી શકાય છે (નાશ અને વિસર્જન). પછી, પદાર્થના વિનાશ દરમિયાન, કચરો સંગ્રહકર્તા પદાર્થની ફાળવણી રદ કરે તે પહેલાં, એક અંતિમ પદ્ધતિ ચલાવી શકાય છે, જે બદલામાં તે પદાર્થ અથવા અન્ય કચરો પદાર્થ (અંતિમ વસ્તુ સાથે પદાર્થમાંથી પહોંચી શકાય તેવું) તેના સંદર્ભો બનાવીને ફરીથી પહોંચી શકાય તેવું બનાવી શકે છે, કારણ કે અંતિમ સ્વરૂપમાં મનસ્વી કોડ હોઈ શકે છે. જો આવું થાય, તો સંદર્ભિત ઓબ્જેક્ટ-જે જરૂરી નથી કે અંતિમ ઓબ્જેક્ટ હોય-તે હવે કચરો નથી, અને તેને અલગ કરી શકાતો નથી, કારણ કે અન્યથા તેના સંદર્ભો લટકતા સંદર્ભો બની જશે અને જ્યારે તેનો ઉપયોગ કરવામાં આવશે ત્યારે ભૂલો થશે, સામાન્ય રીતે પ્રોગ્રામ ક્રેશ અથવા અણધારી વર્તણૂક. તેના બદલે, સ્મૃતિ સલામતી જાળવવા માટે, પદાર્થને જીવંત કરવામાં આવે છે અથવા પુનર્જીવિત કરવામાં આવે છે. આને શોધવા માટે, કચરો સંગ્રહ કરનાર સામાન્ય રીતે અંતિમકર્તાની હાજરીમાં બે તબક્કાનો સંગ્રહ કરશેઃ પ્રથમ કોઈ પણ કચરાને અંતિમ સ્વરૂપ આપે છે તેને અંતિમ સ્વરૂપ આપો, અને પછી તમામ કચરો (અથવા અંતિમકર્તાની વસ્તુઓમાંથી પહોંચી શકાય તેવો તમામ કચરો) ફરીથી તપાસો. આ ઓવરહેડ ઉમેરે છે અને મેમરી રિક્લેમેશનમાં વિલંબ કરે છે. પુનર્જીવિત પદાર્થો પુનર્જીવિત પદાર્થને અન્ય પદાર્થોની જેમ જ ગણવામાં આવી શકે છે, અથવા ખાસ રીતે ગણવામાં આવી શકે છે. ઘણી ભાષાઓમાં, ખાસ કરીને સી #, જાવા અને પાયથોન (પાયથોન 3.4 માંથી), ઓબ્જેક્ટને માત્ર એક જ વાર અંતિમ સ્વરૂપ આપવામાં આવે છે, જેથી ઓબ્જેક્ટને વારંવાર પુનર્જીવિત કરવામાં આવે અથવા તો અવિનાશી બનવાની શક્યતા ટાળી શકાય; સી #માં ડિફોલ્ટ રૂપે અંતિમ સ્વરૂપો સાથે ઓબ્જેક્ટને માત્ર એક જ વાર અંતિમ સ્વરૂપ આપવામાં આવે છે, પરંતુ અંતિમ સ્વરૂપ માટે ફરીથી નોંધણી કરાવી શકાય છે. અન્ય કિસ્સાઓમાં પુનર્જીવિત વસ્તુઓને ભૂલો ગણવામાં આવે છે, ખાસ કરીને ઓબ્જેક્ટિવ-સીમાં; અથવા અન્ય વસ્તુઓ સાથે સમાન રીતે વ્યવહાર કરવામાં આવે છે, ખાસ કરીને પાયથોનમાં પાયથોન 3.4 પહેલાં. પુનર્જીવિત પદાર્થને કેટલીકવાર એ અથવા ઝોમ્બી કહેવામાં આવે છે, પરંતુ આ શબ્દનો ઉપયોગ પદાર્થના વિનાશ સાથે સંબંધિત વિવિધ પદાર્થ સ્થિતિઓ માટે થાય છે, જેનો ઉપયોગ ભાષા અને લેખક પર આધાર રાખે છે. "ઝોમ્બી ઓબ્જેક્ટ" નો ઉદ્દેશ-સીમાં વિશિષ્ટ અર્થ છે, જો કે, જે નીચે વિગતવાર છે. ઝોમ્બી ઓબ્જેક્ટ્સ ઝોમ્બી પ્રક્રિયાઓ સાથે કંઈક અંશે સમાન છે, જેમાં તેઓ સમાપ્તિ સ્થિતિમાં ફેરફારમાંથી પસાર થયા છે અને ડીલોકેશનની નજીક છે, પરંતુ વિગતો નોંધપાત્ર રીતે અલગ છે. . NET માળખામાં ફેરફારો, ખાસ કરીને C #અને VB.NET, "ઑબ્જેક્ટ પુનરુત્થાન" તેના બદલે અંતિમ સ્વરૂપ દરમિયાન ઑબ્જેક્ટની સ્થિતિનો સંદર્ભ આપે છેઃ ઑબ્જેક્ટને જીવંત કરવામાં આવે છે (અપ્રાપ્ય થવાથી), અંતિમ સ્વરૂપ ચલાવવામાં આવે છે, અને પછી અપ્રાપ્ય બનવામાં આવે છે (અને હવે ભવિષ્યના અંતિમ સ્વરૂપ માટે નોંધાયેલ નથી). ડોટ નેટમાં, કઈ વસ્તુઓને અંતિમ સ્વરૂપ આપવાની જરૂર છે તે ઓબ્જેક્ટ-બાય-ઓબ્જેક્ટ ટ્રેક કરવામાં આવતી નથી, પરંતુ તેના બદલે તેને અંતિમ સ્વરૂપ "કતાર" માં સંગ્રહિત કરવામાં આવે છે, તેથી આ લેખના અર્થમાં પુનર્જીવિત વસ્તુઓની કલ્પનાને બદલે, કોઈ વ્યક્તિ "અંતિમ સ્વરૂપ માટે કતારમાં" વસ્તુઓની વાત કરે છે. વધુમાં, વસ્તુઓને GC.ReRegisterForFinalize દ્વારા અંતિમ સ્વરૂપ આપવા માટે પુનઃપ્રાપ્ત કરી શકાય છે, જેથી વસ્તુઓનો ગુણાકાર ન થાય. મિકેનિઝમ એવી બે મુખ્ય રીતો છે કે જેનાથી પદાર્થ પોતાને અથવા અન્ય પદાર્થને પુનર્જીવિત કરી શકે છેઃ તે પદાર્થમાં પોતાનો સંદર્ભ બનાવીને કે જેના સુધી તે પહોંચી શકે છે (કચરો પહોંચી શકાતો નથી, પરંતુ કચરો બિન-કચરો પદાર્થોનો સંદર્ભ આપી શકે છે), અથવા સંદર્ભ બનાવીને પર્યાવરણમાં (વૈશ્વિક ચલ, અથવા કેટલાક કિસ્સાઓમાં સ્થિર ચલ અથવા બંધમાં ચલ). ઑબ્જેક્ટ પોતાને પુનર્જીવિત કરવા માટે, બંનેના પાયથોન ઉદાહરણો અનુસરે છે. કોઈ વસ્તુ માટે અન્ય વસ્તુઓને પુનર્જીવિત કરવી પણ શક્ય છે જો બંનેને આપેલ કચરો સંગ્રહ ચક્રમાં, સમાન પદ્ધતિઓ દ્વારા એકત્રિત કરવામાં આવે. તે જે ઓબ્જેક્ટ સુધી પહોંચી શકે છે તેમાં સંદર્ભ બનાવીને પોતાને પુનર્જીવિત કરે છેઃ વર્ગ ક્લિન્ગીઃ ડેફ _ _ ઇનિટ _ (સેલ્ફ, રીફ = નોન)-> નોનઃ self.ref = રીફ ડેફ _ _ ડેલ _ (સેલ્ફ): જો self.ref: self.ref. રીફ = સેલ્ફ પ્રિન્ટ ("મને છોડશો નહીં!") a = Clingy (Clingy ()) #2-ઘટક સાથે જોડાયેલી સૂચિ બનાવો, #|a | a.ref દ્વારા સંદર્ભિત. રીફ = a #એક ચક્ર બનાવો a.ref = કોઈ નહીં #પ્રથમ નોડથી બીજા નોડ સુધીના સંદર્ભને સાફ કરવાથી બીજો કચરો a.ref = કોઈ નહીં વૈશ્વિક વાતાવરણમાં સંદર્ભ બનાવીને પોતાને પુનર્જીવિત કરે છેઃ c = કોઈ વર્ગ અમર નથીઃ ડેફ _ _ ડેલ _ (સ્વ): વૈશ્વિક cc = સ્વ મુદ્રણ ("હું હજી મૃત નથી".) c = અમર () c = કંઈ નહીં #ક્લિયરિંગ |c | ઓબ્જેક્ટને કચરો બનાવે છે c = કંઈ નહીં ઉપરોક્ત ઉદાહરણોમાં, CPython માં 3.4 પહેલાં, આ વારંવાર ફાઇનલાઇઝર્સ ચલાવશે, અને ઓબ્જેક્ટ્સ કચરો એકત્રિત કરવામાં આવશે નહીં, જ્યારે CPython 3.4 અને પછીના સમયમાં, ફાઇનલાઇઝર્સને માત્ર એક જ વાર બોલાવવામાં આવશે, અને ઓબ્જેક્ટ્સને કચરો એકત્રિત કરવામાં આવશે જ્યારે બીજી વખત તેઓ પહોંચી શકાશે નહીં. સમસ્યાઓ ઑબ્જેક્ટ પુનરુત્થાન મોટી સંખ્યામાં સમસ્યાઓનું કારણ બને છે. કચરાના સંગ્રહને જટિલ બનાવે છે વસ્તુના પુનરુત્થાનની સંભાવનાનો અર્થ એ છે કે કચરો સંગ્રહકર્તાએ અંતિમ સ્વરૂપ આપ્યા પછી પુનર્જીવિત વસ્તુઓની તપાસ કરવી જ જોઇએ-ભલે તે ખરેખર ન થાય-જે કચરાના સંગ્રહને જટિલ બનાવે છે અને ધીમું કરે છે. અવિનાશી પદાર્થો કેટલાક સંજોગોમાં પદાર્થ અવિનાશી હોઈ શકે છેઃ જો કોઈ પદાર્થને તેના પોતાના અંતિમ સ્વરૂપમાં પુનર્જીવિત કરવામાં આવે (અથવા પદાર્થોનું જૂથ તેમના અંતિમ સ્વરૂપોના પરિણામે એકબીજાને પુનર્જીવિત કરે છે), અને અંતિમ સ્વરૂપને હંમેશા પદાર્થનો નાશ કરતી વખતે બોલાવવામાં આવે છે, તો પછી પદાર્થનો નાશ કરી શકાતો નથી અને તેની યાદશક્તિને પુનઃપ્રાપ્ત કરી શકાતી નથી. આકસ્મિક પુનરુત્થાન અને ગળતર ત્રીજું, પદાર્થનું પુનરુત્થાન અજાણતા હોઈ શકે છે, અને પરિણામી પદાર્થ સિમેન્ટીક કચરો હોઈ શકે છે, તેથી ખરેખર ક્યારેય એકત્રિત થતો નથી, જે લોજિકલ મેમરી લીકનું કારણ બને છે. અસંગત સ્થિતિ અને પુનઃપ્રારંભીકરણ એક પુનર્જીવિત પદાર્થ અસંગત સ્થિતિમાં હોઈ શકે છે, અથવા વર્ગ અપરિવર્તનોનું ઉલ્લંઘન કરી શકે છે, કારણ કે અંતિમ સ્વરૂપ ચલાવવામાં આવ્યું છે અને અનિયમિત સ્થિતિ પેદા કરે છે. આમ પુનર્જીવિત વસ્તુઓને સામાન્ય રીતે જાતે ફરીથી શરૂ કરવાની જરૂર પડે છે. વિશિષ્ટ અંતિમ સ્વરૂપ અથવા પુનઃ અંતિમ સ્વરૂપ કેટલીક ભાષાઓમાં (જેમ કે જાવા અને પાયથોન 3.4 +) અંતિમ સ્વરૂપ વસ્તુ દીઠ બરાબર એક જ વાર થવાની ખાતરી આપવામાં આવે છે, તેથી પુનર્જીવિત વસ્તુઓમાં તેમના અંતિમ સ્વરૂપોને બોલાવવામાં આવશે નહીં; તેથી, પુનર્જીવિત વસ્તુઓએ અંતિમ સ્વરૂપની બહાર કોઈપણ જરૂરી સફાઇ કોડને અમલમાં મૂકવો આવશ્યક છે. કેટલીક અન્ય ભાષાઓમાં, પ્રોગ્રામર વારંવાર અંતિમ સ્વરૂપ આપવા માટે દબાણ કરી શકે છે; ખાસ કરીને, C #પાસે GC.ReRegisterForFinalize છે. ઉકેલો ભાષાઓએ પદાર્થના પુનરુત્થાનનો સામનો કરવા માટે ઘણી જુદી જુદી પદ્ધતિઓ અપનાવી છે, સામાન્ય રીતે અંતિમકર્તાઓની હાજરીમાં બે તબક્કાનો કચરો સંગ્રહ કરીને, લટકતા સંદર્ભોને રોકવા માટે; અને વસ્તુઓને માત્ર એક જ વાર અંતિમ સ્વરૂપ આપીને, ખાસ કરીને વસ્તુઓને અંતિમ સ્વરૂપ તરીકે ચિહ્નિત કરીને (ધ્વજ દ્વારા), તે સુનિશ્ચિત કરવા માટે કે વસ્તુઓનો નાશ થઈ શકે છે. જાવા ઓબ્જેક્ટને ત્યાં સુધી મુક્ત કરશે નહીં જ્યાં સુધી તે સાબિત ન કરે કે ઓબ્જેક્ટ ફરી એકવાર પહોંચી ન શકાય તેવું છે, પરંતુ એકથી વધુ વખત ફાઇનલાઇઝર ચલાવશે નહીં. પાયથોનમાં, પાયથોન 3.4 પહેલાં, પ્રમાણભૂત CPython અમલીકરણ પુનર્જીવિત વસ્તુઓને અન્ય વસ્તુઓ (જેને ક્યારેય અંતિમ સ્વરૂપ આપવામાં આવ્યું ન હતું) સાથે સમાન રીતે વ્યવહાર કરશે, જે અવિનાશી વસ્તુઓને શક્ય બનાવશે. વધુમાં, તે પદાર્થના પુનરુત્થાન સાથે સંભવિત સમસ્યાઓને ટાળવા માટે, અંતિમ સ્વરૂપ ધરાવતી વસ્તુ ધરાવતી ચક્રોનો કચરો એકત્રિત કરશે નહીં. પાયથોન 3.4 થી શરૂ કરીને, વર્તન મોટે ભાગે જાવા જેવું જ છેઃ પદાર્થોને માત્ર એક જ વાર અંતિમ સ્વરૂપ આપવામાં આવે છે ("પહેલેથી જ અંતિમ સ્વરૂપ" તરીકે ચિહ્નિત કરવામાં આવે છે), ચક્રોનો કચરો સંગ્રહ બે તબક્કામાં હોય છે, જેમાં બીજા તબક્કામાં પુનર્જીવિત પદાર્થોની તપાસ કરવામાં આવે છે. ઉદ્દેશ-C 2 પુનર્જીવિત વસ્તુઓને "ઝોમ્બી" સ્થિતિમાં મૂકશે, જ્યાં તેઓ તેમને મોકલવામાં આવેલા તમામ સંદેશાઓને લોગ કરશે, પરંતુ બીજું કંઈ નહીં કરે. આ પણ જુઓ સ્વચાલિત સંદર્ભ ગણતરીઃ નબળા સંદર્ભોને સંભાળવા માટે નબળા સંદર્ભોને શૂન્ય કરી રહ્યા છીએ. . NET ફ્રેમવર્કમાં, ખાસ કરીને C #અને VB.NET, ઓબ્જેક્ટને અંતિમ સ્વરૂપ "કતાર" દ્વારા નક્કી કરવામાં આવે છે, જે ઓબ્જેક્ટના વિનાશ દરમિયાન ચકાસવામાં આવે છે. ફાઇનલાઇઝર સાથેની વસ્તુઓ બનાવટ પર આ કતારમાં મૂકવામાં આવે છે, અને જ્યારે ફાઇનલાઇઝરને બોલાવવામાં આવે ત્યારે તેને ડીક્યુ કરવામાં આવે છે, પરંતુ તેને મેન્યુઅલી (ફાઇનલાઇઝેશન પહેલાં) સપ્રેસ ફિનલાઇઝ અથવા રીરેજિસ્ટર ફોર ફિનલાઇઝ સાથે ફરીથી ડીક્યુ કરી શકાય છે. આમ ડિફોલ્ટ રૂપે ફાઇનલાઇઝર્સ સાથેની વસ્તુઓને મહત્તમ એક જ વાર અંતિમ સ્વરૂપ આપવામાં આવે છે, પરંતુ આ અંતિમ સ્વરૂપને દબાવી શકાય છે, અથવા જો વસ્તુઓને પુનર્જીવિત કરવામાં આવે (ફરીથી સુલભ બનાવવામાં આવે) અને પછી અંતિમ સ્વરૂપ આપવા માટે ફરીથી તૈયાર કરવામાં આવે તો તેને ઘણી વખત અંતિમ સ્વરૂપ આપી શકાય છે. વધુમાં, મૂળભૂત રીતે નબળા સંદર્ભો પુનરુત્થાનને ટ્રેક કરતા નથી, એટલે કે જો કોઈ વસ્તુને પુનર્જીવિત કરવામાં આવે તો નબળા સંદર્ભને અપડેટ કરવામાં આવતો નથી; આને ટૂંકા નબળા સંદર્ભો કહેવામાં આવે છે, અને નબળા સંદર્ભો કે જે પુનરુત્થાનને ટ્રેક કરે છે તેને લાંબા નબળા સંદર્ભો કહેવામાં આવે છે. એપ્લિકેશન્સ ઓબ્જેક્ટ પુનરુત્થાન સામાન્ય રીતે ઉપયોગમાં લેવાતી વસ્તુઓના ઓબ્જેક્ટ પૂલને હેન્ડલ કરવા માટે ઉપયોગી છે, પરંતુ તે કોડને અસ્પષ્ટ કરે છે અને તેને વધુ ગૂંચવણમાં મૂકે છે. તેનો ઉપયોગ ફક્ત એવી વસ્તુઓ માટે જ થવો જોઈએ જેનો વારંવાર ઉપયોગ થઈ શકે અને જ્યાં તેનું નિર્માણ/વિનાશ કરવામાં સમય લાગે. એક ઉદાહરણ યાદૃચ્છિક સંખ્યાઓની શ્રેણી હોઈ શકે છે, જ્યાં તેમની મોટી સંખ્યા ટૂંકા સમયમાં બનાવવામાં આવે છે અને નાશ પામે છે, પરંતુ જ્યાં વાસ્તવમાં એક જ સમયે માત્ર એક નાની સંખ્યા ઉપયોગમાં છે. ઑબ્જેક્ટ પુનરુત્થાન સાથે, પૂલિંગ તકનીક સર્જન અને વિનાશના બિનજરૂરી ઓવરહેડને ઘટાડશે. અહીં, પૂલ મેનેજર ઑબ્જેક્ટના સંદર્ભના સ્વરૂપમાં તેના ઓબ્જેક્ટ સ્ટેકની માહિતી મેળવશે, જો તે હાલમાં નષ્ટ થવાનું હોય. પૂલ મેનેજર પછીથી ફરીથી ઉપયોગ માટે ઓબ્જેક્ટ રાખશે. ઓબ્જેક્ટ લાઇફટાઇમ નોટ્સ રેફરન્સ મેમરી મેનેજમેન્ટ ઓબ્જેક્ટ (કોમ્પ્યુટર સાયન્સ) પણ જુઓ.