Java基础-1、基础语法

1、static、final、transient关键字的作用

• static关键字：1、修饰静态包 2、修饰变量 3、修饰静态块 4、修饰内部类

• final关键字：1、修饰变量 2、修饰方法 3、修饰类，不能被继承

public class FinalTest {
    public final int i = 1; //修饰变量
    
    public final void test() { //修饰方法
        
    }
    static final class InnerClass{ //修饰类，不能被继承
        
    }
}

• transient关键字：修饰变量

描述：

    1、当对象序列化时，transient阻止实例中那些用此关键字的声明的变量
    2、当反序列化时，这样的实例变量值不会被持久化和恢复
    例如，当反序列化对象——数据流（例如，文件）可能不存在时，原因是你的对象中存在类型为java.io.InputStream的变量，序列化时这些变量引用的输入流无法被打开。

代码：

public class TransientTest implements Serializable{  
    private static final long serialVersionUID = 1L;

    private transient InputStream is; //修饰变量

    private int majorVer;
    private int minorVer;
    TransientTest(InputStream is) throws IOException{
        System.out.println("TransientTest(InputStream) called");
        this.is = is;
        DataInputStream dis;
        if (is instanceof DataInputStream) {
            dis = (DataInputStream) is;
        }else {
            dis = new DataInputStream(is);
        }
        if (dis.readInt() != 0xcafebabe) {
            throw new IOException("not a .class file");
        }
        majorVer = dis.readShort();
        minorVer = dis.readShort();
    }
    public int getMajorVer() {
        return majorVer;
    }
    public int getMinorVer() {
        return minorVer;
    }

    void showIS(){
        System.out.println(is);
    }
}

2、volatile关键字的底层实现原理

volatile：用来修饰被不同线程访问和修改的变量

              volatile关键字与JVM内存模型相关

              Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了同步块和volatile关键字机制

volatile关键字机制：

               synchronized修饰方法和代码块，以实现同步

               用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的值。volatile经常被误用进行原子性的操作。但是这些操作并不是真正的原子性。在读取加载之后，如果变量发生了变化，线程工作内存中的值由于已加载，不会产生对应的变法。对于volatile修改的变量，JVM只是保证从内存加载到线程工作内存的值是最新的。

             交互图：

代码：

public class VolatileTest {
    //public static int count = 0; //实际运算每次结果都不一样
    public static volatile int count = 0; //
    public static void inc(){
        //这里延迟1毫秒，使得结果明显
        try {
            Thread.sleep(1);
        } catch (Exception e) {
            // TODO: handle exception
        }
        count ++;
    }
    
    public static void main(String[] args) {
        //同时启动1000个线程，去进行i++运算，看看实际结果
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                
                @Override
                public void run() {
                    VolatileTest.inc();
                }
            }).start();
        }
        
        System.out.println("运行结果:"+count);
    }

}