不变性(Immutable)

 如果对象在被创建后，状态就不能被修改，那么它就是不可变的。
 具有不变性的对象一定是线程安全的，我们不需要对其采取任何二外的安全措施，也能保证线程安全。

示例：person 对象，age、name 都不能再变。

/**
 * 描述：     不可变的对象，演示其他类无法修改这个对象，public也不行
 */
public class Person {

    final int age = 18;
      String alice = new String("Alice");//这样就破坏了不可变性
    final String name = alice;
    final TestFinal testFinal = new TestFinal();

    public static void main(String[] args) {
        Person person = new Person();
        person.alice = "44";
        System.out.println(person.name);
    }
}

final 的作用

• 类防止被继承，方法防止被重写，变量防止被修改
• 天生是线程安全的，而不需要额外的开销

final 修饰变量：赋值时机

 属性被声明为 final 后，该变量则只能被赋值一次。且一旦被赋值，final 的变量就不能再被改变，无论如何也不会变。

3 种用法：修饰变量、方法、类

 被 final 修饰的变量，意味着值不能被修改。如果变量是对象，那么对象的引用不能变，但是对象自身的内容依然可以变化。
 final 使用原则：良好的变成习惯

final 修饰： 3 种变量

final instance variable (类中的final属性)

* 在声明变量的等号右边直接赋值
* 在构构造函数中赋值
* 在类的初始化代码块中赋值（不常用）

* 如果不采用第一种，那么就必须在第二种或者第三种中选择一种方式来赋值，不可以不赋值。

final static variable（类中的static final属性）

* 声明变量的等号右边直接赋值
* static 初始代码块赋值

final local variable（方法中的final变量）

* 不规定赋值时机，只要求在使用前必须赋值，这和方法中的非 final 变量的要求也是一样的。

final 修饰方法

* 构造方法不允许 final 修饰
* 不可被重写，也就是不能被 overrride，即便是子类有同样名字的方法，那也不是 override，这个和 static 方法不能被重写是一个道理。

final 修饰类

 不可被继承。

不变性和 final 的关系

• 不变性并不是意味着，简单地用 final 修饰就是不可变。

* 对于基本数据类型，确实被 final 修饰后就具有不变性
* 对于引用类型，需要对象保证滋生被创建后，状态永远不会变才可以

• 如何利用 final 实现对象不可变

* 把所有属性都声明为 final ? 但是属性中也会存在引用类型属性，那么就会一直嵌套下去，还是无法保证不可变性。
* 但是可以利用私有化对象，让对象无法在类外修改。

/**
 * 描述：     一个属性是对象，但是整体不可变，其他类无法修改set里面的数据
 */
public class ImmutableDemo {

    private final Set<String> students = new HashSet<>();

    public ImmutableDemo() {
        students.add("李小美");
        students.add("王壮");
        students.add("徐福记");
    }

    public boolean isStudent(String name) {
        return students.contains(name);
    }
}

不可变性

• 对象创建后，其状态就不能被修改
• 所有属性都是 final 修饰的
• 对象创建过程中没有发生逸出

把变量写在线程内部 —— 栈封闭

• 在方法里新建的局部变量，实际上存储在每个线程私有的栈空间，而每个栈的占空间是不能被其他线程所访问到的，所以不会有线程安全问题，这就是著名的“栈封闭”技术，是“线程封闭”技术的一种情况。

/**
 * 描述：     演示栈封闭的两种情况，基本变量和对象 先演示线程争抢带来错误结果，然后把变量放到方法内，情况就变了
 */
public class StackConfinement implements Runnable {

    int index = 0;

    public void inThread() {
        int neverGoOut = 0; // 栈封闭
        synchronized (this) {
            for (int i = 0; i < 10000; i++) {
                neverGoOut++;
            }
        }

        System.out.println("栈内保护的数字是线程安全的：" + neverGoOut);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            index++;
        }
        inThread();
    }

    public static void main(String[] args) throws InterruptedException {
        StackConfinement r1 = new StackConfinement();
        Thread thread1 = new Thread(r1);
        Thread thread2 = new Thread(r1);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(r1.index);
    }
}

总结

1、final 修饰变量并且赋值时初始化，编译时可以确定，相当于 C 语言中的宏。

/**
 * 描述：     TODO
 */
public class FinalStringDemo1 {

    public static void main(String[] args) {
        String a = "wukong2";
        final String b = "wukong";
        String d = "wukong";
        String c = b + 2; //常量池(编译时可以确定)
        String e = d + 2; //堆
        System.out.println((a == c)); //true
        System.out.println((a == e)); //false
    }
}

2、方法复制运行时才能确定，编译时不能确定

public class FinalStringDemo2 {

    public static void main(String[] args) {
        String a = "wukong2";
        final String b = getDashixiong();//运行时生成
        String c = b + 2;
        System.out.println(a == c);//false

    }

    private static String getDashixiong() {
        return "wukong";
    }
}