Functional programming, by its nature, is thread safe; immutability has a great role in making it thread safe. If you go by the dictionary definition, immutability means that something is unchangeable. So, as per the dictionary, an immutable variable is a variable that cannot change. Now, how can that be of any help to thread safety?

The following example shows a simple class, with no extra protective measures for thread safety:

class MutableObject { 
    var mutableProperty:Int = 1 
} 

Just think of a situation when you're calling this class from multiple threads at the same time. There is no guarantee of integrity in this, right?

Now, imagine making mutableProperty immutable; the problem is partly solved, right?

However, if you think of immutability as creating a class and making all its variables read-only, then such a simplified explanation would not only be wrong, but would also be horrible. Actually, immutability is not about forbidding change, but about handling change. Instead of changing the underlying value of a property directly, create a new property and copy the value with applied changes. This applies to things such as the primitive data types in Kotlin and Java (or even in C). For instance, in the following example, when we're writing var y = x.capitalize(), the value of x remains unchanged, instead the x value is copied to y with applied changes:

fun main(args: Array<String>) { 
    var x:String = "abc" 
    var y = x.capitalize() 
    println("x = $x, y = $y") 
} 

Most of the primitive types operate in the same way; that is what is called immutability. Now, let's see how can we implement immutability in Kotlin and then, we will have a look at its advantages and disadvantages.