JAVA基础-java关键字

1 volatile

volatile是java提供的一种轻量级的同步机制，与synchronize(重量级锁)相比，volatile更轻量级。多线程编程中，线程相互是不可见，也就是说，线程B无法检测到共享对象是否被其他线程进行过修改。可见性指的是当一条线程修改了共享变量的值，新值对于其他线程来说是可以立即得知的。

出现这种状况的原因

1.java内存模型(JMM)
JAVA虚拟机拥有自己的内存模型，它可以屏蔽掉各种硬件和操作系统的内存访问差异，以实现让java程序在各种平台下都可以达到一致的内存访问效果。JMM决定了一个线程对共享变量的写入操作何时对另一个线程可见。

JMM定义了线程和主内存之间的抽象关系：(只为理解，主内存、本地内存并非真实存在)

共享变量存储在主内存中，每一个线程都有一个私有的本地内存，本地内存保存了被该线程使用到的主内存的副本
拷贝。线程对变量的操作都必须在工作内存(也就是私有的本地内存)中进行，而不是直接去读写主内存中的变量。

基于此种操作方式，A/B两个线程同时操作一个变量时，各自有一个特私有的本地内存，在本地内存中进行对变量的操作。只有当A线程操作完变量，然后将变量值重新写入到主内存中时，才不会发生线程安全问题。

volatile有两种特性：
  1.保证了共享变量对所有线程的可见性。
  2.禁止指令重排序
  2.对一个变量volatile声明会有以下效应：
        ①当对一个volatile变量进行写入操作时，JMM会把该线程对应的本地内存中的变量强制刷新到主内存中去
        ②这个写入操作会导致其他线程的本地内存中的缓存失效

但是volatile并不能代替synchronize，volatile主要使用于进行原子性操作。比如num++就属于是复合操作，包含读取、加一、赋值三个操作。所以在多线程环境下，有可能线程A将num读取到本地内存的过程中，其他线程可能已经将num增大很多，此时线程A既然在对之前过期的num进行操作，重新写入内存，最终导致了线程安全问题。

针对这种非原子操作，可以使用java并发包中的院子操作类，其实通过循环CAS的方式保证其原子性。

重排序是指编译器和处理器为了优化程序的性能而对指令序列进行排序的一种手段，但是也会遵循移动端额规则
    1.不会对存在数据依赖关系的操作进行重排序
        比如  a=1   b=a   这个指令序列，由于第二个操作依赖于第一个操作，所以不会对其进行重排序
    2.不管怎么排序，单线程下程序执行的结果不能改变。
        比如  a=1 b=1  c=a+b   这个指令序列，由于前两个不存在依赖关系，所以可能会进行重排序，但是第三个不会被重排序

重排序在单线程下可以保证最终结果的准确性，但是在多线程的情况下，就不可保证了

public class TestVolatile {
    int a = 1;
    boolean status = false;

    /**
     * 状态切换为true
     */
    public void changeStatus(){
        a = 2;//1
        status = true;//2
    }

    /**
     * 若状态为true，则running。
     */
    public void run(){
        if(status){//3
            int b = a+1;//4
            System.out.println(b);
        }
    }
}

在上面的代码中，1 2 可能会发生重排序，也就是说，可能会先执行status=true，再执行a=2。此时如果B线程的到执行权限，在a=2这个未执行前执行b=a+1操作，可能得到的结果是2

使用volatile关键字可以禁止重排序，volatile修饰共享变量，在编译时会在指令序列中插入内存屏障防止进行重排序操作。

  重排序规则
　　1.当第二个操作是voaltile写时，无论第一个操作是什么，都不能进行重排序

　　2.当地一个操作是volatile读时，不管第二个操作是什么，都不能进行重排序

　　3.当第一个操作是volatile写时，第二个操作是volatile读时，不能进行重排序

总结

volatile是一个轻量级同步机制，它主要有两个特性，保证共享变量对所有线程的可见性、禁止指令重排序

volatile对于单个的共享变量的读写具有原子性，复合操作volatile无法保证其原子性。

2 原子类的操作原理 ！！！！！！

针对复合操作会在并发情况下发生问题。一般的解决方式有乐观锁和悲观锁两种方式。
乐观锁：
    每一次都会任务有其他的线程对数据进行了更改，所以直接加锁，将复合操作进行同步，但是这样会造成很大的性能开销。
悲观锁：
    就是每次操作都认为没有别的线程对数据进行过修改。如果自己修改的时候发现跟预想中的数据不同，则进行反复重试。
    
原子类的实现机制：
    先获取当前的value值，对value值加1，调用compareAndSet方法进行原子更新操作。
    
    先检查当前value是否等于current，如果相等，则意味着value没有被其他线程进行修改，更新并返回true，如果不相等，则返回false，然后循环继续尝试更新

3 synchronize的实现原理

4 lock的实现原理

5 static关键字

1.修饰变量
    静态变量与非静态变量的区别是 静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当累在初次加载的时候被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，每个对象拥有的副本，互不影响。static修饰的变量初始化的顺序按照定义的顺序进行初始化。
2.修饰方法
    不依赖任何对象，直接可以使用类名进行调用。在静态方法中不能访问类中的非静态成员变量和费静态成员方法，因为非静态成员变量和费静态成员方法都是依赖于具体的对象，也就是说只能通过具体的对象去调用。但是非静态方法可以访问静态成员变量和静态成员方法。最常见的静态方法main方法，因为在运行main方法之前，是没有任何对象被实例化的，所以只能通过类名来访问。
3.静态代码块
    static修饰的代码块。主要用于初始化类，为类的属性初始化。每个静态代码块只会在类加载的时候执行一次，存储到静态代码区（方法区）。也就是说静态代码块会在jvm加载类的时候进项执行，所以静态代码块在主方法执行之前进行执行。如果类中包含多个静态代码块，则按照定义顺序进行执行。
    静态代码块不能存在于任何方法体内。同时，静态代码块不能直接访问静态实例变量和实例方法。
    静态代码块是自动执行的，但是静态方法是需要调用才可以进行执行的。静态方法不能使用this，super等关键字，因为静态方法在使用前不需要创建实力对象。this代表的是调用该方法的对象，所以使用this的前提是存在实力对象。
    创建子类对象时执行先后顺序：
        父类的静态代码块->子类代码块->父类代码块->父类构造方法->子类代码块->子类构造方法。
4.静态内部类
    静态内部类，定义在类中，方法外。静态内部类只能访问外部类的静态成员。
    生成一个静态内部类对象，不需要创建外部类成员：这是静态内部类和普通内部类的区别。
    非静态内部类，在定义成员变量或方法的时候是不能定义为静态成员的。也就是说在非静态内部类中不可存在静态成员
    非静态内部类，可以随意访问其自身的外部类的成员变量和方法。但是静态内部类只能访问其外部类的静态成员。
    非静态内部类创建对象必须绑定外部类的实例，但是静态内部类只需要new Outer.Inner()
    静态内部类是为了降低包的深度，不会依赖于外部类，一般是为了方便类结构的管理而定义的。
    内部类存在的意义，可以理解成内部类的存在只跟外部类进行关联，没有必要设计成单独的文件，同时也防止与其他类产生依赖关联关系。
5.静态导包
    import static com.cjb.Common.*;
    主要是为了减少代码的重复性。
    静态导入一般不要使用哪个通配符*，除非是导入静态常量类(只包含常量的类或接口)。
    方法名觉有明确清晰表象意义。
    当静态导入的方法跟该类本身的方法重名时，会调用本类中的方法。

6 final关键字

修饰的类不可被继承
修饰的方法不能被重写
    方法可以被子类继承得到，但是不能进行重写
修饰的变量不可被改变
    基本数据类型是不可改变其值得，但是引用数据类型包括数组，不可改变的是对象的引用，对象内部的属性内容是可以改变的。
    类中有一个属性是final Person p=new Person("name")；那么你不能对p进行重新赋值，但是可以改变p里面属性的值，p.setName('newName');

final修饰方法中的参数时，会保证这个参数不会在方法体内被重新定义。但是其属性的值是可以在方法中进行改变的。 
匿名函数中定义或者引用的局部变量都必须声明为final
byte b1=1;
byte b2=3;
byte b3=b1+b2;//当程序执行到这一行的时候会出错，因为b1、b2可以自动转换成int类型的变量，运算时java虚拟机对它进行了转换，结果导致把一个int赋值给byte-----出错
如果对b1 b2加上final就不会出错
final byte b1=1;
final byte b2=3;
byte b3=b1+b2; //防止程序对其进行类型转换   

7 transient关键字

Java中一个类只要实现了serilizable接口，这个类的所有属性和方法都会被序列化。但是加上transient修饰之后，属性是可以不参加序列化的。因为一些敏感信息，我们不想让他在网络中进行传输。transient修饰的属性，在序列化对象的时候，是不会序列化到指定的目的地的。
1.一旦被transient修饰，变量将不再是对象持久化的一部分。该变量内容在序列化后无法获得访问。
2.transient关键字只能修饰变量，不能修饰方法和类。本地变量不可被transient关键字修饰。变量如果是用户自定义变量免责该类需要实现serializable接口。
3.一个静态变量，是否被transient修饰，都不会被序列化。
java中对象的序列化有两种方式，如果实现serializable接口，所有的序列化都会自动进行。如果实现的是externalizable接口，则没有任何成员可以自动序列化。需要在writeExternal方法中进行手工指定所要序列化的变量，这与是否是transient修饰无关。

8 this

1.调用本类中的其他方法
2.调用本类中的其他属性，也就是类的成员变量
3.调用本类中的其他构造方法
this代表的是当前对象，调用当前方法的对象

8 forEach的原理

9 类中的属性的加载流程

要想加载子类，必须先去加载父类，即便是子类中也存在静态代码块静态方法，那也需要先去加载父类中的静态代码块，如果父类中有的话。父类中的静态代码块加载完之后，回头加载子类的静态代码块，然后执行子类的构造器，但是子类构造器的首行默认有一个super()，所以需要先去加载父类的构造器，然后再回头执行子类的构造器。

类加载步骤：
    装载：查找和导入类或接口的二进制数据文件
    链接：包含校验，准备和解析三个步骤
        校验：检查导入类或接口的二进制数据的正确性
        准备：给类的静态变量分配并初始化内存空间
        解析：将符号引用转成直接引用
    初始化：激活累的静态变量的初始化Java代码和静态java代码块
子类的构造方法，不管其带不带参数，默认的都会先去执行父类的不带参数的构造方法。如果父类中没有无参构造，那么必须使用super声明调用父类中的哪个构造方法，否则会报错。

异常捕获

int x = 1;      ①
try{
    return ++x; ②
}finally{
    ++x;        ③
}
该代码片返回结果为2.
上面的代码片中，如果try代码块中有return时：
    1.如果有返回值，在执行②时，就把返回值保存在局部变量中
    2.执行jsr指令跳转到finally中执行finally的代码
    3.执行完finally语句后，返回之前保存在局部变量表中的值

int x=1;
try{
    return ++x;
}finally{
    return ++x;
}
如上代码片中，程序会默认执行finally中的return，忽略try中的return。


1.return的作用是终止当前方法的执行。
2.无论try中执行了return、break还是continue语句，finally语句块还是会执行的。但是可以使用System.exit()进行终止。