Bạn đã thực sự hiểu mutable và immutable?

Link gốc bài viết ở đây

Bạn đã từng đọc hay nghe đâu đó nói rằng: mutable là giá trị có thể thay đổi được còn immutable là giá trị không thể thay đổi được. Nhưng bạn đã thực sự hiểu đúng nó chưa?

>> test = 3
# => 3

>> test
# => 3

>> test = 2 * test
# => 6

>> test
# => 6

Bạn nghĩ đoạn code trên(trong ruby) chứng tỏ biến test có phải là mutable không?

Trong ruby, kiểu number và boolean luôn là immutable

Rõ ràng trong ruby, kiểu number luôn là immutable nhưng ta vẫn thấy test ở ví dụ trên có thể thay đổi được. Lý do là vì bạn đã hiểu sai từ giá trị trong định nghĩa.

Để hiểu đúng bạn cần biết được cách bộ nhớ lưu trữ một biến như thế nào.

Nguyên lý 2 Von Neumann: Chương trình máy tính chỉ truy cập tới dữ liệu thông qua địa chỉ.

Bộ nhớ chương trình gồm có 2 thành phần là địa chỉ bộ nhớ và dữ liệu được lưu trữ trong bộ nhớ đó.

Khi có một phép toán như phép gán test = 3, rõ ràng bộ nhớ cần lưu trữ chữ test và giá trị 3 của nó vào bộ nhớ:

Cần lưu trữ một thứ gì đó trong bộ nhớ để gán test = 3, giả sử ví dụ đơn giản bộ nhớ làm như sau để lưu trữ phép gán đó:

Thế khi nào thì phép toán test = test * 2 được xem là mutable, khi nào thì được xem là immutable?

Phép toán trên được xem là mutable khi bộ nhớ thành như sau:

Phép toán trên được xem là immutable khi bộ nhớ thành như sau:

Như bạn thấy, khi giá trị của biến không bị ghi đè mà được copy sang một nơi khác thì đó mới là immutable , từ giá trị ở định nghĩa này chính là giá trị đi với ô nhớ.

Vì sao phải copy sang một ô nhớ khác như thế? Nếu chỉ có một biến tham chiếu tới một ô nhớ thì không có gì đáng nói nhưng khi bạn có nhiều biến tham chiếu tới cùng một ô nhớ thì khi thay đổi giá trị của một biến thì giá trị của các biến kia cũng đều thay đổi theo tương ứng(Xem ví dụ ở phía dưới).

Còn nếu xxx2 không còn được dùng trong immutable sẽ đi về đâu? Trong ruby có chương trình dọn rác Garbage Collection sẽ tự động xóa biến này đi khi nó đi thu dọn bộ nhớ.

Giờ bạn có thể hiểu đoạn code ruby ở phần mở đầu rồi, nếu không tin bạn có thể in ra object_id của nó để xác thực:

>> test = 3
# => 3

>> test
# => 3
>> test.object_id
# => 7

>> test = 2 * test
# => 6

>> test
# => 6
>> test.object_id
# => 13

Thế vì sao lại phải cần tới immutable để làm gì khi nó giảm công suất của bộ nhớ đi như thế? Xem phần dưới.

Khi nào nên dùng mutable

Khi cần thay đổi một biến trong vòng lặp thì bạn nên dùng mutable

Nếu lặp n phần tử mà ta dùng immutable như sau:

String s = "";
for (int i = 0; i < n; ++i) {
    s = s + n;
}

Trong java, kiểu String là immutable. Đoạn code trên cứ mỗi lần gán s = s + n là phải copy biến s cũ thành object khác rồi mới gán vào s mới được. Cứ mỗi lần copy s cũ là phải lặp số ký tự có trong s cũ để copy, dẫn tới thời gian tính toán của thuật toán là O(n²).

Ta có thể cải thiện thuật toán trên bằng cách sử dụng mutable:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
  sb.append(String.valueOf(n));
}

String s = sb.toString();

Khi nào nên dùng immutable

Trong đa số các trường hợp, bạn nên dùng immutable vì immutable dễ hiểu và không xảy ra bug liên quan tới reference còn mutable khiến cho code không tuân theo luồng suy nghĩ của lập trình viên, khó đọc, dễ gây bug khó chịu liên quan tới reference.

VD1 gây bug:

/** @return the sum of the numbers in the list */
public static int sum(List<Integer> list) {
    int sum = 0;
    for (int x : list)
        sum += x;
    return sum;
}

/** @return the sum of the absolute values of the numbers in the list */
public static int sumAbsolute(List<Integer> list) {
    // let's reuse sum(), because DRY, so first we take absolute values
    for (int i = 0; i < list.size(); ++i)
        list.set(i, Math.abs(list.get(i)));
    return sum(list);
}


// meanwhile, somewhere else in the code...
public static void main(String[] args) {
    // ...
    List<Integer> myData = Arrays.asList(-5, -3, -2);
    System.out.println(sumAbsolute(myData));
    System.out.println(sum(myData));
}

• Hàm sum tính tổng các phần tử của list truyền vào
• Hàm sumAbsolute tính tổng giá trị tuyệt đối của mỗi phần tử của list truyền vào. Vì không muốn tạo một mảng tạm trong hàm này nên lập trình viên đã dùng lại luôn list truyền vào để đỡ tốn bộ nhớ và hiệu năng.

Vấn để xảy ra khi ai đó gọi hàm sumAbsolute(myData) với mảng bất kỳ myData rồi gọi tiếp sum(myData), khi gọi sumAbsolute(myData) thì hàm này đã làm mảng myData bị thay đổi nên hàm sum(myData) không còn gọi đúng với myData ban đầu như dự kiến nữa.

VD2 gây bug:

private static Date startSpringDate = null;

/** @return the first day of spring this year */
public static Date startOfSpring() {
    if (startSpringDate == null) startSpringDate = getStartOfSpring();
    return startSpringDate;
}


// somewhere else in the code...
public static void partyPlanning() {
    // let's have a party one month after spring starts!
    Date partyDate = startOfSpring();
    partyDate.setMonth(partyDate.getMonth() + 1);
}

• Kiểu Date trong java là mutable.
• Hàm startOfSpring() để lấy ngày đầu tiên của mùa xuân, vì hàm getStartOfSpring() phía trong có xử lý rất phức tạp và tốn thời gian nên lập trình viên đã gán một biến global startSpringDate để lưu giá trị của startOfSpring() vào giúp khỏi phải gọi lại khi cần thiết.

Vấn đề xảy ra khi một lập trình viên nào đó muốn lấy ngày đầu tiên của mùa xuân và cộng thêm 1 tháng nữa như đoạn code trên. Vì startSpringDate và partyDate lúc này đang cùng trỏ đến một giá trị và kiểu Date trong java là mutable nên khi gọi hàm partyDate.setMonth(... thì vô tình chung họ đã làm biến startSpringDate bị thay đổi, thiết kế ban đầu nhằm mục đích biến này không bị thay đổi nên nó gây ra bug.

Link tham khảo:
https://launchschool.com/blog/references-and-mutability-in-ruby
https://en.wikipedia.org/wiki/Variable_(computer_science)
http://web.mit.edu/6.005/www/fa15/classes/09-immutability/