स्वचालित मेमोरी प्रबंधन वाली भाषाओं में, कचरा संग्रहकर्ता उन वस्तुओं को हटा देता है जब वे संदर्भ द्वारा सुलभ नहीं होती हैं। आमतौर पर यह वही है जिसकी आपको आवश्यकता है: जब तक आप इसे एक्सेस कर सकते हैं, तब तक ऑब्जेक्ट मौजूद रहता है।
कभी-कभी यह व्यवहार उपयुक्त नहीं होता है। उदाहरण के लिए, प्रोग्राम को एक निश्चित वर्ग के उदाहरणों के बारे में कुछ सहायक जानकारी संग्रहीत करने की आवश्यकता होती है, लेकिन आपके पास इस वर्ग में अपना स्वयं का फ़ील्ड जोड़ने का कोई तरीका नहीं है। इस मामले में, आप एक प्रदर्शन बना सकते हैं जिसमें कुंजी वस्तु है, और मूल्य सहायक जानकारी है।
यहीं से समस्याएं शुरू होती हैं। चूंकि मैपिंग कुंजी के संदर्भों को संग्रहीत करती है, उन वस्तुओं को जिनके लिए सहायक जानकारी को स्मृति से मुक्त करने के लिए बाध्य किया गया था। यदि कोई प्रोग्राम अपने काम के दौरान कई ऑब्जेक्ट बनाता है, तो मेमोरी जल्द या बाद में समाप्त हो जाएगी।
कमजोर लिंक ऐसी समस्याओं से बचने में मदद करते हैं। कमजोर लिंक नियमित लोगों से भिन्न होते हैं कि वे ऑब्जेक्ट को मेमोरी से डिलीट होने से नहीं रोकते हैं। जब किसी ऑब्जेक्ट द्वारा कब्जा की गई मेमोरी को मुक्त किया जाता है, तो इसे इंगित करने वाले सभी कमजोर संदर्भ रीसेट हो जाते हैं। कुछ कार्यान्वयन में, इस मामले में, उपयोगकर्ता-परिभाषित हैंडलर, फाइनल, भी कहा जाता है।
उपरोक्त उदाहरण में, आपको सामान्य मैपिंग को एक मैपिंग के साथ बदलने की आवश्यकता है जो कमजोर कुंजी संदर्भों को संग्रहीत करता है। जब कुंजी गायब हो जाती है, तो डिस्प्ले में रिकॉर्ड स्वचालित रूप से इसके साथ गायब हो जाता है, जिसके बाद मूल्य भी जारी किया जा सकता है।
एक अन्य उदाहरण - जटिल गणनाओं के माध्यम से एक फ़ंक्शन पैरामीटर के एक सेट के संदर्भ में बहुत अधिक महत्व प्राप्त करता है। कई बार एक ही चीज़ की गणना नहीं करने के लिए, आप गणना किए गए मानों का एक कैश बना सकते हैं। यदि मूल्य एक वस्तु है, तो इसे कैश से हटाने का कोई मतलब नहीं है जब तक कि इसके लिंक हैं। यहां आप कैश के रूप में, मानों के बजाय कमजोर संदर्भ वाले मानचित्र का उपयोग कर सकते हैं।
समर्थन जानकारी के साथ उदाहरण पर लौटते हैं। कभी-कभी ऐसा होता है कि सहायक जानकारी एक वस्तु होती है, और इसमें एक कुंजी का लिंक होता है। कमजोर कुंजी संदर्भों के साथ एक मानचित्रण काम करना बंद कर देता है: चूँकि मूल्य का संदर्भ कमजोर नहीं होता है, और मान का एक महत्वपूर्ण संदर्भ होता है, कुंजी हमेशा नियमित लिंक के माध्यम से पहुंच योग्य होती है, और मेमोरी को मुक्त नहीं किया जाता है। मूल्य से लिंक को भी कमजोर बनाकर इस समस्या को हल किया जा सकता है।
लेकिन कुछ भाषाओं में, इस समस्या को एक विशेष प्रकार के कमजोर लिंक के साथ हल किया जा सकता है: पंचांग । एपेमरॉन दो वस्तुओं के संदर्भ का समर्थन करता है: कुंजी और मूल्य। जबकि कुंजी नियमित लिंक के माध्यम से पहुंच योग्य है, न तो कुंजी और न ही मूल्य हटाया जाता है। यदि कुंजी फिर से पहुंचना बंद कर देती है, तो दोनों लिंक रीसेट हो जाते हैं और कुंजी जारी हो जाती है। संपूर्ण बिंदु यह है कि एक मूल्य से महत्वपूर्ण संदर्भों को पुनरावर्तन का निर्धारण करते समय ध्यान में नहीं रखा जाता है, इसलिए यदि ऊपर दिए गए उदाहरण में हम मैपिंग की जगह कमजोर कुंजी संदर्भों को मैपिंग के साथ उपयोग करते हैं, तो सब कुछ फिर से काम करेगा।
कचरा इकट्ठा करने वाले के दृष्टिकोण से, पंचांग की उपस्थिति पंचांग से कुंजी की कमजोर कड़ी और कुंजी से मूल्य के लिए एक मजबूत लिंक बनाती है। कुछ भाषाओं में, जैसे हास्केल, कुंजी से एपेमरॉन के लिए भी एक मजबूत लिंक है, ताकि जब तक कि कीपर मौजूद रहता है, तब तक एपेरमोन का अस्तित्व बना रहे, जिससे आप एपेसेरॉन से लिंक को नहीं बचा सकते।

C #

सी # में, कमजोर लिंक दो वर्गों द्वारा कार्यान्वित किए जाते हैं: System नामस्थान में WeakReference और WeakReference<T> । ये वर्ग इस मायने में भिन्न होते हैं कि उनमें से दूसरा एक सामान्य प्रकार है, अर्थात्, यह आपको उस वस्तु के प्रकार को निर्दिष्ट करने की अनुमति देता है, जिससे लिंक इंगित करता है, इसके अलावा, उनके पास उस वस्तु तक पहुँचने के लिए अलग-अलग इंटरफेस होते हैं जो लिंक को इंगित करता है: उनमें से पहला उपयोग करता है गुण IsAlive और Target , और दूसरा - तरीके TryGetTarget और SetTarget ।
अन्य भाषाओं के विपरीत, C # आपको यह बनाने की अनुमति देता है कि इसे बनाए जाने के बाद कमजोर लिंक बिंदुओं को कौन सी वस्तु। कमजोर लिंक में एक कंस्ट्रक्टर भी होता है जो टाइप bool एक अतिरिक्त पैरामीटर को स्वीकार करता है: यदि इसका मान false , तो एक साधारण कमजोर लिंक बनाया जाता है, और यदि यह true , तो लिंक जावा में एक PhantomReference व्यवहार की तरह व्यवहार करेगा। C # में, कमजोर लिंक में फ़ाइनलीज़र नहीं है, या जल्दी से पता चलता है कि कई कमजोर लिंक में से एक को रीसेट कर दिया गया है।

सी ++

C ++ में, std::weak_ptr , जिसे std::shared_ptr वर्ग के साथ संयोजन के रूप में उपयोग करने के लिए डिज़ाइन किया गया है, कमजोर लिंक के लिए जिम्मेदार है। कमजोर लिंक द्वारा इंगित की गई किसी वस्तु के साथ काम करने के लिए, आपको पहले lock विधि का उपयोग करके एक मजबूत लिंक प्राप्त करना होगा।

कोड उदाहरण:

 #include <iostream> #include <memory> using namespace std; void print_weak(weak_ptr<int> w) { if (auto s = w.lock()) { cout << *s << endl; } else { cout << "   " << endl; } } int main(int argc, char *argv[]) { shared_ptr<int> s(new int(123)); weak_ptr<int> w(s); print_weak(w); s = NULL; print_weak(w); } 

हास्केल

कई अन्य भाषाओं के विपरीत, हास्केल पंचांगों का समर्थन करता है। सभी कमजोर लिंक Weak प्रकार के हैं, जो System.Mem.Weak मॉड्यूल में परिभाषित है। हास्केल में, एक कमजोर लिंक कम से कम तब तक मौजूद रहेगा जब तक कुंजी लिंक द्वारा पहुंच योग्य नहीं होती है, इसलिए आप एक अंतिम लिंक के साथ एक कमजोर लिंक बना सकते हैं, इसके बारे में "भूल" और फाइनल करने वाले को अभी भी बुलाया जाएगा। addFinalizer फ़ंक्शन बस यही addFinalizer है। एक कमजोर लिंक बनाने के लिए, mkWeak और mkWeakPtr ।

कोड उदाहरण:

 import Control.Exception import System.Mem.Weak main = do l <- getLine mkWeakPtr l (Just $ putStrLn "   ") evaluate $ sum [1..100000] 

जावा

जावा में, एक कमजोर लिंक एक अलग वस्तु है, और जिस वस्तु के साथ कमजोर लिंक इंगित करता है, उसके साथ काम करने के लिए, आपको पहले get विधि का उपयोग करके एक नियमित लिंक प्राप्त करना होगा। कमजोर लिंक 3 प्रकार के होते हैं: सॉफ्ट लिंक ( java.lang.ref में SoftReference क्लास), साधारण कमजोर लिंक ( WeakReference ) और फैंटम लिंक ( PhantomReference )। वे उस में भिन्न होते हैं जब कचरा कलेक्टर ऐसे लिंक द्वारा पहुंच योग्य वस्तुओं को मुक्त करेगा। यदि ऑब्जेक्ट नरम लिंक के माध्यम से पहुंच योग्य है, तो इसे तभी मुक्त किया जाएगा जब ढेर में पर्याप्त खाली स्थान न हो। इस तरह के लिंक सभी प्रकार के कैश के लिए अच्छी तरह से अनुकूल हैं। जब लिंक रीसेट हो जाता है तो साधारण कमजोर लिंक फैंटम वालों से अलग होते हैं: पहला फ़ाइनल करने से पहले रीसेट हो जाता है, और दूसरा उसके तुरंत बाद, मेमोरी फ़्री होने से पहले। अंतिम ऑब्जेक्ट्स तक पहुंच को रोकने के लिए, PhantomReference लिए पाठक फ़ंक्शन हमेशा null । उनसे लाभ प्राप्त करने का एकमात्र तरीका लिंक कतारों का उपयोग करना है।
यदि प्रोग्राम बहुत कमजोर लिंक का उपयोग करता है, तो उनमें से प्रत्येक को यह देखने के लिए जांचें कि क्या यह शून्य पर रीसेट किया गया है, लाभहीन हो सकता है। जावा आपको कमजोर लिंक के लिए फाइनल निर्दिष्ट करने की अनुमति नहीं देता है, लेकिन इसके बजाय आप एक विशेष ऑब्जेक्ट बना सकते हैं - एक लिंक कतार ( ReferenceQueue ) - और कमजोर लिंक को कॉन्फ़िगर करें ताकि वे शून्य होने पर खुद को वहां जोड़ लें। अब आप सभी लिंक नहीं, बल्कि केवल एक कतार देख सकते हैं।
जावा में भी एक कमजोर WeakHashMap वर्ग है - कमजोर प्रमुख संदर्भों के साथ HashMap का एक एनालॉग।

कोड उदाहरण:

 import java.lang.ref.*; class WeakRefTest implements Runnable { //  ,    // ,     . public static void printWhenUnreachable(Object obj) { ReferenceQueue<Object> queue = new ReferenceQueue<Object>(); WeakReference<Object> ref = new WeakReference<Object>(obj, queue); new Thread(new WeakRefTest(ref, queue)).start(); } private final WeakReference<Object> ref; private final ReferenceQueue<Object> queue; private WeakRefTest(WeakReference<Object> ref, ReferenceQueue<Object> queue) { this.ref = ref; this.queue = queue; } public void run() { try { queue.remove(); System.out.println("   "); } catch (InterruptedException e) { throw new RuntimeException(e); } } } 

ध्यान दें कि WeakRefTest वर्ग का ref क्षेत्र है जिसका उपयोग नहीं किया गया है। यह आवश्यक है ताकि कमजोर लिंक को समय से पहले ही मुक्त न किया जाए, अन्यथा यह काम नहीं करेगा।

लुआ

लुआ "कमजोर तालिकाओं" के माध्यम से कमजोर संदर्भों का समर्थन करता है: इसी मेटिबिटेबल में, __mode कुंजी को एक स्ट्रिंग मान पर सेट किया जा सकता है, और फिर यदि इसमें वर्ण k , तो कुंजी कमजोर होगी, और यदि इसमें v शामिल है, तो लिंक कमजोर होंगे । इसके निर्माण के बाद तालिका के प्रकार को बदला जा सकता है, हालांकि, परिवर्तन केवल अगले कचरा संग्रह पर प्रभावी होंगे। जैसे कमजोर संदर्भ वाली तालिकाओं के अन्य कार्यान्वयन में, जब एक कुंजी या मान रीसेट किया जाता है, तो पूरा रिकॉर्ड हटा दिया जाता है।
यदि मुख्य संदर्भ कमजोर हैं और मान मजबूत हैं, तो तालिका में प्रविष्टियां पंचांगों की तरह व्यवहार करेंगी: कुंजी मान का एक लिंक प्रविष्टि को हटाए जाने से नहीं रोक सकेगा।

पर्ल

पर्ल में, Scalar::Util पैकेज से weaken विधि का उपयोग करके किसी भी लिंक को कमजोर बनाया जा सकता है। अन्य भाषाओं के विपरीत, यदि आप एक कमजोर लिंक कॉपी करते हैं, तो कॉपी एक नियमित लिंक होगी।

अजगर

पायथन कमजोर संदर्भों का समर्थन करता है, लेकिन उन्हें केवल उन वर्गों के उदाहरणों पर बनाया जा सकता है जो इसका समर्थन करते हैं। इनमें अधिकांश कस्टम क्लासेस और कुछ बिल्ट-इन शामिल हैं। इसके अलावा, पायथन में कमजोर लिंक के लिए 2 कक्षाएं हैं: ref वर्ग ( weakref वर्ग पैकेज) के उदाहरणों से आपको स्पष्ट रूप से सामान्य वस्तु संदर्भ प्राप्त करने की आवश्यकता है, और आप सीधे proxy वर्ग के उदाहरणों के साथ काम कर सकते हैं।
एक कमजोर लिंक बनाते समय, आप एक अंतिम रूप निर्दिष्ट कर सकते हैं। किसी भी वस्तु के लिए कमजोर लिंक की सूची प्राप्त करना भी संभव है (साधारण, वैसे, भी)।
जावा के विपरीत, पायथन में कमजोर लिंक वाले 3 प्रकार के संग्रह हैं: WeakSet , WeakKeyDictionary और WeakValueDictionary ।

कोड उदाहरण:

 # -*- coding: utf8 -*- from weakref import * def finalizer(ref): print("   ") obj = set() reference = ref(obj, finalizer) del obj 

जावा में, यदि लिंक को ऑब्जेक्ट से पहले हटा दिया जाता है, तो अंतिम रूप से कॉल नहीं किया जाता है।

गहरे लाल रंग का

रूबी में, कमजोर लिंक को केवल WeakRef वर्ग में लागू किया जाता है, जो कि Python में proxy क्लास के समान व्यवहार करता है, यानी एक कमजोर लिंक के साथ आप उसी तरह काम कर सकते हैं जैसे कि ऑब्जेक्ट के साथ। ऑब्जेक्ट के तरीकों के अलावा, क्या कमजोर संदर्भों में एक कमजोर weakref_alive? विधि है weakref_alive? , जो true अगर लिंक द्वारा संदर्भित वस्तु अभी भी मौजूद है, अन्यथा false ।

UPD: सॉर्ट की गई भाषाओं को वर्णानुक्रम में जोड़ा गया, C # और Lua जोड़ा गया, जो कि पंचांगों के व्यवहार के बारे में अधिक विस्तार से वर्णित है।