[Java并发与多线程]（二十）以不变应万变：final关键字和不变性

1、什么是不变性(Immutable)

如果对象在被创建后，状态就不能被修改，那么它就是不可变的。
例子：person对象，age和name都不能在变；
好处：具有不变性的对象一定是线程安全的，我们不需要对其采取任何额外的安全措施，也能保证线程安全。

public class Person {
    //一旦被赋值，就没有被更改的可能了
    final int age = 18;
    final String name = "Alice";
}

2、final的作用

早期作用：锁定、效率：早期的Java实现版本中，会将final方法转为内嵌调用；
现在作用：
a、类防止被继承、方法防止被重写、变量防止被修改；
b、天生是线程安全的，而不需要额外的同步开销；

2.1、final3种用法：修饰变量、方法、类

2.1.1 final修饰变量——三种变量

被final修饰的变量，意味着值不能被修改。如果变量是对象，那么对象的引用不能变，但是对象自身的内容依然可以变化；
a、final instance variable(类中的final属性)
第一种是在声明变量的时候直接在等号右边赋值： final int age = 18;
第二种就是在构造函数中赋值
第三就是在类的初始代码块中赋值(不常用)

public class FinalVariableDemo {
    // 类中的final属性赋值
    //1、直接赋值
    private final int a = 6;

    //2、构造函数赋值
    private final int b;

    public FinalVariableDemo(int b) {
        this.b = b;
    }

    //3、代码块赋值
    private final int c;
    {
        c = 7;
    }
}

如果不采用第一种赋值方法，那么就必须在第2、3中挑一个来赋值，而不能不赋值，这是final语法所规定的。
b、final static variable(类中的static final属性)
两个赋值时机：除了在声明变量的等号右边直接赋值外，static final变量还可以用static初始代码块赋值， 但是不能用普通的初始代码块赋值；

 //类中的static final属性
    //1、直接赋值
    private static final int d = 1;

    //2、static初始代码块赋值
    private static final int e;
    static {
        e = 1;
    }

c、final local variable(方法中的final变量)
和前面两种不同，由于这里的变量是在方法里的，所以没有构造函数，也不存在初始代码块。首先，它不规定赋值时机，只要求在使用前必须赋值，这和方法中的非final变量的要求是一样的。

//使用前赋值
    void testFinal() {
        final int f;
    }

final修饰变量：赋值时机
属性被声明为final后，该变量则只能被赋值一次，且一旦被赋值，final的变量就不能再被改变，无论如何也不会变。
为什么要规定赋值时机？
如果初始化不赋值，后续赋值，就是从Null编程你的赋值，这样就违反了final不变的原则了。

2.1.2 final修饰方法

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

引申：static方法不能被重写，但是可以在子类定义一个重名方法。这是因为static变量在创建的时候，就已经绑定了这个方法，而不是后期动态绑定的，看上去是重写了，其实不是；只是属于子类的跟父类没关系。

public class FinalMethodDemo {
    public void drink() {

    }

    public final void eat() {

    }

    public static void sleep() {

    }
}

class SubClass extends FinalMethodDemo {
    @Override
    public void drink() {
        super.drink();
    }
    public static void sleep() {

    }
}

2.1.3 final修饰类

不可被继承。
例如：典型的String类就是final的，我们从没见过哪个类是继承String类的。

2.2 注意点

final修饰对象的时候，只是对象的引用不可变，而对象本身的属性是可以变化的。

3、不变性和final的关系

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

1. 对于基本数据类型而言，确实被final修饰后就具有不变性；
2. 但是对于对象类型，需要该对象保证自身被创建后，状态永远不会变才可以；被final修饰之后仅仅代表引用不可变，而对象里面的内容是可变的；

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

1、把所有的属性都声明为final？
错误，如果有个属性是对象的话，那么即便用final修饰，它只是对象引用不可变，而对象本身还可变。

public class TestFinal {
    String test;
    public static void main(String[] args) {
        Person person = new Person();
        person.testFinal.test = "HelloWorld";
        System.out.println( person.testFinal.test);
        person.testFinal.test = "HelloWorld hi";
        System.out.println( person.testFinal.test);

    }
}

class Person {
    //一旦被赋值，就没有被更改的可能了
    final int age = 18;
    final String name = "Alice";

    final TestFinal testFinal = new TestFinal();

}

2、一个属性是对象类型的不可变对象的正确例子
总结，满足以下条件时，对象才是不可变的：
a、对象创建后，其状态就不能修改
b、所有属性都是final修饰的
c、对象创建过程中没有发生逸出

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

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

public class StackConfinement implements Runnable {
    int index = 0; //线程共享，不具备栈封闭的能力

    public void inThread() { //线程安全
        int neverGoOut = 0; //局部变量，不会有线程安全问题
        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);
    }
}

运行结果：

栈内保护的数字是线程安全的10000
栈内保护的数字是线程安全的10000
13338

5、常见问题：真假美猴王

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

        //因为一旦把b，加了final之后编译期间，我们就知道它的准确值了，而且这个b永远不会变化；
        //所以后期编译器会把它当做编译时期的常量使用，所以c就没有必要新建一个对象了，就会和a指向一样的地址

        //而d最开始是指向常量池中的悟空，而不是悟空2，而且由于d没有被final修饰，所以编译器在使用的时候
        //不会知道具体的值，所以e的值也只能在运行时确定，像这种在运行时确定的e，它会在堆上生成 悟空2，
        //所以e指向的是堆上的，而a、c指向的是常量池的
    }
}

public class FinalStringDemo2 {
    public static void main(String[] args) {
        String a = "悟空2";
        final String b = getDaShiXiong();
        String c = b + 2;
        System.out.println((a == c)); //false

        //问题在于b是通过方法得到的，编译器没办法确定b的值，编译器也没办法优化，所以c也是在运行时才生成的
    }

    private static String getDaShiXiong() {
        return "悟空";
    }
}

下一章： 第二十一章 并发容器