Java基础知识总结(三)

内存模型

1. CPU为了高速执行指令，因此CPU里面就有了高速缓存，不需要每次都和内存进行交互。
2. 因此，当多个CPU线程访问同一个资源（即称为共享变量），并对其进行修改时，就会出现缓存不一致问题
3. 两种解决方式：1）通过在总线加LOCK#锁的方式；2）通过缓存一致性协议（MESI协议）
4. 第一种方式，锁住总线期间，其他CPU无法访问内存，效率低下。
5. 第二种方式，当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。
   

并发编程的三个概念

并发编程中，常遇到三个问题：原子性问题，可见性问题，有序性问题。

1. 原子性问题
即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。类比于mysql的一个事务。
2.可见性
当多个线程访问同一个变量时，一个线程改变了这个变量的值，其他线程立刻能看到修改后的值。
3.有序性
JVM在执行代码时，不能保证代码执行有序性，因为可能会发生指令重排序（Instruction Reorder）。

指令重排序：处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

可以预想到，单个线程不会因为指令重排序而造成程序错误，但多个线程就可能会出错，以下例说明：

//线程1:
context = loadContext();   //语句1
inited = true;             //语句2
 
//线程2:
while(!inited ){
  sleep()
}
doSomethingwithconfig(context);

上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。

总结：要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

Java内存模型（Java Memory Model，JMM）

Java内存模型规定所有的变量都是存在主存当中（类似于前面说的物理内存），每个线程都有自己的工作内存（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。并且每个线程不能访问其他线程的工作内存。

1. 原子性
   只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。

x = 10;         //语句1
y = x;         //语句2
x++;           //语句3
x = x + 1;     //语句4

上述语句只有语句1是原子性操作。其他的都涉及变量之间的赋值。
Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

2.可见性

1. 对于可见性，Java提供了volatile关键字来保证可见性。
2. 当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。
3. 而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。
4. 另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

3. 有序性

1. 在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
2. 在Java里面，可以通过volatile关键字来保证一定的“有序性”（具体原理在下一节讲述）。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。
3. 另外，Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。
4. happens-before原则中其中有如下规则：volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作。如果一个线程先去写一个变量，然后一个线程去进行读取，那么写入操作肯定会先行发生于读操作。

volatile关键字

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1. 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的.
2. 禁止进行指令重排序。
3. 不保证原子性，采用synchronized、Lock可以解决问题。

volatile关键字禁止指令重排序有两层意思：
1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；
2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

//x、y为非volatile变量
//flag为volatile变量
 
x = 2;        //语句1
y = 0;        //语句2
flag = true;  //语句3
x = 4;         //语句4
y = -1;       //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。
并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

Java单例模式

饿汉式：线程安全，调用效率高。但是不能延时加载。

public class SingletonDemo1 {
    //线程安全的
    //类初始化时，立即加载这个对象
    private static SingletonDemo1 instance = new SingletonDemo1();
    private SingletonDemo1() {
    }
    //方法没有加同步块，所以它效率高
    public static SingletonDemo1 getInstance() {
        return instance;
    }
}

懒汉式：线程不安全。

public class SingletonDemo2 {
    //线程不安全的
    private static SingletonDemo2 instance = null;
    private SingletonDemo2() {
    }
    //运行时加载对象
    public static SingletonDemo2 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

接口和抽象类的区别

接口和抽象类是Java的两个基础机制。
接口是对行为的抽象，他是抽象方法的集合。接口不用被实例化，不能包含非常量成员。所有成员默认被public static final所修饰，接口中也没有非静态方法的实现，所有方法要么是抽象方法，要么是静态方法。接口实现了定义与实现分离的目的。

抽象类也不能被实例化，但是形式上和一般的Java方法没有太大区别，一个抽象类中可以有一个或者多个抽象方法，也可以不含有抽象方法。抽象类是对共有方法实现或者共有的成员变量的抽取，主要用于代码重用（通过继承的方式）。

区别：

1. 一个类可以实现多个接口，但是却只能继承最多一个抽象类；
2. 抽象类可以包含具体的方法，接口的所有方法都是抽象的；
3. 抽象类可以声明和使用字段；接口则不能，但接口可以创建静态的final常量；
4. 接口的方法都是public的，抽象类的方法可以使用public，private，protecte或者是默认的packag；
5. 抽象类可以定义构造函数，但是接口不行。

接口的设计目的是对类的行为进行约束（更准确的说是一种“有”约束，因为接口不能规定类不可以有什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现行为进行限制。对“接口为何是约束”的理解，我觉得配合泛型食用效果更佳。实现类也可以增加额外的方法，但声明的时候需要把实现类当成普通类来创建对象，否则无法调用新增方法。
而抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为(记为行为集合A)，且其中一部分行为的实现方式一致时（A的非真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执行）。

String StringBuffer 和 StringBuilder 的区别是什么?

• String 为什么是不可变的?
  
• String StringBuffer 和 StringBuilder 可变的原因？
  
• 线程安全？
  
• 总结
  

Java中为什么要定义一个没有参数的构造方法

对象的相等与指向他们的引用相等，两者有什么不同？

为什么要有hashCode？

为什么重写equals方法必须重写hashCode方法？（当在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中，用不到该类。则equals和hashCode无任何关系。）

线程、程序、进程的基本概念，及其他们之间的关系？

操作系统中可以同时执行1个以上进程，一个进程可以同时执行一个以上的线程。

如何使用synchronized关键字？

如何写一个单例模式？

饿汉式（线程不安全）：

public class SingletonDemo {
    private static SingletonDemo instance = new SingletonDemo();
    //私有化构造方法
    private SingletonDemo(){
    }

    public static SingletonDemo getInstance(){
        return instance;
    }
}

懒汉式（线程不安全）：

public class SingletonDemo2 {
    private static SingletonDemo2 instance = null;

    private SingletonDemo2(){

    }

    public static SingletonDemo2 getInstance(){
        if(instance == null) {
            return new SingletonDemo2();
        }
            return instance;
    }
}

引入锁（线程安全，范围较大，作用在类上）：

public class SingletonDemo3 {
    private static SingletonDemo3 instance = null;

    private SingletonDemo3(){

    }

    synchronized private static SingletonDemo3 getInstance(){
        if (instance == null){
            instance = new SingletonDemo3();
        }
        return instance;
    }
}

双重校验锁（线程安全，范围较小）：

public class SingletonDemo4 {
    //加volatile禁止指令重排
    private volatile static SingletonDemo4 instance = null;
    //私有化构造方法
    private SingletonDemo4(){}

    /**
     * 获取实例
     * @return
     */
    public static SingletonDemo4 getInstance(){
        //第一次验证是否为空
        if(instance==null){
            synchronized (SingletonDemo4.class){
                //第二次验证是否为空
                if(instance==null){
                    instance = new SingletonDemo4();
                }
            }
        }
        return instance;
    }
}