Java基礎-1、基礎語法

1、static、final、transient關鍵字的作用

• static關鍵字：1、修飾靜態包 2、修飾變量 3、修飾靜態塊 4、修飾內部類

import static java.lang.System.out; //靜態導包
public class StaticTest {
    public static int count; //修飾變量
    static { //修飾靜態塊
        count ++;
    }
    
    static class InnerClass{//修飾內部類
        
    }
}

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

}