Object resurrection
ಕಸ ಸಂಗ್ರಹದೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ, ಆಬ್ಜೆಕ್ಟ್ ರಿಸರೆಕ್ಷನ್ ಎಂದರೆ ವಸ್ತುವಿನ ವಿನಾಶದ ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ಒಂದು ವಸ್ತುವು ಜೀವಂತವಾಗಿ ಹಿಂತಿರುಗಿದಾಗ, ಫೈನಲೈಸರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಡ್ಡಪರಿಣಾಮವಾಗಿದೆ. ವಸ್ತುವಿನ ಪುನರುತ್ಥಾನವು ಹಲವಾರು ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ವಸ್ತುವಿನ ಪುನರುತ್ಥಾನದ ಸಾಧ್ಯತೆಯು-ಅದು ಸಂಭವಿಸದಿದ್ದರೂ ಸಹ-ಕಸ ಸಂಗ್ರಹವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಮತ್ತು ನಿಧಾನಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅಂತಿಮಗೊಳಿಸುವವರನ್ನು ನಿರುತ್ಸಾಹಗೊಳಿಸಲು ಇದು ಒಂದು ಪ್ರಮುಖ ಕಾರಣವಾಗಿದೆ. ಭಾಷೆಗಳು ವಸ್ತುವಿನ ಪುನರುತ್ಥಾನದ ಬಗ್ಗೆ ವಿವಿಧ ರೀತಿಯಲ್ಲಿ ವ್ಯವಹರಿಸುತ್ತವೆ. ಅಪರೂಪದ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಆಬ್ಜೆಕ್ಟ್ ಪುನರುತ್ಥಾನವನ್ನು ಕೆಲವು ವಿನ್ಯಾಸದ ಮಾದರಿಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಆಬ್ಜೆಕ್ಟ್ ಪೂಲ್, ಆದರೆ ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ ಪುನರುತ್ಥಾನವು ಅಂತಿಮಗೊಳಿಸುವ ದೋಷದಿಂದ ಉಂಟಾಗುವ ಅನಪೇಕ್ಷಿತ ದೋಷವಾಗಿದೆ, ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಪುನರುತ್ಥಾನವನ್ನು ನಿರುತ್ಸಾಹಗೊಳಿಸಲಾಗುತ್ತದೆ. ಪ್ರಕ್ರಿಯೆ ವಸ್ತುವಿನ ಪುನರುತ್ಥಾನವು ಈ ಕೆಳಗಿನ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ಸಂಭವಿಸುತ್ತದೆ. ಮೊದಲನೆಯದಾಗಿ, ಒಂದು ವಸ್ತುವನ್ನು ಪ್ರೋಗ್ರಾಂನಿಂದ ಇನ್ನು ಮುಂದೆ ತಲುಪಲಾಗದಿದ್ದಾಗ ಅದು ಕಸವಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು (ನಾಶಪಡಿಸಬಹುದು ಮತ್ತು ವಿಂಗಡಿಸಬಹುದು). ನಂತರ, ವಸ್ತುವಿನ ನಾಶದ ಸಮಯದಲ್ಲಿ, ಕಸ ಸಂಗ್ರಾಹಕನು ವಸ್ತುವನ್ನು ನಿಯೋಜಿಸುವ ಮೊದಲು, ಅಂತಿಮಗೊಳಿಸುವ ವಿಧಾನವನ್ನು ಚಲಾಯಿಸಬಹುದು, ಅದು ಆ ವಸ್ತುವನ್ನು ಅಥವಾ ಇನ್ನೊಂದು ಕಸ ವಸ್ತುವನ್ನು (ಅಂತಿಮಗೊಳಿಸುವ ಮೂಲಕ ವಸ್ತುವಿನಿಂದ ತಲುಪಬಹುದಾದ) ಅದರ ಉಲ್ಲೇಖಗಳನ್ನು ರಚಿಸುವ ಮೂಲಕ ಮತ್ತೆ ತಲುಪಬಹುದು, ಏಕೆಂದರೆ ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯು ಅನಿಯಂತ್ರಿತ ಸಂಕೇತವನ್ನು ಹೊಂದಿರಬಹುದು. ಇದು ಸಂಭವಿಸಿದಲ್ಲಿ, ಉಲ್ಲೇಖಿತ ವಸ್ತುವು-ಇದು ಅಂತಿಮ ವಸ್ತುವಾಗಿರಬೇಕಾಗಿಲ್ಲ-ಇನ್ನು ಮುಂದೆ ಕಸವಲ್ಲ, ಮತ್ತು ಅದನ್ನು ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ, ಇಲ್ಲದಿದ್ದರೆ ಅದರ ಉಲ್ಲೇಖಗಳು ತೂಗಾಡುತ್ತಿರುವ ಉಲ್ಲೇಖಗಳಾಗುತ್ತವೆ ಮತ್ತು ಬಳಸಿದಾಗ ದೋಷಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತವೆ, ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್ ಅಥವಾ ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆ. ಬದಲಿಗೆ, ಸ್ಮರಣೆಯ ಸುರಕ್ಷತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು, ವಸ್ತುವನ್ನು ಜೀವಂತಗೊಳಿಸಲಾಗುತ್ತದೆ ಅಥವಾ ಪುನರುಜ್ಜೀವನಗೊಳಿಸಲಾಗುತ್ತದೆ. ಇದನ್ನು ಪತ್ತೆಹಚ್ಚಲು, ಕಸ ಸಂಗ್ರಾಹಕರು ಸಾಮಾನ್ಯವಾಗಿ ಅಂತಿಮಗೊಳಿಸುವವರ ಉಪಸ್ಥಿತಿಯಲ್ಲಿ ಎರಡು ಹಂತದ ಸಂಗ್ರಹವನ್ನು ಮಾಡುತ್ತಾರೆಃ ಮೊದಲು ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿರುವ ಯಾವುದೇ ಕಸವನ್ನು ಅಂತಿಮಗೊಳಿಸಿ, ನಂತರ ಎಲ್ಲಾ ಕಸವನ್ನು (ಅಥವಾ ಅಂತಿಮಗೊಳಿಸುವ ವಸ್ತುಗಳಿಂದ ತಲುಪಬಹುದಾದ ಎಲ್ಲಾ ಕಸವನ್ನು) ಮರು ಪರಿಶೀಲಿಸುತ್ತಾರೆ. ಇದು ಓವರ್ಹೆಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಮೆಮೊರಿ ರಿಕ್ಲಮೇಷನ್ ಅನ್ನು ವಿಳಂಬಗೊಳಿಸುತ್ತದೆ. ಪುನರುತ್ಥಾನಗೊಂಡ ವಸ್ತುವನ್ನು ಇತರ ವಸ್ತುಗಳಂತೆಯೇ ಪರಿಗಣಿಸಬಹುದು ಅಥವಾ ವಿಶೇಷವಾಗಿ ಪರಿಗಣಿಸಬಹುದು. ಅನೇಕ ಭಾಷೆಗಳಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ಸಿ #, ಜಾವಾ, ಮತ್ತು ಪೈಥಾನ್ (ಪೈಥಾನ್ 3.4 ರಿಂದ), ವಸ್ತುಗಳನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಅಂತಿಮಗೊಳಿಸಲಾಗುತ್ತದೆ, ವಸ್ತುವು ಪದೇ ಪದೇ ಪುನರುತ್ಥಾನಗೊಳ್ಳುವ ಅಥವಾ ನಾಶವಾಗದ ಸಾಧ್ಯತೆಯನ್ನು ತಪ್ಪಿಸಲು; ಸಿ #ನಲ್ಲಿ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಅಂತಿಮಗೊಳಿಸುವ ವಸ್ತುಗಳನ್ನು ಹೊಂದಿರುವ ವಸ್ತುಗಳನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಅಂತಿಮಗೊಳಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಅಂತಿಮಗೊಳಿಸಲು ಮರು-ನೋಂದಾಯಿಸಬಹುದು. ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ ಪುನರುತ್ಥಾನಗೊಂಡ ವಸ್ತುಗಳನ್ನು ದೋಷಗಳೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ಯಲ್ಲಿ; ಅಥವಾ ಇತರ ವಸ್ತುಗಳಿಗೆ ಸಮಾನವಾಗಿ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಪೈಥಾನ್ 3.4ಕ್ಕಿಂತ ಮೊದಲು ಪೈಥಾನ್ನಲ್ಲಿ. ಪುನರುತ್ಥಾನಗೊಂಡ ವಸ್ತುವನ್ನು ಕೆಲವೊಮ್ಮೆ ಎ ಅಥವಾ ಜೊಂಬಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಆದರೆ ಈ ಪದವನ್ನು ವಸ್ತು ನಾಶಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ವಿವಿಧ ವಸ್ತು ಸ್ಥಿತಿಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ, ಇದರ ಬಳಕೆಯು ಭಾಷೆ ಮತ್ತು ಲೇಖಕರನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ ಯಲ್ಲಿ "ಜೊಂಬಿ ಆಬ್ಜೆಕ್ಟ್" ಒಂದು ವಿಶೇಷ ಅರ್ಥವನ್ನು ಹೊಂದಿದೆ, ಇದನ್ನು ಕೆಳಗೆ ವಿವರಿಸಲಾಗಿದೆ. ಜೊಂಬಿ ವಸ್ತುಗಳು ಜೊಂಬಿ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಹೋಲುತ್ತವೆ, ಇದರಲ್ಲಿ ಅವು ಮುಕ್ತಾಯ ಸ್ಥಿತಿಯ ಬದಲಾವಣೆಗೆ ಒಳಗಾಗಿವೆ ಮತ್ತು ಡಿಯಾಲೊಕೇಷನ್ಗೆ ಹತ್ತಿರದಲ್ಲಿವೆ, ಆದರೆ ವಿವರಗಳು ಗಮನಾರ್ಹವಾಗಿ ಭಿನ್ನವಾಗಿವೆ. . NET ಚೌಕಟ್ಟಿನಲ್ಲಿನ ರೂಪಾಂತರಗಳು, ವಿಶೇಷವಾಗಿ C #ಮತ್ತು VB.NET, "ವಸ್ತುವಿನ ಪುನರುತ್ಥಾನ" ವು ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯ ಸಮಯದಲ್ಲಿ ವಸ್ತುವಿನ ಸ್ಥಿತಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆಃ ವಸ್ತುವನ್ನು ಮತ್ತೆ ಜೀವಂತಗೊಳಿಸಲಾಗುತ್ತದೆ (ಪ್ರವೇಶಿಸಲಾಗದ ಸ್ಥಿತಿಯಿಂದ), ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯನ್ನು ಓಡಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಪ್ರವೇಶಿಸಲಾಗದ ಸ್ಥಿತಿಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ (ಮತ್ತು ಭವಿಷ್ಯದ ಅಂತಿಮಗೊಳಿಸುವಿಕೆಗಾಗಿ ಇನ್ನು ಮುಂದೆ ನೋಂದಾಯಿಸಲಾಗುವುದಿಲ್ಲ). . ನೆಟ್ನಲ್ಲಿ, ಯಾವ ವಸ್ತುಗಳನ್ನು ಅಂತಿಮಗೊಳಿಸಬೇಕೆಂಬುದನ್ನು ವಸ್ತುವಿನಿಂದ ವಸ್ತುವಿಗೆ ಟ್ರ್ಯಾಕ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಬದಲಿಗೆ ಅಂತಿಮಗೊಳಿಸುವ "ಕ್ಯೂ" ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಈ ಲೇಖನದ ಅರ್ಥದಲ್ಲಿ ಪುನರುತ್ಥಾನಗೊಂಡ ವಸ್ತುಗಳ ಕಲ್ಪನೆಯ ಬದಲು, ಒಬ್ಬರು "ಅಂತಿಮಗೊಳಿಸಲು ಸರತಿ ಸಾಲಿನಲ್ಲಿ" ಇರುವ ವಸ್ತುಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಾರೆ. ಇದಲ್ಲದೆ, ಎನ್ಕ್ಯೂಯು ಆಬ್ಜೆಕ್ಟ್ಗಳನ್ನು ಗುಣಿಸದಂತೆ ನೋಡಿಕೊಳ್ಳುತ್ತಾ, GC.ReRegisterForFinalize ಮೂಲಕ ಅಂತಿಮಗೊಳಿಸಲು ಆಬ್ಜೆಕ್ಟ್ಗಳನ್ನು ಮರು-ಎನ್ಕ್ಯೂವ್ ಮಾಡಬಹುದು. ಕಾರ್ಯವಿಧಾನ ಒಂದು ವಸ್ತುವು ತನ್ನನ್ನು ಅಥವಾ ಇನ್ನೊಂದು ವಸ್ತುವನ್ನು ಪುನರುಜ್ಜೀವನಗೊಳಿಸಲು ಎರಡು ಮುಖ್ಯ ಮಾರ್ಗಗಳಿವೆಃ ಅದು ತಲುಪಬಹುದಾದ ವಸ್ತುವಿನಲ್ಲಿ ತನ್ನದೇ ಆದ ಉಲ್ಲೇಖವನ್ನು ರಚಿಸುವ ಮೂಲಕ (ಕಸವನ್ನು ತಲುಪಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಕಸವು ಕಸವಲ್ಲದ ವಸ್ತುಗಳನ್ನು ಉಲ್ಲೇಖಿಸಬಹುದು), ಅಥವಾ ಪರಿಸರದಲ್ಲಿ ಉಲ್ಲೇಖವನ್ನು ರಚಿಸುವ ಮೂಲಕ (ಜಾಗತಿಕ ಅಸ್ಥಿರಗಳು, ಅಥವಾ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಸ್ಥಿರ ಅಸ್ಥಿರಗಳು ಅಥವಾ ಮುಚ್ಚುವಿಕೆಯಲ್ಲಿನ ಅಸ್ಥಿರಗಳು). ಒಂದು ವಸ್ತುವು ತನ್ನನ್ನು ತಾನು ಪುನರುಜ್ಜೀವನಗೊಳಿಸಿಕೊಳ್ಳುವುದಕ್ಕಾಗಿ, ಇವೆರಡರ ಪೈಥಾನ್ ಉದಾಹರಣೆಗಳು ಅನುಸರಿಸುತ್ತವೆ. ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಸ ಸಂಗ್ರಹಣಾ ಚಕ್ರದಲ್ಲಿ, ಒಂದೇ ಕಾರ್ಯವಿಧಾನದ ಮೂಲಕ ಎರಡನ್ನೂ ಸಂಗ್ರಹಿಸುತ್ತಿದ್ದರೆ, ಒಂದು ವಸ್ತುವು ಇತರ ವಸ್ತುಗಳನ್ನು ಪುನರುಜ್ಜೀವನಗೊಳಿಸಲು ಸಹ ಸಾಧ್ಯವಿದೆ. ಅದು ತಲುಪಬಹುದಾದ ವಸ್ತುವಿನಲ್ಲಿ ಒಂದು ಉಲ್ಲೇಖವನ್ನು ರಚಿಸುವ ಮೂಲಕ ತನ್ನನ್ನು ತಾನು ಪುನರುಜ್ಜೀವನಗೊಳಿಸುತ್ತದೆಃ ವರ್ಗ ಕ್ಲಿಂಗಿಃ ಡೆಫ್ _ _ init _ (ಸ್ವಯಂ, ರೆಫ್ = ಯಾವುದೂ ಇಲ್ಲ)-> ಯಾವುದೂ ಇಲ್ಲಃ 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 + ನಂತಹ) ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯು ಪ್ರತಿ ವಸ್ತುವಿಗೆ ನಿಖರವಾಗಿ ಒಮ್ಮೆ ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ಖಾತರಿಪಡಿಸಲಾಗಿದೆ, ಆದ್ದರಿಂದ ಪುನರುತ್ಥಾನಗೊಂಡ ವಸ್ತುಗಳು ಅವುಗಳ ಅಂತಿಮಗೊಳಿಸುವಿಕೆಗಳನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ; ಆದ್ದರಿಂದ, ಪುನರುತ್ಥಾನಗೊಂಡ ವಸ್ತುಗಳು ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯ ಹೊರಗೆ ಯಾವುದೇ ಅಗತ್ಯವಾದ ಸ್ವಚ್ಛಗೊಳಿಸುವ ಸಂಕೇತವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು. ಇತರ ಕೆಲವು ಭಾಷೆಗಳಲ್ಲಿ, ಪ್ರೋಗ್ರಾಮರ್ ಪದೇ ಪದೇ ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯನ್ನು ಒತ್ತಾಯಿಸಬಹುದು; ಗಮನಾರ್ಹವಾಗಿ, ಸಿ #GC.ReRegisterForFinalize ಅನ್ನು ಹೊಂದಿದೆ. ಪರಿಹಾರಗಳು ವಸ್ತುಗಳ ಪುನರುತ್ಥಾನವನ್ನು ನಿಭಾಯಿಸಲು ಭಾಷೆಗಳು ಹಲವಾರು ವಿಭಿನ್ನ ವಿಧಾನಗಳನ್ನು ಅಳವಡಿಸಿಕೊಂಡಿವೆ, ಸಾಮಾನ್ಯವಾಗಿ ಅಂತಿಮಗೊಳಿಸುವವರ ಉಪಸ್ಥಿತಿಯಲ್ಲಿ ಎರಡು-ಹಂತದ ಕಸ ಸಂಗ್ರಹವನ್ನು ಹೊಂದುವ ಮೂಲಕ, ತೂಗಾಡುತ್ತಿರುವ ಉಲ್ಲೇಖಗಳನ್ನು ತಡೆಗಟ್ಟಲು; ಮತ್ತು ವಸ್ತುಗಳನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಅಂತಿಮಗೊಳಿಸುವ ಮೂಲಕ, ವಿಶೇಷವಾಗಿ ವಸ್ತುಗಳನ್ನು ಅಂತಿಮಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಗುರುತಿಸುವ ಮೂಲಕ (ಧ್ವಜದ ಮೂಲಕ), ವಸ್ತುಗಳನ್ನು ನಾಶಪಡಿಸಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು. ವಸ್ತುವನ್ನು ಮತ್ತೊಮ್ಮೆ ತಲುಪಲಾಗುವುದಿಲ್ಲ ಎಂದು ಸಾಬೀತುಪಡಿಸುವವರೆಗೆ ಜಾವಾ ವಸ್ತುವನ್ನು ಮುಕ್ತಗೊಳಿಸುವುದಿಲ್ಲ, ಆದರೆ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯನ್ನು ಚಲಾಯಿಸುವುದಿಲ್ಲ. ಪೈಥಾನ್ನಲ್ಲಿ, ಪೈಥಾನ್ 3.4ಕ್ಕಿಂತ ಮೊದಲು, ಪ್ರಮಾಣಿತ CPython ಅನುಷ್ಠಾನವು ಪುನರುತ್ಥಾನಗೊಂಡ ವಸ್ತುಗಳನ್ನು ಇತರ ವಸ್ತುಗಳಿಗೆ ಸಮಾನವಾಗಿ ಪರಿಗಣಿಸುತ್ತದೆ (ಇವುಗಳನ್ನು ಎಂದಿಗೂ ಅಂತಿಮಗೊಳಿಸಲಾಗಿಲ್ಲ), ಇದು ನಾಶವಾಗದ ವಸ್ತುಗಳನ್ನು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ಇದಲ್ಲದೆ, ವಸ್ತುವಿನ ಪುನರುತ್ಥಾನದಲ್ಲಿ ಸಂಭವನೀಯ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು, ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯೊಂದಿಗೆ ವಸ್ತುವನ್ನು ಹೊಂದಿರುವ ಚಕ್ರಗಳನ್ನು ಇದು ಕಸ ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ. ಪೈಥಾನ್ 3.4 ರಲ್ಲಿ ಪ್ರಾರಂಭಿಸಿ, ನಡವಳಿಕೆಯು ಹೆಚ್ಚಾಗಿ ಜಾವಾದಂತೆಯೇ ಇರುತ್ತದೆಃ ವಸ್ತುಗಳನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಅಂತಿಮಗೊಳಿಸಲಾಗುತ್ತದೆ ("ಈಗಾಗಲೇ ಅಂತಿಮಗೊಳಿಸಲಾಗಿದೆ" ಎಂದು ಗುರುತಿಸಲಾಗಿದೆ), ಚಕ್ರಗಳ ಕಸ ಸಂಗ್ರಹವು ಎರಡು ಹಂತಗಳಲ್ಲಿ ಇರುತ್ತದೆ, ಎರಡನೇ ಹಂತದಲ್ಲಿ ಪುನರುತ್ಥಾನಗೊಂಡ ವಸ್ತುಗಳನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ. ಆಬ್ಜೆಕ್ಟಿವ್-ಸಿ 2.0 ಪುನರುತ್ಥಿತ ವಸ್ತುಗಳನ್ನು "ಜೊಂಬಿ" ಸ್ಥಿತಿಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಅವರು ಕಳುಹಿಸಿದ ಎಲ್ಲಾ ಸಂದೇಶಗಳನ್ನು ಲಾಗ್ ಮಾಡುತ್ತಾರೆ, ಆದರೆ ಬೇರೆ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ. ಸಹ ನೋಡಿ ಸ್ವಯಂಚಾಲಿತ ಉಲ್ಲೇಖ ಎಣಿಕೆಃ ದುರ್ಬಲ ಉಲ್ಲೇಖಗಳನ್ನು ನಿರ್ವಹಿಸಲು ದುರ್ಬಲ ಉಲ್ಲೇಖಗಳನ್ನು ಶೂನ್ಯಗೊಳಿಸುವುದು. . NET ಚೌಕಟ್ಟಿನಲ್ಲಿ, ವಿಶೇಷವಾಗಿ C #ಮತ್ತು VB.NET, ವಸ್ತುವಿನ ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯನ್ನು ಅಂತಿಮಗೊಳಿಸುವ "ಕ್ಯೂ" ನಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ, ಇದನ್ನು ವಸ್ತುವಿನ ನಾಶದ ಸಮಯದಲ್ಲಿ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ. ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯೊಂದಿಗಿನ ವಸ್ತುಗಳನ್ನು ಸೃಷ್ಟಿಯ ಮೇಲೆ ಈ ಸಾಲಿನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯನ್ನು ಕರೆಯುವಾಗ ಜಮೆ ಮಾಡಲಾಗುತ್ತದೆ, ಆದರೆ ಅದನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಜಮೆ ಮಾಡಬಹುದು (ಅಂತಿಮಗೊಳಿಸುವ ಮೊದಲು) ಸಪ್ರೆಸ್ ಫೈನಲೈಸ್ನೊಂದಿಗೆ ಅಥವಾ ರೀ ರೆಜಿಸ್ಟರ್ ಫಾರ್ ಫೈನಲೈಸ್ನೊಂದಿಗೆ ಮರು-ಜಮೆ ಮಾಡಬಹುದು. ಹೀಗಾಗಿ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯೊಂದಿಗೆ ವಸ್ತುಗಳನ್ನು ಗರಿಷ್ಠ ಒಮ್ಮೆಯಾದರೂ ಅಂತಿಮಗೊಳಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಈ ಅಂತಿಮಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿಗ್ರಹಿಸಬಹುದು, ಅಥವಾ ವಸ್ತುಗಳನ್ನು ಪುನರುಜ್ಜೀವನಗೊಳಿಸಿದರೆ (ಮತ್ತೆ ಪ್ರವೇಶಿಸುವಂತೆ) ಅನೇಕ ಬಾರಿ ಅಂತಿಮಗೊಳಿಸಬಹುದು ಮತ್ತು ನಂತರ ಅಂತಿಮಗೊಳಿಸುವಿಕೆಗಾಗಿ ಮರು-ಜಮೆ ಮಾಡಬಹುದು. ಇದಲ್ಲದೆ, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ದುರ್ಬಲ ಉಲ್ಲೇಖಗಳು ಪುನರುತ್ಥಾನವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದಿಲ್ಲ, ಅಂದರೆ ಒಂದು ವಸ್ತುವನ್ನು ಪುನರುತ್ಥಾನಗೊಳಿಸಿದರೆ ದುರ್ಬಲ ಉಲ್ಲೇಖವನ್ನು ನವೀಕರಿಸಲಾಗುವುದಿಲ್ಲ; ಇವುಗಳನ್ನು ಸಣ್ಣ ದುರ್ಬಲ ಉಲ್ಲೇಖಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಪುನರುತ್ಥಾನವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ದುರ್ಬಲ ಉಲ್ಲೇಖಗಳನ್ನು ದೀರ್ಘ ದುರ್ಬಲ ಉಲ್ಲೇಖಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಅಪ್ಲಿಕೇಶನ್ಗಳು ಆಬ್ಜೆಕ್ಟ್ ಪುನರುತ್ಥಾನವು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ವಸ್ತುಗಳ ಆಬ್ಜೆಕ್ಟ್ ಪೂಲ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಉಪಯುಕ್ತವಾಗಿದೆ, ಆದರೆ ಇದು ಕೋಡ್ ಅನ್ನು ಅಸ್ಪಷ್ಟಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹೆಚ್ಚು ಗೊಂದಲಕ್ಕೀಡು ಮಾಡುತ್ತದೆ. ಇದನ್ನು ಆಗಾಗ್ಗೆ ಬಳಸಬಹುದಾದ ಮತ್ತು ಅದರ ನಿರ್ಮಾಣ/ನಾಶವು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುವ ವಸ್ತುಗಳಿಗೆ ಮಾತ್ರ ಬಳಸಬೇಕು. ಒಂದು ಉದಾಹರಣೆಯು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳ ಒಂದು ಶ್ರೇಣಿಯಾಗಿರಬಹುದು, ಅಲ್ಲಿ ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯನ್ನು ಅಲ್ಪಾವಧಿಯಲ್ಲಿಯೇ ರಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಾಶಪಡಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ವಾಸ್ತವವಾಗಿ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಒಂದು ಸಣ್ಣ ಸಂಖ್ಯೆಯು ಮಾತ್ರ ಬಳಕೆಯಲ್ಲಿದೆ. ವಸ್ತುವಿನ ಪುನರುತ್ಥಾನದೊಂದಿಗೆ, ಪೂಲಿಂಗ್ ತಂತ್ರವು ಸೃಷ್ಟಿ ಮತ್ತು ವಿನಾಶದ ಅನಗತ್ಯ ಮೇಲ್ಮೈಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಇಲ್ಲಿ, ಪೂಲ್ ಮ್ಯಾನೇಜರ್ ತನ್ನ ಆಬ್ಜೆಕ್ಟ್ ಸ್ಟಾಕ್ ಮಾಹಿತಿಯನ್ನು ಪ್ರಸ್ತುತ ನಾಶಪಡಿಸಬೇಕಾದರೆ, ವಸ್ತುವಿನ ಉಲ್ಲೇಖದ ರೂಪದಲ್ಲಿ ಪಡೆಯುತ್ತದೆ. ಪೂಲ್ ಮ್ಯಾನೇಜರ್ ನಂತರ ಮರುಬಳಕೆಗಾಗಿ ವಸ್ತುವನ್ನು ಇಟ್ಟುಕೊಳ್ಳುತ್ತಾನೆ. ಆಬ್ಜೆಕ್ಟ್ ಲೈಫ್ಟೈಮ್ ನೋಟ್ಸ್ ರೆಫರೆನ್ಸ್ ಮೆಮೊರಿ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್ (ಕಂಪ್ಯೂಟರ್ ಸೈನ್ಸ್) ಅನ್ನು ಸಹ ನೋಡಿ.