再次认识下final关键字和不变性

快速到达看这里-->

什么是不变性
final的作用
final的三种用法
注意点
不变性与final的关系
栈封闭技术
面试题

什么是不变性

如果对象被创建后，状态就不能被修改了，那么它就是不可变的
如：person对象的birthday和sex被设置成final的，那么一旦创建了就不可变的

public class Persion {
    private final Date birthday = new Date();
    private final int sex = 0;
}

具有不变性的对象一定是线程安全的

final的作用

类防止被继承
方法防止被重写
变量防止被篡改
为了保证线程安全且不使用额外同步开销

final的三种用法

final修饰变量

含义：被final修饰的变量，意味着值不能被修改，如果变量是对象，那么对象的引用不能变，但是对象自身的内容依然可以变化

虽然person被设置为final的变量，但是person对象的值依然是可以修改的

public static void main(String[] args) {
        final Persion persion = new Persion();
        persion.setName("mary");
       
}

赋值时机

类中的final属性
- 声明变量时直接在等号右边赋值private final int a = 123;
- 构造函数中赋值
- 类的初始化代码块中赋值

			//构造函数中赋值
			private final String name ;
			public Persion(String name) {
			    this.name = name;
			}
---------------------------------------------------------------------
			//类的初始化代码块中赋值
			private final String name ;
		    {
		        name = "tom";
		    }

类中的static final属性
- 声明变量时直接在等号右边赋值private static final int a = 123;
- static代码块赋值

			private static final String name ;
		    static {
		        name = "tom";
		    }

方法中的final变量
- 不要求赋值时机，但是使用前必须赋值，和非final变量一致

final修饰方法

构造方法不允许final修饰
修饰的方法不可被重写，即使子类有同样名称的方法，也不是重写（和静态方法一致）

final修饰类

不可被继承
典型案例：String类

注意点

final修饰对象，只是对象的引用不可变，对象的属性是可以变化的
明确知道一个类创建后不会被变化，最好加一个final，提高代码可读性

不变性与final的关系

并不是意味着简单的用final修饰就是不变性

对于基本数据类型，被final修饰后就具有不可变性
对于对象类型
- 需要保证对象自身被创建后，状态永远不会变。
- 所有属性都是final修饰的
- 对象创建过程没有发生溢出

栈封闭技术

在方法里新建的局部变量，实际上是存储在每个线程的私有栈空间，而每个栈的栈空间是不会被其他线程访问到的，所以不会有线程安全问题

实现一个runnable接口，在run方法中累加10000次，再调用一个拥有局部变量的方法，方法内同样实现累加10000次
创建两个线程使用上面创建的实现类

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

打印结果如图

栈内保护的数据是线程安全的：10000
栈内保护的数据是线程安全的：10000
15033

受栈空间保护的数据是线程安全的，而没有被保护的数据是存在线程安全的（15033<20000）

面试题

推测下面一段代码的运行结果：

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

运行结果为：

true
false

分析：

对于c：其中b是被final修饰的，所以在编译期间就知道b的准确值了，所以c ="test"+2,而编译器会把"test"+2自动优化成"test2"，将"test2"赋值给c时，首先会查询常量池是否存在"test2"，因为对a赋值的时候已经在常量池创建了"test2"，所以就直接将"test2"的引用指向c，所以a == c
对于e：其中d指向常量池中的"test",在编译期并不知道其具体的值，所以需要在运行时才知道具体的值，对于运行期才知道值的情况，JVM会调用new String(e),e的值将在堆上被创建，而a在常量池，所以a != e