JUC编程之final关键字

---

1.什么是不变性

如果对象被创建后，状态就不能更改，那么就是不可变

一旦person的树形被final修饰，就不能再修改，

增加可变属性，那么是可变的；对于不可变的对象，一定是对线程安全的，不需要采取任何措施保证其线程安全

2.final的作用

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

• 注意 person指向是final的，它的引用指向不能变，但是属性可以变

3.三种用法:修饰变量方法类

3.1final修饰变量

3.1.1 类的final属性

package immutable;

/**
 * 描述：     演示final变量
 */
public class FinalVariableDemo {
    
    

    private static final Person person = null;

//    void testFinal() {
    
    
//       final int b = 7;
//        int c =b;
//    }
//    public FinalVariableDemo() {
    
    
//    }
//    public FinalVariableDemo(int a) {
    
    
        this.a = a;
    }
//
//    static {
    
    
//        a = 7;
//    }
}

3.1.2类中static final属性

3.1.3 方法中final变量

3.2 final修饰方法

• 不允许修饰构造方法
• 不能被重写

引申:静态方法不能被重写

3.3 final修饰类

• final修饰类不能被继承（String）

4. 面试题

package immutable;

/**
 * 描述：     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));
        System.out.println((a == e));
    }
}

运行结果

5.不变性和final关系(栈封闭)

5.1 不可变性

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

5.2 栈封闭

代码演示:

package immutable;

/**
 * 描述：     演示栈封闭的两种情况，基本变量和对象 先演示线程争抢带来错误结果，然后把变量放到方法内，情况就变了
 */
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);
    }
}