स्विफ्ट - एआरसी अवलोकन

मेमोरी प्रबंधन फ़ंक्शन और इसके उपयोग को स्विफ्ट 4 भाषा में स्वचालित संदर्भ गणना (एआरसी) के माध्यम से नियंत्रित किया जाता है। एआरसी का उपयोग सिस्टम संसाधनों को आरंभ करने और विघटित करने के लिए किया जाता है, जिससे वर्ग उदाहरणों द्वारा उपयोग की जाने वाली मेमोरी रिक्त स्थान जारी करते हैं जब इंस्टेंसेस की अब आवश्यकता नहीं होती है। एआरसी मेमोरी कोड को प्रभावी ढंग से प्रबंधित करने के लिए हमारे कोड इंस्टेंस के बीच संबंधों के बारे में जानकारी का ट्रैक रखता है।

एआरसी के कार्य

  • एआरसी सूचनाओं को संग्रहीत करने के लिए स्मृति का एक हिस्सा आवंटित करता है जब हर बार एक नया वर्ग उदाहरण init () द्वारा बनाया जाता है।

  • उदाहरण प्रकार और उसके मूल्यों के बारे में जानकारी स्मृति में संग्रहीत होती है।

  • जब वर्ग उदाहरण की आवश्यकता नहीं होती है, तो यह स्वचालित रूप से आगे की श्रेणी के उदाहरण के भंडारण और पुनर्प्राप्ति के लिए deinit () द्वारा मेमोरी स्पेस को मुक्त करता है।

  • एआरसी वर्तमान में क्लास इंस्टेंस प्रॉपर्टीज, कॉन्स्टेंट और वैरिएबल का जिक्र करती है, ताकि उन अप्रयुक्त इंस्टेंस पर ही डीइनिट () लागू हो।

  • एआरसी उन वर्ग उदाहरण संपत्ति, स्थिरांक और चर को 'मजबूत संदर्भ' बनाए रखता है जब वर्ग का उपयोग वर्तमान में होता है।

एआरसी कार्यक्रम

class StudDetails {
   var stname: String!
   var mark: Int!
   
   init(stname: String, mark: Int) {
      self.stname = stname
      self.mark = mark
   }
   deinit {
      print("Deinitialized \(self.stname)")
      print("Deinitialized \(self.mark)")
   }
}

let stname = "Swift 4"
let mark = 98

print(stname)
print(mark)

जब हम खेल के मैदान का उपयोग करके उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्नलिखित परिणाम मिलते हैं -

Swift 4
98

एआरसी मजबूत संदर्भ चक्र वर्ग उदाहरण

class studmarks {
   let name: String
   var stud: student?
   
   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

class student {
   let name: String
   var strname: studmarks?
   
   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

var shiba: studmarks?
var mari: student?

shiba = studmarks(name: "Swift 4")
mari = student(name: "ARC")

shiba!.stud = mari
mari!.strname = shiba

जब हम खेल के मैदान का उपयोग करके उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्नलिखित परिणाम मिलते हैं -

Initializing: Swift 4
Initializing: ARC

एआरसी कमजोर और अज्ञात संदर्भ

वर्ग प्रकार की संपत्तियों के मजबूत संदर्भ चक्र को हल करने के दो तरीके हैं -

  • कमजोर संदर्भ
  • प्रख्यात संदर्भ

एक संदर्भ चक्र में अन्य उदाहरणों को संदर्भित करने के लिए एक उदाहरण को सक्षम करने के लिए इन संदर्भों का उपयोग किया जाता है। तब उदाहरण मजबूत संदर्भ चक्र के बारे में देखभाल करने के बजाय प्रत्येक और प्रत्येक उदाहरण को संदर्भित कर सकते हैं। जब उपयोगकर्ता जानता है कि कुछ उदाहरण 'शून्य' मान लौटा सकते हैं, तो हम इंगित कर सकते हैं कि कमजोर संदर्भ का उपयोग कर रहे हैं। जब शून्य के बजाय किसी वस्तु को वापस करने जा रहा है, तो इसे अज्ञात संदर्भ के साथ घोषित करें।

कमजोर संदर्भ कार्यक्रम

class module {
   let name: String
   init(name: String) { self.name = name }
   var sub: submodule?
   deinit { print("\(name) Is The Main Module") }
}

class submodule {
   let number: Int
   init(number: Int) { self.number = number }
   weak var topic: module?

   deinit { print("Sub Module with its topic number is \(number)") }
}

var toc: module?
var list: submodule?
toc = module(name: "ARC")
list = submodule(number: 4)
toc!.sub = list
list!.topic = toc

toc = nil
list = nil

जब हम खेल के मैदान का उपयोग करके उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्नलिखित परिणाम मिलते हैं -

ARC Is The Main Module
Sub Module with its topic number is 4

प्रसिद्ध संदर्भ कार्यक्रम

class student {
   let name: String
   var section: marks?
   init(name: String) {
      self.name = name
   }
   deinit { print("\(name)") }
}

class marks {
   let marks: Int
   unowned let stname: student
   
   init(marks: Int, stname: student) {
      self.marks = marks
      self.stname = stname
   }
   deinit { print("Marks Obtained by the student is \(marks)") }
}

var module: student?
module = student(name: "ARC")
module!.section = marks(marks: 98, stname: module!)
module = nil

जब हम खेल के मैदान का उपयोग करके उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्नलिखित परिणाम मिलते हैं -

ARC
Marks Obtained by the student is 98

क्लोजर के लिए मजबूत संदर्भ चक्र

जब हम क्लास इंस्टेंस प्रॉपर्टी और क्लोजर बॉडी को क्लोजर देते हैं तो विशेष इंस्टेंस को कैप्चर करने के लिए मजबूत रेफरेंस चक्र हो सकता है। बंद करने के लिए मजबूत संदर्भ 'self.someProperty' या 'self.someMethod ()' द्वारा परिभाषित किया गया है। मजबूत संदर्भ चक्रों को क्लोजर के लिए संदर्भ प्रकार के रूप में उपयोग किया जाता है।

class HTMLElement {
   let samplename: String
   let text: String?
   
   lazy var asHTML: () -> String = {
      if let text = self.text {
         return "<\(self.samplename)>\(text)</\(self.samplename)>"
      } else {
         return "<\(self.samplename) />"
      }
   }
   init(samplename: String, text: String? = nil) {
      self.samplename = samplename
      self.text = text
   }
   deinit {
      print("\(samplename) is being deinitialized")
   }
}

var paragraph: HTMLElement? = HTMLElement(samplename: "p", text: "Welcome to Closure SRC")
print(paragraph!.asHTML())

जब हम खेल के मैदान का उपयोग करके उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्नलिखित परिणाम मिलते हैं -

<p>Welcome to Closure SRC</p>

कमजोर और अज्ञात संदर्भ

जब क्लोजर और इंस्टेंस एक दूसरे को संदर्भित करते हैं तो उपयोगकर्ता किसी क्लोजर में कैप्चर को एक गैर-संदर्भ संदर्भ के रूप में परिभाषित कर सकता है। तब यह उपयोगकर्ता को एक ही समय में उदाहरण से निपटने की अनुमति नहीं देगा। जब उदाहरण कभी-कभी 'शून्य' मान लौटाता है, तो कमजोर उदाहरण के साथ बंद को परिभाषित करें।

class HTMLElement {
   let module: String
   let text: String?
   
   lazy var asHTML: () -> String = {
      [unowned self] in
      if let text = self.text {
         return "<\(self.module)>\(text)</\(self.module)>"
      } else {
         return "<\(self.module) />"
      }
   }
   init(module: String, text: String? = nil) {
      self.module = module
      self.text = text
   }
   deinit {
      print("\(module) the deinit()")
   }
}

var paragraph: HTMLElement? = HTMLElement(module: "Inside", text: "ARC Weak References")
print(paragraph!.asHTML())
paragraph = nil

जब हम खेल के मैदान का उपयोग करके उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्नलिखित परिणाम मिलते हैं -

<Inside>ARC Weak References</Inside>
Inside the deinit()