Java并发编程 final关键字和不变性

1. 什么是不变性（Immutable）

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

2. final的作用

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

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

3.1 final修饰变量

属性被声明为final后，该变量则只能被赋值一次。且一旦被赋值，final的变量就不能再被改变，无论如何也不会变。
被final修饰的变量，意味着值不能被修改。如果变量是对象，那么对象的引用不能变，但是对象自身的内容依然可以变化。

public class Person {
    String name = "lili";
}

image.png

• final instance variable（类中的final属性）

第1种是在声明变量的等号右边直接赋值
第2种就是构造函数中赋值
第3种就是在类的初始代码块中赋值
如果不采用第一种赋值方法，那么就必须在第2、3种挑一个来赋值，而不能不赋值，这是final语法所规定的。

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

第1种是在声明变量的等号右边直接赋值
第2种就是在类的初始代码块中赋值

private static final int a = 12;

    private static final int a ;
    static {
        a = 7;
    }

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

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

为什么要规定赋值时机

如果初始化不赋值，后续赋值，就是从null变成你的赋值，这是违反final不变的原则了。

3.2 final修饰方法

• 构造方法不允许final修饰

• 不可被重写，也就是不能被override，即便是子类有同样名字的方法，那也不是override

  
  image.png
  

  static的方法是和该类绑定的，可以相同方法,但是不能重写override父类static方法

3.3 final修饰方法

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

4.注意点

• final修饰对象的时候，只是对象的引用不可变，而对象本身的属性是可以变化的。
• final使用原则：良好的编程习惯

5.不变性和final的关系

• 不变性并不意味着，简单地用final修饰就是不可变
  1.对于基本数据类型，确实被final修饰后就具有不变性
  2.对于对象类型，需要该对象保证自身被创建后，状态永远不会变才可以

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

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

public class ImmutableDemo {

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

    public ImmutableDemo() {
        students.add("Jach");
        students.add("Lisi");
        students.add("Wangyi");
    }

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

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

public class StackConfinement implements Runnable {

    int index = 0;

    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);
    }

    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();
    }
}

6.面试题

    public static void main(String[] args) {
        String a = "kpioneer2";
        final String b = "kpioneer";
        String d = "kpioneer";
        String c = b + 2;
        String e = d + 2;
        System.out.println((a == c));
        System.out.println((a == e));
    }

true
false

对于字符串：其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。

因为c的值在常量池中，e的值在堆中

    public static void main(String[] args) {
        String a = "kpioneer2";
        final String b = getDashixiong();
        String c = b + 2;
        System.out.println(a == c);

    }

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

false

getDashixiong是一个不可预料的部分，编译器不会优化，必须等到运行时才可以确定结果,c 分配到堆中