从面试到技术提升（Java篇-上卷）

2018-07-19 本文已影响149人咸鱼正翻身

背景

其实，这系列文章我构思了很久。从我大概2016年初断断续续在CSDN上写博客开始，我就想好好整理一篇Android的综合文章。奈何那个时候功力尚浅，没办法驾驭（虽然现在依然彩笔一支）。
时至今日，算是正式开始动笔，其实之前想过很多文章计划，比如2018年开年的周期计划。不过写了8篇便放弃了。今天借着正正经经写公众号的机会，把这个《地表有点强》系列坚持下去，加油！

OK，闲话不说。先从Java开始~

《Java篇-上卷》

1、描述一个类的加载过程？

Model model= new Model ()

JVM会通过双亲委派机制将Model .class加载到内存中。
执行类里的静态代码块（如果有的话）。
在堆内存中申请内存空间，并分配内存地址给我们真正的Model对象。
在堆/栈内存里建立对象的属性（基本类型在堆中，引用类型和数组在堆中），并进行初始化赋值。
开始对象的构造代码块初始化（如果有的话）。
调用对象对应的构造方法进行初始化。
将对象的被分配的内存地址赋值给model变量。

2、Java对象的生命周期是什么？

加载：首相将类的全部信息加载到JVM的方法区中，然后在堆区中实例化一个java.lang.Class对象，作为方法去中这个类的信息入口（可以理解成是这个java代码的数据结构）。
连接：分为三个部分：
- 验证：验证类是否合法（判断这个代码文件是否符合JVM的标准）。
- 准备：为静态变量分配内存并设置赋初始值，非静态变量在此时不会被分配内存（还没出生，也就是为什么静态不能调用非静态）。
- 解析：将常量池里的符号引用转换为直接引用。
初始化：初始化类的静态赋值语句和静态代码块，主动引用（就是那几种可以造成类初始化的行为）会被触发类的初始化，被动引用不会触发类的初始化。
使用：执行类的初始化，主动引用会被触发类的初始化，被动引用不会触发类的初始化。
卸载：卸载过程就是清楚堆里类的信息，以下情况会被卸载：① 类的所有实例都已经被回收。② 类的ClassLoader被回收。③ 类的CLass对象没有被任何地方引用，无法在任何地方通过反射访问该类。（GC）

3、描述一下类的加载机制？

先将类.java文件编译成.class文件然后将.class文件中的二进制数据读入到内存中（使用ClassLoader）。

类加载器可以分为三类：

启动类加载器（Bootstrap ClassLoader）：负责加载<JAVA_HOME>\lib目录下或者被-Xbootclasspath参数所指定的路径的，并且是被虚拟机所识别的库到内存中。

扩展类加载器（Extension ClassLoader）：负责加载<JAVA_HOME>\lib\ext目录下或者被java.ext.dirs系统变量所指定的路径的所有类库到内存中。

应用类加载器（Application ClassLoader）：负责加载用户类路径上的指定类库，如果应用程序中没有实现自己的类加载器，一般就是这个类加载器去加载应用程序中的类库。

聊一下双亲委派模型，流程图如下所示

双亲委派

简单流程：如果一个类加载器收到了加载类的请求，它不会自己立即去加载类，它会先去请求父类加载器，每个层次的类加载器都是如此。层层传递，直到传递到最高层的类加载器，只有当父类加载器反馈自己无法加载这个类，才会有当前子类加载器去加载该类。

落实到代码上就是：

public abstract class ClassLoader {
    
    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException  {
            //首先，检查该类是否已经被加载
            Class c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    //先调用父类加载器去加载
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {            
                }

                if (c == null) {
                    //如果父类加载器没有加载到该类，则自己去执行加载
                    long t1 = System.nanoTime();
                    c = findClass(name);
                }
            }
            return c;
    }
}

4、如何判断对象死了？

引用计数法：有对这个对象的引用就+1，不再引用就-1，但是这种方式看起来简单美好，但它却无法解决循环引用的问题。

可达性分析算法：可达性分析算法通过一系列称为GC Roots的对象作为起始点，从这些节点从上向下搜索，搜索走过的路径称为引用链，当一个对象没有任何引用链与GC Roots连接时就说明此对象不可用，也就是对象不可达。（也就是说可以被回收）

什么样的对象才能被称之为GC Roots对象？

虚拟机栈中引用的对象（栈帧中的本地变量表）
方法去中类的静态属性引用的对象
方法区中常量引用的对象
Native方法引用的对象

5、synchronized理解？

synchronized同步的俩种写法：

synchronized(this)：对象锁

public synchronized void method(){}

public void method(){
  synchronized(this) {}
}

synchronized(ClassName.class)：类锁

public void method() {
   synchronized(ClassName.class) {}
}

public static synchronized method(){}

它们的区别大概可以这么理解：
对象锁：Java的所有对象都含有1个互斥锁，这个锁由JVM自动获取和释放。线程进入synchronized方法的时候获取该对象的锁（也就是传入的对象），当然如果已经有线程获取了这个对象的锁，那么当前线程会等待；synchronized方法正常返回或者抛异常而终止，JVM会自动释放对象锁。

类锁：首先来说，Java类可能会有很多个对象，但是只有一个Class对象，也就是说类的不同实例之间共享这一个的Class对象。Class对象就是一个特殊的Java对象。类锁和对象锁不是同一个东西，一个是类的Class对象的锁，一个是类的实例的锁。也就是说：一个线程访问静态synchronized的时候，允许另一个线程访问对象的实例synchronized方法。反过来也是成立的，因为他们需要的锁是不同的。

6、如何理解volatile？

首先我们先了解一下JMM，Java内存模型。

Java内存模型规定了所有变量（这些变量包括实例变量、静态变量等，但不包括局部变量、方法参数等，因为这些变量存放在栈中，是线程私有的，并不存在竞争）都存在主内存中，每个线程会有自己的工作内存，工作内存里保存了线程所使用到的变量在主内存里的副本拷贝，线程对变量的操作只能在自己的工作内存里进行，不能直接读写主内存，彼此线程之间也不可见。

Java线程模型

volatile有两条关键的语义：

保证被volatile修饰的变量对所有线程都是可见的
禁止进行指令重排序

非原子性操作除外，也就是说i++这种操作，用volatile修饰是没办法保证同步的，需要用到AtomicInteger

为什么自增不行？
因为i++操作，是多个步骤：首先取出i的值，因为有volatile的修饰，这时候的值是没有问题的。
但是自增的时候，别的线程可能已经把i修改了比如+1，这种情况下就此线程如果写入成功就把i的值改错误了。

7、单例

经典的单例写法：（但是此方式没办法应对反射破坏）

public class Singleton {

    //volatile保证了：1 instance在多线程并发的可见性 2 禁止instance在操作是的指令重排序
    private volatile static Singleton instance;

    private Singleton(){}

    public static Singleton getInstance() {
        //第一次判空，保证不必要的同步
        if (instance == null) {
            //synchronized对Singleton加全局所，保证每次只要一个线程创建实例
            synchronized (Singleton.class) {
                //第二次判空时为了在null的情况下创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

枚举的单例方式可以避免反射破坏，目前正在学习其中的原理，不要zhaoji...

8、手写一下生产者和消费者模型


public class Main {
    private static Integer count = 0;
    private static final Integer FULL = 10;
    private static Object LOCK =new Object;
    
    public static void main(String[] args) {
        Main main = new Main();
        new Thread(main .new Producer()).start();
        new Thread(main .new Consumer()).start();
        new Thread(main .new Producer()).start();
        new Thread(main .new Consumer()).start();
        new Thread(main .new Producer()).start();
        new Thread(main .new Consumer()).start();
        new Thread(main .new Producer()).start();
        new Thread(main .new Consumer()).start();
    }
    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == FULL) {
                        try {
                            LOCK.wait();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    count++;
                    Log.d("test",Thread.currentThread().getName() + "生产者生产成功，目前总共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }
    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == 0) {
                        try {
                            LOCK.wait();
                        } catch (Exception e) {
                        }
                    }
                    count--;
                   Log.d("test",Thread.currentThread().getName() + "消费者消费成功，目前总共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }
}

呃...

写完突然发现，有点随意了。这些内容好像完全不相干。不管了，大家就当琐碎的知识点，学习吧_{当然如果文中有错误的地方，欢迎评论区之出。因为这毕竟也只是我自己的学习总结}~