”;
Automatic Reference Counting in Swift
Automatic Reference Counting(ARC) is a memory management mechanism used by Swift, it automatically tracks and manages the allocation and deallocation of objects’s memory. Or we can say that it is used to initialize and deinitialize the system resources thereby releasing memory spaces used by the class instances when the instances are no longer needed. It keeps track of information about the relationships between the instances to manage the memory resources effectively. ARC is generally applicable only to instances of classes because they are reference types.
Working of ARC
-
ARC allocates a chunk of memory to store the information whenever a new class instance is created by init().
-
Information about the instance type and its values are stored in the memory.
-
When the class instance is no longer needed it automatically frees the memory space by deinit() for further class instance storage and retrieval.
-
ARC keeps in track of currently referring class instances properties, constants and variables so that deinit() is applied only to those unused instances.
-
ARC maintains a ”strong reference” to those class instance properties, constants and variables to restrict deallocation when the class instance is currently in use.
Example
Swift program to demonstrate ARC.
class StudDetails {
// Properties
var stname: String
var mark: Int
// Initializer to initialize instances of the class
init(stname: String, mark: Int) {
self.stname = stname
self.mark = mark
}
// Deinitializer to deinitialize the instances of
// the class when they are no longer required
deinit {
print("Deinitialized (self.stname)")
print("Deinitialized (self.mark)")
}
}
// Creating class instance
var obj1 = StudDetails( stname:"Swift", mark:98)
// Creating another class instance
var obj2: StudDetails? = StudDetails(stname: "iOS", mark: 95)
// Setting anotherObj to nil to deallocate the memory
obj2 = nil
Output
It will produce the following output −
Deinitialized iOS Deinitialized 95
Strong Reference Cycles Between Class Instances in Swift
ARC is used to automatically manage memory by keeping track of object references. However, there is a challenge faced by the developers which is the creation of a strong reference cycle, where two or more objects have strong references to each other which prevents their reference counts from reaching zero and due to this a memory leakage happens.
Example
Swift program to demonstrate strong reference cycles between class instances in Swift.
class studmarks {
let name: String
var stud: student?
// Initializer
init (name: String) {
print("Initializing: (name)")
self.name = name
}
// Deinitializer
deinit {
print("Deallocating: (self.name)")
}
}
class student {
let name: String
var strname: studmarks?
// Initializer
init (name: String) {
print("Initializing: (name)")
self.name = name
}
// Deinitializer
deinit {
print("Deallocating: (self.name)")
}
}
// Declare optional variables for instances
var shiba: studmarks?
var mari: student?
shiba = studmarks(name: "Swift 4")
mari = student(name: "ARC")
// Create a strong reference cycle by assigning references to each other
shiba!.stud = mari
mari!.strname = shiba
Output
It will produce the following output −
Initializing: Swift 4 Initializing: ARC
To resolve strong reference cycles Swift provides Weak and Unowned References. These references are used to enable one instance to refer to other instances in a reference cycle. Then the instances may refer to every instance instead of caring about a strong reference cycle.
Weak References
It is an optional reference to an object that does not keep a strong hold on the object. It will return nil when the object it refers to is deallocated. It is generally used where the referenced object’s lifecycle is not guaranteed to outlive the referencing object. It is commonly used for relationships where the referenced object can deallocate independently. We can declare weak references using the weak Keyword.
Syntax
Following is the syntax for weak reference −
class Class1 {
var name: Name?
}
class Name {
weak var teacher: Class1?
}
Example
Swift program to demonstrate weak references.
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
Output
It will produce the following output −
ARC Is The Main Module Sub Module with its topic number is 4
Unowned References
It is a non-optional reference to an object that does not keep a strong hold on the object as compared to a weak reference. It assumed that the reference object will never become nil, while the reference object is still alive. It is generally used where you know that the referenced object’s life is guaranteed to be at least as long as the referencing object’s lifetime. It is commonly used for relationships where the referenced object has the same or longer lifetime as compared to the referencing object. We can declare unowned references using the unowned Keyword.
Syntax
Following is the syntax for unowned reference −
class Class1 {
var name: Name?
}
class Name {
unowned var teacher: Class1
}
Example
Swift program to demonstrate Unowned references.
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
Output
It will produce the following output −
ARC Marks Obtained by the student is 98
Strong Reference Cycles for Closures
When we assign a closure to the class instance property and to the body of the closure to capture particular instance strong reference cycle can occur. Strong reference to the closure is defined by ”self.someProperty” or ”self.someMethod()”. Strong reference cycles are used as reference types for the closures.
Example
Swift program to demonstrate Strong Reference Cycles for Closures.
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())
Output
It will produce the following output −
<p>Welcome to Closure SRC</p>
Resolving Strong Reference Cycles for Closures
We can resolve the strong reference cycles for closures using Weak and Unowned References. When the closure and the instance refer to each other the user may define the capture in a closure as an unowned reference. Then it would not allow the user to deallocate the instance at the same time. When the instance sometimes returns a ”nil” value define that closure with the weak instance.
Example
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
Output
It will produce the following output −
<Inside>ARC Weak References</Inside> Inside the deinit()
”;