2020面试前准备

1.所有的类都继承于object类，你用过的object类的直接子类有哪些，object类常用的方法有哪些

.toString(),.clone(),.getClass(),.getHashCode(),.wait(),.notify(),finalize，equals

.clone(): 保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

.getClass方法: final方法，获得运行时类型。

toString方法:该方法用得比较多，一般子类都有覆盖。

finalize方法:该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

equals方法:该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。

2.String、StringBuffer、StringBuild区别

String 字符串常量线程安全源码 final char value[], int hash.

StringBuffer 字符串变量线程安全效率不高同步Synchronized方法

StringBuild 字符串变量线程不安全高效

3.JAVA异常

4.JAVA垃圾回收

5.static用法，静态类、final用法

static修饰方法和变量，在Java运行期间生产，直接通过类访问，区别于实例变量需要通过new实例化对象，对对象进行访问。

static类只能是静态内部类

final类不能被继承，final方法不能被重写。初始化只能赋一次值

6.线程、进程、协程区别

进程操作系统资源调度最小单位

线程操作系统（CPU）调度的最小单位

协程更轻量级的线程，由程序自身控制，多个协程运行，可以在程序执行中随意切换运行，高并发

6.创建线程方式，区别，wait()、notify()使用注意点

继承Thread类和实现Runnable接口. wait()、notify()一般实在synchronized块中，条件不满足则wait等待，条件满足时唤醒。调用前必须先获得锁

区别：继承是单继承，并且是实例化多个线程对象，分别取完成任务。

public class MyThread extends Thread{
//实例化多个线程对象，独立去完成任务
public static void main(String[] args) {
        MyThread thread1 = new MyThread("一号");
        MyThread thread2 = new MyThread("二号");
        MyThread thread3 = new MyThread("三号");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

　　实现Runable是实例化一个对象，对象创建多个线程去共同完成任务。

public class MyRunable implements Runable{
//实例化一个对象，并创建多个线程共同完成任务
MyRunable myRunable = new MyRunable();
        Thread thread1 = new Thread(myRunable,"一号");
        Thread thread2 = new Thread(myRunable,"2号");
        Thread thread3 = new Thread(myRunable, "3号");
        thread1.start();
        thread2.start();
        thread3.start();
}

7.线程之间怎么共享变量，是否安全

实现可见性sychronized,volatile修饰变量。安全性sychronized安全，volatile不一定，要看共享变量操作能不能保持原子性。

8.线程池创建参数，线程池中如果线程已满，再加入一个线程，会发生什么

线程池的好处：新建线程和销毁线程都有很大的开销，线程池能够复用线程从而减少资源开销和时间。对线程进行统一管理，有效控制线程最大并发数，提高资源使用率，避免过多资源竞争而阻塞。

其中定长线程池：fixedThreadPool和singleTreadPool。

处理优先级：corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。

// 构造一个线程池  
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3,  
                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),  
                new ThreadPoolExecutor.DiscardOldestPolicy());

4、这个小组里面队员至少有两个，如果他们两个忙不过来，任务就被放到任务列表里面。

如果积压的任务过多，多到任务列表都装不下(超过3个)的时候，就雇佣新的队员来帮忙。但是基于成本的考虑，不能雇佣太多的队员，至多只能雇佣 4个。

5、如果四个队员都在忙时，再有新的任务，这个小组就处理不了了，任务就会被通过一种策略来处理，我们的处理方式是不停的派发，直到接受这个任务为止(更残忍！呵呵)。

因为队员工作是需要成本的，如果工作很闲，闲到 3 秒都没有新的任务了，那么有的队员就会被解雇了，但是，为了小组的正常运转，即使工作再闲，小组的队员也不能少于两个。参考自：https://www.iteye.com/blog/uule-1123185

拒绝策略：

①AbortPolicy：默认策略，在拒绝任务时，会抛出RejectedExecutionException。

②CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前的被丢弃的任务。

③DiscardOldestPolicy：该策略将丢弃最老的一个请求，也就是即将被执行的任务，并尝试再次提交当前任务。

④DiscardPolicy：该策略默默的丢弃无法处理的任务，不予任何处理

9.乐观锁和悲观锁是什么

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的
乐观锁：版本号控制，CAS算法，

需要读写的内存值 V
进行比较的值 A
拟写入的新值 B

当且仅当 V 的值等于 A时，CAS通过原子方式用新值B来更新V的值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。

10.数据库索引的原理

11.数据库隔离级别

12.HashMap实现原理过程，扩容

13.JVM内存

线程共享：堆（存放对象实例和数组），方法区

线程私有：本地方法栈（基本类型），虚拟机栈，程序计数器

12.StringBoot运行过程原理

@springbootApplication注解包含@SpringBootConfiguration加载创建bean和@ComponentScan扫包

13.SpringCloud分发过程

IO操作

14.ThreadLocal的应用场景

在Java的多线程编程中，为保证多个线程对共享变量的安全访问，通常会使用synchronized来保证同一时刻只有一个线程对共享变量进行操作。这种情况下可以将类变量放到ThreadLocal类型的对象中，使变量在每个线程中都有独立拷贝，不会出现一个线程读取变量时而被另一个线程修改的现象。最常见的ThreadLocal使用场景为用来解决数据库连接、Session管理等。链接：https://www.jianshu.com/p/6fc3bba12f38

//实现： sqlSessionManager类中获取连接，mybatis在分布式事务中通过将A模块分配连接保存到threadLocal，B模块从threadLocal中获从而保持数据库一致性
Private final ThreadLocal<SqlSession> localSqlSession = new threadLocal<>();//

//使用TransactionContextHolder保证分布式事务一致性

Private static final ThreadLocal<TransactionContext> currentTransactionContext = new NamedInheritableThreadLocal<>();

15.软件设计原则

开闭原则：对扩展开放，对修改关闭。即要求用抽象构建框架，用实现扩展细节

高内聚低耦合

https://blog.csdn.net/shuizhizhiyin/article/details/51718900

16.微服务拆分：

　https://baijiahao.baidu.com/s?id=1632326446570197886&wfr=spider&for=pc　

17.分布式锁

https://blog.csdn.net/yb223731/article/details/90349502

项目中实际用到的一些东西

1.分布式锁