Java面试题(第四天)

1.双亲委派机制

双亲委派机制是指当一个类加载器收到一个类加载请求时，该类加载器首先会把请求委派给父类加载器。每个类加载器都是如此，只有在父类加载器在自己的搜索范围内找不到指定类时，子类加载器才会尝试自己去加载。 1.当Application ClassLoader 收到一个类加载请求时，他首先不会自己去尝试加载这个类，而是将这个请求委派给父类加载器Extension ClassLoader去完成。

BusFx2l5q7hWtzd

向上委托：实际上就是查找缓存

向下查找：实际上是查找加载路径

2.Java中的异常体系

Java中的所有异常都来自顶级父类Throwable

Throwable下有两个子类Exception和Error

Error是程序无法处理的错误，一旦出现这个错误，则程序将被迫停止运行

Exception不会导致程序停止，又分为两个部分RunTimeException（运行时期异常）和CheckedException（检查异常）

RunTimeException常常发生在程序运行过程中，会导致程序当前线程执行失败，CheckedException常常发生在程序编译过程中，会导致程序编译不通过

3.GC如何判断对象可以被回收

引用计数法：每个对象都有一个引用计数属性，新增一个引用计数加1，引用释放时计数减1，计数为0可以回收
可达性分析：从GC Roots开始向下搜索，搜索所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可同的，那么虚拟机就判断是可回收对象

引用计数法弊端：可能会出现A引用B，B又引用A，这时就算它们都不再使用了，但因为互相引用计数器=1，永远无法被回收。

GCRoots的对象有：

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

可达性算法中的不可达对象并不是立即死亡的，对象有一次拯救自我的机会，对象被系统宣告死亡至少要经历两次标记过程，第一次是经过可达性分析发现没有与GCRoots相连接的引用链，第二次是由虚拟机自动建立的Finalzer队列中判断是否需要执行Finalize()方法

若对象变成（GC Roots）不可达时，GC会判断对对象是否覆盖了Finalize方法，若没覆盖，则直接将其回收。否则，若对象未执行过finalize方法，则将其放入F-Queue队列，由低级线程执行该队列中对象的finalize方法。执行完毕后，GC再次判断该对象是否可达，若不可达，就回收，否则，对象“复活”

每个对象只能触发一次finalize方法

由于finalize()方法运行代价高昂，不确定性大，无法保证各个对象的调用程序，不推荐使用

4.线程的生命周期，线程有几种状态

1.线程通常有五种状态，创建，就绪，运行，阻塞和死亡状态

2.阻塞的情况又分为三种：

（1）、等待阻塞：运行的线程执行wait方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify或notifyAll方法才能被唤醒，wait是object的方法

（2）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中

（3）、其他阻塞：运行的线程执行sleep或join方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态，当sleep状态超时，join等待线程终止或者超时，或者I/O处理完毕时，线程重新转入就绪状态，sleep是Thread类的方法

1.新建状态（New）：新创建了一个线程对象

2.就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start方法，该状态下的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权

3.运行状态（Running）：就绪的线程获取了CPU，执行程序代码

4.阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行，直至线程进入就绪状态，才有机会转到运行状态

5.死亡状态（Dead）：线程执行完了或者因异常退出了run方法，该线程结束生命周期

5.sleep()、wait()、join()、yield()的区别

1.锁池

所有需要竞争同步锁的线程都会放在锁池当中，比如当前对象的锁已经被其中一个线程得到，则其他线程需要再这个锁池进行等待，当前面的线程释放同步锁后锁池中的线程去竞争同步锁，当某个线程到后会进入就绪队列进行等待CPU资源分配

2.等待池

当我们调用wait()方法后，线程会放到等待池当中，等待池的线程是不回去竞争同步锁，只有调用notify()或notifyAll()后等待池的线程才会开始去竞争锁，notify()是随机从等待池选出一个线程放到锁池，而notifyAll()是将等待池的所有线程放到锁池中

1.sleep是Thread类的静态本地方法，wait则是Object类的本地方法

2.sleep方法不会释放Lock，但是wait会释放，而且会加入到等待队列中。

sleep就是把CPU的执行资格和执行权释放出来，不再运行此线程，当定时时间结束再取回cpu资源，参与cpu的调度，获取到cpu资源后就可以继续运行了，而如果sleep时该线程有锁，那么sleep不会释放这个锁，而是把锁带着进入了冻结状态，也就是说其他需要这个锁的线程根本不可能获取到这个锁，也就是说无法执行程序，如果在睡眠时期其他线程调用了这个线程interrupt方法，那么这个线程也会抛出interruptException异常返回，这点和wait是一样的。

3.sleep方法不依赖于同步器synchronized，但是wait需要依赖synchronized关键字

4.sleep不需要被唤醒(休眠之后推出阻塞)，但是wait需要（不指定时间需要被别人中断）

5.sleep一般用于当线程休眠，或者轮循暂停操作，wait则多用于多线程之间的通信

6.sleep会让出CPU执行时间且强制切换上下文，而wait则不一定，wait后肯呢个还是有机会重新竞争到锁继续执行的

yield()执行后线程直接进入就绪状态，马上释放了CPU的执行权，但是依然保留了CPU的执行资格，所以有可能cpu下次进行线程调度还会让出这个线程获取到执行权继续执行

join()执行后线程会进入阻塞状态，例如在线程B中调用线程A的join()，那线程B会进入到阻塞队列，直到线程A结束或中断线程

public class ThreadJoinTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("子线程执行--"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadJoinTest threadJoinTest = new ThreadJoinTest();
        Thread thread = new Thread(threadJoinTest);
        thread.start();
        for (int i = 0; i < 100; i++) {
            if (i==50){
                thread.join();
            }
            System.out.println("main执行了---"+i);
        }
    }
}

这里当我们的i执行到50的时候，他会去执行子线程，直到子线程执行完毕，这就导致了main线程的阻塞

标签：面试题,Java,对象,线程,sleep,加载,方法,wait
From： https://www.cnblogs.com/qisui/p/17806009.html

Java面试题4