2021年最新面试基础题

心已赠人 2022-10-09 14:27 320阅读 0赞

**目录**

一、Java基础

二、多线程

三、、集合 ：Set 、List、Map

四、网络

五、设计模式

--------------------

### 一、Java基础 ###

1、基本数据类型：8个：byte、short、int、long、float、double、char、boolean；基本数据类型：数据直接存储在栈上引用数据类型区别：数据存储在堆上，栈上只存储引用地址。

2、String、StringBuffer、 StringBuilder的区别：String被final修饰故不可变，线程安全；StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，线程安全；StringBuilder是非线程安全的，相同单线程情况下，StringBuilder性能高于StringBuffer

3、自动装箱和拆箱：装箱：将基本类型用它们对应的引用类型包装起来；拆箱：将包装类型转换成基本数据类型。

4、重载和重写的区别

1）、重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序 不同，方法返回值和访问修饰符可以不同，发生在编译时 不同，方法返回值和访问修饰符可以不同，发生在编译时。

2）、重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。

5、事务失效的三种场景:

事务方法内部捕捉了异常，没有抛出新的异常，导致事务操作不会进行回滚；2Transactional注解标注方法修饰符为非public时；3.在类内部调用调用类内部@Transactional标注的方法

6、public、private、protected修饰范围的区别

7、&和&&的区别： && 逻辑与运算符，具有短路作用；& 逻辑与运算符、按位运算符；

8、String str = new String('xyz"); 创建了几个字符串对象？   一个或两个。如果字符串常量池已经有“xyz”，则是一个；否则，两个。当字符创常量池没有 “xyz”，此时会创建如下两个对象：一个是字符串字面量 "xyz" 所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，此时该实例也是在堆中，字符串常量池只放引用。另一个是通过 new String() 创建并初始化的，内容与"xyz"相同的实例，也是在堆中。

9、String s = "xyz" 和 String s = new String("xyz") 区别 ： 两个语句都会先去字符串常量池中检查是否已经存在 “xyz”，如果有则直接使用，如果没有则会在常量池中创建 “xyz” 对象。另外，String s = new String("xyz") 还会通过 new String() 在堆里创建一个内容与 "xyz" 相同的对象实例.所以前者其实理解为被后者的所包含。

10、什么是开放-封闭法则（OCP）?

对拓展开放，对修改关闭、封装变化

11、单例模式、工厂模式等？

12、==和equal的区别？

1）、==：基本数据类型比较值，引用数据类型比较引用地址；

2）、 equal:比较对象的值是否相同，其被重写时一般

hashCode也重写。

13、抽象类和接口的区别？

1）抽象类只能单继承，接口可以多实现；

2）抽象类可以有构造方法，接口没有；

3）抽象类可以有成员变量，接口只能有常量；

4）抽象类可以包含非抽象方法，java7之前接口中方法都是抽象方法，Java8之后接口支持非抽象方法，Java9接口支持私有方法、私有静态方法。

5）抽象类可以使用任意修饰符，Java8之前接口只能使用public，Java9支持private

6）都不可以实例化，都要对其中方法全部实现

14、 请求转发和重定向的区别

本质区别：  转发是服务器行为，重定向客户端行为。

重定向特点：两次请求，浏览器地址发生变化，可以访问自己 web之外的资源，传输数据会丢失。

请求转发特点：一次请求，浏览器地址不变，访问的是自己本身请eb资源，传输的数据不会丢失。

15、重载和重写的区别

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；

重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。

重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

16、maven命令的区别 install packet

package命令完成了项目编译、单元测试、打包功能，但没有把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库

install命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库，但没有布署到远程maven私服仓库

deploy命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库

17、hashCode和equal？为啥重写equal一定要重写hashCode？

1）如果两个对象相等，则 hashcode 一定也是相同的

2）两个对象相等,对两个对象分别调用 equals 方法都返回 true

3）两个对象有相同的 hashcode 值，它们也不一定是相等的

因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖

hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写

hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

18、对象的相等和指向他们的引用相等，有什么不同？

对象的相等：比较的是内存中存放的内容是否相同

引用的相等：比较的是他们指向的内存地址是否相同

19、成员变量和局部变量的区别？

1）、在类的位置不同：成员变量在类中方法外；局部变量：方法定义中或方法声明上；

2）、在内存中的位置不同：成员变量在堆中；局部变量在栈中；

3）、生命周期不同：成员变量随着对象的创建而创建，消失而消失；局部变量随着方法的调用而存在，调用结束消失

4）、初始化值不同：成员变量有默认值；局部变量必须定义赋值才能使用

20、wait()和sleep()的区别？

1）、原理不同：sleep是Thread类的静态方法，是线程用来控制自身流程的，使线程暂停一段时间，把执行机会让给其他线程，等时间一到，就会自动苏醒；wait是object类的方法，用于线程间通信，它会使当前拥有改变对象锁的进程等待，直到其他进程调用notify()或notifyAll()，不过开发人员也可以指定一个时间自动醒来；

2）、对锁的处理机制不同：sleep会不会释放锁；wait线程会释放占用的锁；

3）、使用区域不同：wait必须使用在同步控制方法或同步语句块中使用，sleep可以使用在任何地方；

4）、异常处理不同：sleep  必须捕获异常；wait方法不需要捕获异常；

21、final、finally、finalize的作用

1）、final：修改变量，则变量不可变；修饰类，则类不能被继承，类中方法被隐私指向final方法；修饰方法，方法不能被重写

2）、finally：异常处理语句中的一部分，表示总是执行

3）、finalize：是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等

22、object有哪些方法？ wait方法、equal方法、toString方法

23、maven命令的区别  packet install deploy

1）、package命令完成了项目编译、单元测试、打包功能，但没有把打好的可执行jar包布署到本地maven仓库和远程maven私服仓库

2）、install命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包布署到本地maven仓库，但没有布署到远程maven私服仓库

3）、deploy命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包布署到本地maven仓库和远程maven私服仓库

24、 volatile关键字的作用？

1）、 防止指令重排（单例模式中）

2）、内存可见性

25、Java获取反射的三种方式

1）、通过new对象实现反射机制

2）、通过路径实现反射机制

3）、通过类名实现反射机制

26、什么是反射？

1）、Java 反射机制是在运行状态中，对于任意一个类，都能够获得这个类的所有属性和方法，对于任意一个对象都能够

调用它的任意一个属性和方法。这种在运行时动态的获取信息以及动态调用对象的方法的功能称为 Java 的反射机

制。

27、Files的常用方法都有哪些？

1）、Files.exists() 检测文件路径是否存在

2）、Files.createFile()创建文件

3）、Files.createDirectory()创建文件夹

4）、Files.delete() 删除文件或者目录

5）、Files.copy() 复制文件

6）、Files.move() 移动文件

7）、Files.size（）查看文件个数

8）、Files.read() 读取文件

9）、Files.write()写入文件

28、什么是 java 序列化？什么情况下需要序列化？

1）、序列化：将 Java 对象转换成字节流的过程。

2）、反序列化：将字节流转换成 Java 对象的过程。

3）、当 Java 对象需要在网络上传输 或者 持久化存储到文件中时，就需要对 Java 对象进行序列化处理。

4）、序列化的实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。

29、动态代理是什么？有哪些应用？

1）、动态代理：在运行时，创建目标类，可以调用和扩展目标类的方法。

2）、动态代理的实现

使用的模式：代理模式。

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。类似租房的中介。

3）、两种动态代理：

jdk动态代理，jdk动态代理是由Java内部的反射机制来实现的，目标类基于统一的接口（InvocationHandler）

cglib动态代理，cglib动态代理底层则是借助asm来实现的，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。

4）、主要应用的框架：

Spring中的AOP，Struts2中的拦截器

30、怎么实现动态代理？

31、为什么要使用克隆？

1）、想对一个对象进行处理，又想保留原有的数据进行接下来的操作

32、如何实现对象克隆？

1）、实现 Cloneable 接口并重写 Object 类中的 clone()方法

2）、实现 Serializable 接口，通过对象的序列化和反序列化实现克隆

33、深拷贝和浅拷贝区别是什么？

1·）、浅拷贝：复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针，不复制堆内存中的对象

2）、深拷贝：复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针和堆内存中的对象。

34、forward 和 redirect 的区别？

1）、forward:转发页面和转发到的页面可以共享request里面的数据；redirect:不能共享数据

2）、地址栏显示方面：redirect新URL；forward不变

3）、本质区别：转发是服务器行为，重定向是客户端行为

35、get 和 post 请求有哪些区别

1）、GET在浏览器回退时是无害的，而POST会再次提交请求。

2）、GET产生的URL地址可以被Bookmark，而POST不可以。

3）、GET请求会被浏览器主动cache，而POST不会，除非手动设置。

4）、GET请求只能进行url编码，而POST支持多种编码方式。

5）、GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。

6）、GET请求在URL中传送的参数是有长度限制的，而POST么有。

7）、对参数的数据类型，GET只接受ASCII字符，而POST没有限制。

8）、GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。

9）、GET参数通过URL传递，POST放在Request body中。

36、说一下 JSONP 实现原理？（暂不分析）

37、session 和 cookie 有什么区别？

1）、存储容量不同

单个cookie保存的数据<=4KB，一个站点最多保存20个Cookie。

对于session来说并没有上限，但出于对服务器端的性能考虑，session内不要存放过多的东西，并且设置session删除机制。

2）、存储方式不同

cookie中只能保管ASCII字符串，并需要通过编码方式存储为Unicode字符或者二进制数据。

session中能够存储任何类型的数据，包括且不限于string，integer，list，map等。

3）、隐私策略不同

cookie对客户端是可见的，别有用心的人可以分析存放在本地的cookie并进行cookie欺骗，所以它是不安全的。

session存储在服务器上，对客户端是透明对，不存在敏感信息泄漏的风险。

4）、有效期上不同：

开发可以通过设置cookie的属性，达到使cookie长期有效的效果。

session依赖于名为JSESSIONID的cookie，而cookie JSESSIONID的过期时间默认为-1，只需关闭窗口该session就会失效，因而session不能达到长期有效的效果。

5）、存储位置不同和服务器压力不同：

cookie保管在客户端，不占用服务器资源。对于并发用户十分多的网站，cookie是很好的选择。

session是保管在服务器端的，每个用户都会产生一个session。假如并发访问的用户十分多，会产生十分多的session，耗费大量的内存。

6）、跨域支持上不同：cookie支持跨域名访问；session不支持跨域名访问。

38、说一下 session 的工作原理？

1）、session 的工作原理是客户端登录完成之后，服务器会创建对应的 session，session 创建完之后，会把 session 的 id 发送给客户端，客户端再存储到浏览器中。这样客户端每次访问服务器时，都会带着 sessionid，服务器拿到 sessionid 之后，在内存找到与之对应的 session 这样就可以正常工作了。

39、如果客户端禁止 cookie 能实现 session 还能用吗？

1）、可以

通过url重写，把 sessionid 作为参数追加的原 url 中，后续的浏览器与服务器交互中携带 sessionid 参数。

服务器的返回数据中包含 sessionid，浏览器发送请求时，携带 sessionid 参数。

通过 Http 协议其他 header 字段携带 sessionid 参数

40、java 中 IO 流分为几种？

1）、字节流和字符流

41、同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO 有什么区别？

1）、Java BIO ：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。

2）、Java NIO ： 同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。

3）、Java AIO(NIO.2) ： 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，

4）、BIO、NIO、AIO适用场景分析:

BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。

NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。

AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

42、如何将字符串反转？

1）、StringBuiler的reverse()的方法

### 二、多线程 ###

1、什么是死锁？

死锁指两个或两个以上进程在执行任务过程中，由于资源竞争或由于彼此通信而造成的一种阻塞现象，若无外力作用，他们将无法推进下去；

2、死锁产生的原因？

1）、系统资源的竞争；

2）、进程运行推进顺序执行不当

3、发生死锁的四个必要条件使什么？

1）、互斥条件：一段时间内某个资源只能由一个进程占用

2）、请求与保持条件： 进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已经被其他进程占用，此时请求进程被阻塞，但对自己已获得的资源保持不放。

3）、不可剥夺条件：资源只能有自己主动释放，不能被其他进程强行剥夺

4）、循环等待条件：进程与资源之间形成环链

4、如何避免死锁？

1）、死锁避免的基本思想：系统对进程发出每一个系统能够满足的资源申请进行动态检查，并根据检查结果决定是否分配资源，如果分配后会造成死锁，则不分配。

2）、死锁预防：设法至少破坏死锁产生的四个必要条件之一。

5、线程有哪些状态（生命周期）

1）、线程状态五种：新建、就绪、运行、阻塞和死亡；

6、线程的创建方式有几种？区别？

1）、继承Thread类创建线程

2）、实现Runnable接口创建线程

3）、使用Callable和Future创建线程

区别：

1）、 实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，后者线程执行体run()方法无返回值；其归为一类和Thread比较

2）、线程只是实现 Runnable或实现Callable接口，还可以继承其他类；

3）、实现接口的方式，多线程可以共享一个target对象，非常适合多线程处理一份资源的情形；

4）、继承Thread之后，不能继承其他的了（单继承多实现）

7、乐观锁和悲观锁？以及对应的实现？

1）、乐观锁：CAS、version版本标识

2）、悲观锁：synchronized

8、CAS、synchronized的原理？CAS造成的ABA问题，如何解决?和lock的区别？

1）、CAS 原理：CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。 如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值 。否则，处理器不做任何操作。

2）、CAS的ABA问题：因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。

3）、CAS的 循环时间长开销大： 自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销

4）、CAS 只能保证一个共享变量的原子操作： 当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij

5）、synchronized原理：

9、为什么用线程池？

1）、减少因线程创建和销毁造成的开销，提高程序运行效率；

2）、控制线程数量，防止程序崩溃

10、如何使用线程池？

1）、  Executors创建线程池；其常用的有四种线程池：

newCachedThreadPool：具有缓存功能的线程池（允许创建的线程数为 Integer.MAX\_VALUE，大量线程，导致OOM ）

newScheduledThreadPool：创建具有指定线程数的线程池

newFixedThreadPool：可重用的、具有固定线程数的线程池（请求队列长度为Integer.MAX\_VALUE，堆积请求，造成OOM）

newSingleThreadExecutor：只有单线程的线程池

推荐使用：ThreadPoolExecutor

11、核心线程数量和最大线程数量？

核心线程数量：瓶身

队列：瓶颈

最大线程数：瓶口

1）、如果当前池大小 poolSize 小于 corePoolSize ，则创建新线程执行任务。

2）、如果当前池大小 poolSize 大于 corePoolSize ，且等待队列未满，则进入等待队列

3）、如果当前池大小 poolSize 大于 corePoolSize 且小于 maximumPoolSize ，且等待队列已满，则创建新线程执行任务。

4）、如果当前池大小 poolSize 大于 corePoolSize 且大于 maximumPoolSize ，且等待队列已满，则调用拒绝策略来处理该任务。

饱和策略：

当工作队列满且线程个数达到maximunPoolSize后所采取的策略

AbortPolicy：默认策略；新任务提交时直接抛出未检查的异常RejectedExecutionException，该异常可由调用者捕获。

CallerRunsPolicy：既不抛弃任务也不抛出异常，使用调用者所在线程运行新的任务。

DiscardPolicy：丢弃新的任务，且不抛出异常。

DiscardOldestPolicy：调用poll方法丢弃工作队列队头的任务，然后尝试提交新任务

自定义策略：根据用户需要定制

12、 如何设置核心线程大小

1）、CPU密集型任务：尽量使用较小的线程池，一般为CPU核心数+1。因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，只能增加上下文切换的次数，因此会带来额外的开销。

2）、IO密集型任务：可以使用稍大的线程池，一般为2\*CPU核心数+1。因为IO操作不占用CPU，不要让CPU闲下来，应加大线程数量，因此可以让CPU在等待IO的时候去处理别的任务，充分利用CPU时间

13、threadlocal作用和原理？

14、CountDownLatch和CyclicBarrier了解吗？

1）、CountDownLatch中一个线程等待其他几个线程完成。

2）、CyclicBarrier中几个线程相互等待某一事件的达成。CyclicBarrier可以复用

15、notify唤醒时机？

1）、notify后不会立刻唤醒处于线程等待池中的线程，而是等当前同步代码块执行完，才释放当前的对象锁，并唤醒等待线程。

16、notify和notifyAll区别？

1）、notify通知一个线程获取锁，而notifyAll通知所有相关的线程去竞争锁

17、讲一下Lock？

1）、Lock是为了弥补synchronized的缺陷而诞生的，主要解决两种场景

读写操作，读读不应该互斥

避免永久的等待某个锁

2）、Lock是一个类，并非Java本身带的关键字，相对于synchronized而言，需要手动释放锁。

18、锁的种类？

1）、可重入锁，如ReentrantLock

2）、可中断锁，lockInterruptibly()反应了Lock的可中断性

3）、公平锁，synchronized是非公平锁，Lock默认也是非公平锁（可调整）

4）、读写锁，如ReadWriteLock

19、线程的 run()和 start()有什么区别？

1）、run()相当于线程的任务处理逻辑的入口方法，它由Java虚拟机在运行相应线程时直接调用，而不是由应用代码进行调用。

2）、start()的作用是启动相应的线程。启动一个线程实际是请求Java虚拟机运行相应的线程，而这个线程何时能够运行是由线程调度器决定的。start()调用结束并不表示相应线程已经开始运行，这个线程可能稍后运行，也可能永远也不会运行。

20、线程池都有哪些状态？

1）、RUNNING：线程池一旦被创建，就处于 RUNNING 状态，任务数为 0，能够接收新任务，对已排队的任务进行处理。

2）、 SHUTDOWN：不接收新任务，但能处理已排队的任务。调用线程池的 shutdown() 方法，线程池由 RUNNING 转变为 SHUTDOWN 状态。

3）、STOP：不接收新任务，不处理已排队的任务，并且会中断正在处理的任务。调用线程池的 shutdownNow() 方法，线程池由(RUNNING 或 SHUTDOWN ) 转变为 STOP 状态。

4）、 TIDYING：

SHUTDOWN 状态下，任务数为 0， 其他所有任务已终止，线程池会变为 TIDYING 状态，会执行 terminated() 方法。线程池中的 terminated() 方法是空实现，可以重写该方法进行相应的处理。

线程池在 SHUTDOWN 状态，任务队列为空且执行中任务为空，线程池就会由 SHUTDOWN 转变为 TIDYING 状态。

线程池在 STOP 状态，线程池中执行中任务为空时，就会由 STOP 转变为 TIDYING 状态。

5）、 TERMINATED：线程池彻底终止。线程池在 TIDYING 状态执行完 terminated() 方法就会由 TIDYING 转变为 TERMINATED 状态。

21、线程池中 submit()和 execute()方法有什么区别？

两个方法都可以向线程池提交任务：

1）、execute()方法的返回类型是 void，它定义在Executor 接口中。

2）、submit()方法可以返回持有计算结果的 Future 对象，它定义在ExecutorService 接口中，它扩展了 Executor 接口，其它线程池类像ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 都有这些方法。

22、在 java 程序中怎么保证多线程的运行安全？

1）、使用安全类，比如 Java. util. concurrent 下的类

2）、使用自动锁 synchronized

3）、使用手动锁 Lock

23、多线程锁的升级原理是什么？

1）、锁的级别从低到高：无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁

2）、锁分级别原因：

没有优化以前，synchronized是重量级锁（悲观锁），使用 wait 和 notify、notifyAll 来切换线程状态非常消耗系统资源；线程的挂起和唤醒间隔很短暂，这样很浪费资源，影响性能。所以 JVM 对 synchronized 关键字进行了优化，把锁分为 无锁、偏向锁、轻量级锁、重量级锁 状态。

3）、无锁：没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功，其他修改失败的线程会不断重试直到修改成功。

4）、偏向锁：对象的代码一直被同一线程执行，不存在多个线程竞争，该线程在后续的执行中自动获取锁，降低获取锁带来的性能开销。偏向锁，指的就是偏向第一个加锁线程，该线程是不会主动释放偏向锁的，只有当其他线程尝试竞争偏向锁才会被释放。

偏向锁的撤销，需要在某个时间点上没有字节码正在执行时，先暂停拥有偏向锁的线程，然后判断锁对象是否处于被锁定状态。如果线程不处于活动状态，则将对象头设置成无锁状态，并撤销偏向锁；如果线程处于活动状态，升级为轻量级锁的状态。

5）、轻量级锁：轻量级锁是指当锁是偏向锁的时候，被第二个线程 B 所访问，此时偏向锁就会升级为轻量级锁，线程 B 会通过自旋的形式尝试获取锁，线程不会阻塞，从而提高性能。

当前只有一个等待线程，则该线程将通过自旋进行等待。但是当自旋超过一定的次数时，轻量级锁便会升级为重量级锁；当一个线程已持有锁，另一个线程在自旋，而此时又有第三个线程来访时，轻量级锁也会升级为重量级锁。

6）、重量级锁：指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。

重量级锁通过对象内部的监视器（monitor）实现，而其中 monitor 的本质是依赖于底层操作系统的 Mutex Lock 实现，操作系统实现线程之间的切换需要从用户态切换到内核态，切换成本非常高

24、synchronized 和 volatile 的区别是什么？

1）、java的线程抽象内存模型中定义了每个线程都有一份自己的私有内存，里面存放自己私有的数据，其他线程不能直接访问，而一些共享数据则存在主内存中，供所有线程进行访问。

如果线程A和线程B要进行通信，就要经过主内存，比如线程B要获取线程A修改后的共享变量的值，要经过下面两步：

（1）、线程A修改自己的共享变量副本，并刷新到了主内存中。

（2）、线程B读取主内存中被A更新过的共享变量的值，同步到自己的共享变量副本中。

2）、java多线程中的原子性、可见性、有序性

（1）、原子性：是指线程的多个操作是一个整体，不能被分割，要么就不执行，要么就全部执行完，中间不能被打断。

（2）、可见性：是指线程之间的可见性，就是一个线程修改后的结果，其他的线程能够立马知道。

（3）、有序性：为了提高执行效率，java中的编译器和处理器可以对指令进行重新排序，重新排序会影响多线程并发的正确性，有序性就是要保证不进行重新排序（保证线程操作的执行顺序）。

3）、volatile关键字的作用

其实volatile关键字的作用就是保证了可见性和有序性（不保证原子性），如果一个共享变量被volatile关键字修饰，那么如果一个线程修改了这个共享变量后，其他线程是立马可知的。为什么是这样的呢？比如，线程A修改了自己的共享变量副本，这时如果该共享变量没有被volatile修饰，那么本次修改不一定会马上将修改结果刷新到主存中，如果此时B去主存中读取共享变量的值，那么这个值就是没有被A修改之前的值。如果该共享变量被volatile修饰了，那么本次修改结果会强制立刻刷新到主存中，如果此时B去主存中读取共享变量的值，那么这个值就是被A修改之后的值了。

volatile能禁止指令重新排序，在指令重排序优化时，在volatile变量之前的指令不能在volatile之后执行，在volatile之后的指令也不能在volatile之前执行，所以它保证了有序性。

4）、synchronized关键字的作用

synchronized提供了同步锁的概念，被synchronized修饰的代码段可以防止被多个线程同时执行，必须一个线程把synchronized修饰的代码段都执行完毕了，其他的线程才能开始执行这段代码。

因为synchronized保证了在同一时刻，只能有一个线程执行同步代码块，所以执行同步代码块的时候相当于是单线程操作了，那么线程的可见性、原子性、有序性（线程之间的执行顺序）它都能保证了。

5）、volatile关键字和synchronized关键字的区别

volatile只能作用于变量，使用范围较小。synchronized可以用在变量、方法、类、同步代码块等，使用范围比较广。

volatile只能保证可见性和有序性，不能保证原子性。而可见性、有序性、原子性synchronized都可以包证。

volatile不会造成线程阻塞。synchronized可能会造成线程阻塞。

25、synchronized 和 Lock 有什么区别？

26、synchronized 和 ReentrantLock 区别是什么？

两者的共同点：

1. 都是用来协调多线程对共享对象、变量的访问

2. 都是可重入锁，同一线程可以多次获得同一个锁

3. 都保证了可见性和互斥性

两者的不同点：

1. ReentrantLock 显示的获得、释放锁，synchronized 隐式获得释放锁

2. ReentrantLock 可响应中断、可轮回，synchronized 是不可以响应中断的，为处理锁的

不可用性提供了更高的灵活性

3. ReentrantLock 是 API 级别的，synchronized 是 JVM 级别的

4. ReentrantLock 可以实现公平锁

5. ReentrantLock 通过 Condition 可以绑定多个条件

6. 底层实现不一样， synchronized 是同步阻塞，使用的是悲观并发策略，lock 是同步非阻

塞，采用的是乐观并发策略

7. Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言

实现。

8. synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；

而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，

因此使用 Lock 时需要在 finally 块中释放锁。

9. Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用 synchronized 时，

等待的线程会一直等待下去，不能够响应中断。

10. 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

11. Lock 可以提高多个线程进行读操作的效率，既就是实现读写锁等

27、说一下 atomic 的原理？

### 三、、集合 ：Set 、List、Map ###

1、HashMap的put的过程？

2、HashMap的底层原理？HashMap在JDK1.8的变化？为什么要用红黑树？

1）、JDK1.8之前，链表+数组；JDK1.8之后，链表+红黑树+数组

3、HashMap扩容时的流程

1）、扩容：创建一个新的Entry空数组，长度是原数组的2倍。

2）、ReHash：遍历原Entry数组，把所有的Entry重新Hash到新数组。为什么要重新Hash呢？因为长度扩大以后，Hash的规则也随之改变。

4、HashMap在put时放在新链表节点头部还是尾部？

1）、JDK1.8之前放在头部，1.8放在尾部。

5、HashMap 如何实现线程安全？

1）、通过collections.synchroizedMap()的接口；

2）、重写HashMap，通过java.util.Concurrent.ConcurrentHashMap（）,把hashmap里面的方法进行拆分。

6、hashMap 为什么是线程不安全的？

1）、hashMap不安全的线程不安全体现在会造成死循环、数据丢失、数据覆盖；在JDK1.7中：循环和数据丢失，在JDK1.8中数据覆盖

2）、HashMap的线程不安全主要是发生在扩容函数中，即根源是在transfer函数中，JDK1.7中HashMap的transfer函数如下：

3）、JDK1.7出现的问题，在JDK1.8中已经得到了很好的解决，如果你去阅读1.8的源码会发现找不到transfer函数，因为JDK1.8直接在resize函数中完成了数据迁移。另外说一句，JDK1.8在进行元素插入时使用的是尾插法。

HashMap的线程不安全主要体现在下面两个方面：

1）、在JDK1.7中，当并发执行扩容操作时会造成环形链和数据丢失的情况。

2）、在JDK1.8中，在并发执行put操作时会发生数据覆盖的情况。

7、hashTable和hashMap的区别？

1）、hashTable 线程安全      初始 11    负载因子0.75  扩容 2N     继承的父类不同    key和value不允许null值

2）、hashMap 线程不安全    初始 16    负载因子0.75  扩容 2N+1                  key和value允许null值

8、HashMap的循环遍历方式

1）、Iterator遍历EntrySet

2）、Iterator遍历keySet

3）、for-each遍历hashmap

4）、lambda遍历hashMap

5）、Stream API 遍历hashMap

9、ConcurrentHashMap 怎么保证线程安全？

1）、JDK 1.8 以前通过分段锁，JDK 1.8 以后通过 CAS + Synchronized

10、CocurrentHashMap在JDK1.8前后的锁有什么区别？

1）、JDK 1.8 以前锁分段，JDK 1.8 以后锁单个节点，锁粒度降低，并发度变高

11、TreeMap的原理：TreeMap的实现是红黑树算法的实现

12、ArrayList    LinkedList 区别 ？复杂度分析

1）、LinkedList：添加、删除速度快，查询相对于ArrayList较慢、线程不同步(不安全)、数据结构为链表

2）、ArrayList：查询速度快、线程不同步(不安全)、数据结构为数组

13、ArrayList 和 LinkedList 读写快慢的本质

1）、ArrayList : 查询数据快，是因为数组可以通过下标直接找到元素。 写数据慢有两个原因：一是数组复制过程需要时间，二是扩容需要实例化新数组也需要时间。

2）、LinkedList : 查询数据慢，是因为链表需要遍历每个元素直到找到为止。 写数据快有一个原因：除了实例化对象需要时间外，只需要修改指针即可完成添加和删除元素。

14、list如何实现排序？list中存对象，根据年龄、收入排序。

1）、排序比较-- Comparable接口

2）、 Collections.sort ()

3）、Stream

15、for循环list时删除元素会发生什么？

抛出异常；使用迭代器的remove方法解决

16、linkedhashmap为什么KEY VALUE 不能为空？

17、二叉树

20、Map、List、Set分别说一下你知道的线程安全类和线程不安全的类 ？ 什么场景用什么集合？待思考！！

1）、hashMap    线程不安全  无序，keyvalue可以为null    继承了AbstractMap类，实现了Map、Cloneable、Serializable接口 初始16，扩容加载因子为 0.75，一旦大于 0.75\*16之后，就会调用resize()进行扩容，扩容2倍，即32；

2）、LinkedHashMap   线程不安全    有序     继承了HashMap类，实现了Map接口    初始16，扩容加载因子为 0.75，一旦大于 0.75\*16之后，就会调用resize()进行扩容，扩容2倍，即32；

3）、TreeMap    线程不安全    有序    继承了AbstractMap类，实现了NavigableMap(继承了SortedMap)、Cloneable、Serializable接口 无初始化长度

4）、Hashtable   线程安全    ，keyvalue不可以为null        继承了Dictionary类，实现了Map、Cloneable、Serializable接口    初始 11，扩容加载因子为 0.75，一旦>0.75\*11之后，扩容到2n+1,即23；

5）、ConcurrentHashMap    线程安全    继承了AbstractMap类，实现了ConcurrentMap(继承了Map)、Serializable接口    初始 16，扩容加载因子为 0.75，一旦大于 0.75\*16之后，就会调用resize()进行扩容，扩容2倍，即32

6）、ArrayList        线程不安全        继承了AbstractList类，实现了List、RandomAccess、Cloneable、Serializable接口    认初始化长度为 10，扩容规则为 0.5倍的原容量加1，即一次扩容后的长度为 16；

7）、LinkedList        线程不安全        继承了AbstractSequentialList类，实现了List、Deque、Cloneable、Serializable接口

8）、Vector            线程安全        继承了AbstractList类  synchronized  性能差

9）、HashSet            线程不安全        继承了AbstractSet类，初始16，扩容加载因子为 0.75，扩容大小为原来的一倍。

10）、HashSet 中的元素，作为 HashMap 键值对的 Key 存储，而 Value 由一个统一的值保存。

11）、TreeSet            线程不安全    有序（元素大小顺序）无重    继承了AbstractSet类

12）、TreeSet 中的元素，作为 TreeMap 键值对的 Key 存储，而 Value 由一个统一的值保存。

13）、LinkedHashSet    线程不安全    有序（写入顺序）无重    继承了HashSet类

14）、LinkedHashSet 中的元素，作为 LinkedHashMap 键值对的 Key 存储，而 Value 由一个统一的值保存。

由于 HashSet、TreeSet、LinkedHashSet的底层实现为HashMap、TreeMap、LinkedHashMap，所以Set集合是非线程安全的。

如果要实现 Set 集合的线程安全，可以使用 ConcurrentHashMap 实现一个Set集合。

### 四、网络 ###

1、HTTP和HTTPS的区别

1）、https协议需要到CA  （Certificate Authority，证书颁发机构）申请证书。

2）、http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。

3）、http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。

4）、http的连接很简单，是无状态的。Https协议是由SSL+Http协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。

2、UDP和TCP的区别

1）、TCP提供面向连接的传输，通信前要先建立连接（三次握手机制）； UDP提供无连接的传输，通信前不需要建立连接。

2）、TCP提供可靠的传输（有序，无差错，不丢失，不重复）； UDP提供不可靠的传输。

3）、TCP面向字节流的传输，因此它能将信息分割成组，并在接收端将其重组； UDP是面向数据报的传输，没有分组开销。

4）、TCP提供拥塞控制和流量控制机制； UDP不提供拥塞控制和流量控制机制。

3、三次握手、四次挥手

背景：TCP位于传输层，作用是提供可靠的字节流服务，为了准确无误地将数据送达目的地，TCP协议采纳三次握手策略。

1）、发送端首先发送一个带有SYN（synchronize）标志地数据包给接收方。

2）、接收方接收后，回传一个带有SYN/ACK标志的数据包传递确认信息，表示我收到了。

3）、最后，发送方再回传一个带有ACK标志的数据包，代表我知道了，表示’握手‘结束。

1）、第一次挥手：Client发送一个FIN，用来关闭Client到Server的数据传送，Client进入FIN\_WAIT\_1状态。

2）、第二次挥手：Server收到FIN后，发送一个ACK给Client，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号），Server进入CLOSE\_WAIT状态。

3）、第三次挥手：Server发送一个FIN，用来关闭Server到Client的数据传送，Server进入LAST\_ACK状态。

4）、第四次挥手：Client收到FIN后，Client进入TIME\_WAIT状态，接着发送一个ACK给Server，确认序号为收到序号+1，Server进入CLOSED状态，完成四次挥手

4、介绍各种网络协议。

1）、TCP: 传输控制协议， TCP是一个面向连接的协议，为用户进程提供可靠的全双工字节流。TCP套接字是一种流套接字。 TCP关心确认、超时和重传之类的细节。大多数因特网应用程序使用TCP。

2）、UDP： 用户数据报协议，UDP是一个无连接协议， UDP套接字是一种数据报套接字。UDP数据报不能保证终于到达它们的目的。

3）、 IPv4： IPv4给TCP、UDP、SCTP、ICMP和IGMP提供分组递送服务

4）、 IPv6： IPv4的一个替代品设计的； 其主要变化是使用128位更大的地址以应对因特网的爆发性增长。IPv6给TCP、UDP、SCTP和ICMPv6提供分组递送服务。

5、DNS在网络层用哪个协议，为什么。

1）、网际层协议：包括：IP协议、ICMP协议、ARP协议、RARP协议。

2）、传输层协议：TCP协议、UDP协议。

3）、应用层协议：FTP、Telnet、SMTP、HTTP、RIP、NFS、DNS

6、介绍HTTPS协议，详述SSL建立连接过程。

7、http 响应码 301 和 302 代表的是什么？有什么区别？

8、OSI 的七层模型都有哪些

9、如何实现跨域

4、什么是RPC？

### 五、设计模式 ###

1）、单例模式：

饿汉模式 ：线程安全，但是效率低

/\*\*

\* 懒汉式单例

\*/

public class Singleton2 \{

// 私有构造

private Singleton2() \{\}

private static Singleton2 single = null;

public static Singleton2 getInstance() \{

if(single == null)\{

single = new Singleton2();

return single;

优点：简单，不存在多线程同步问题，避免了synchronized所造成的性能问题；

缺点：当类Singleton被加载的时候，会初始化static的single ，静态变量被创建并分配内存空间之后，这个static的single 对象会一直占用这段内存，当类被卸载时，静态变量被销毁，释放所占有的内存，因此在某些特定条件下会耗费内存。

/\*\*

\* 懒汉式：线程安全

\*/

public class Singleton5 \{

// 私有构造方法（防止通过 new Singleton5()去实例化）

private Singleton5() \{

// Singleton5类型的变量（不初始化，注意这里没有使用final关键字）

private static Singleton5 instance;

// 静态的方法（调用时再初始化Singleton5，使用synchronized 避免多线程访问时，可能造成重的复初始化问题）

public static synchronized  Singleton5 getInstance() \{

if (instance == null) \{

instance = new Singleton5();

return instance;

懒汉式 ： 线程非安全

优点：简单，当类Singleton2被加载的时候，静态变量static的single未被创建并分配内存空间，当getInstance方法第一次被调用时，初始化signle变量，并分配内存，因此在某些特定条件下会节约了内存；

缺点：并发环境下很可能出现多个Singleton2实例。

/\*\*

\* 懒汉式：线程安全

\*/

public class Singleton5 \{

// 私有构造方法（防止通过 new Singleton5()去实例化）

private Singleton5() \{

// Singleton5类型的变量（不初始化，注意这里没有使用final关键字）

private static Singleton5 instance;

// 静态的方法（调用时再初始化Singleton5，使用synchronized 避免多线程访问时，可能造成重的复初始化问题）

public static synchronized  Singleton5 getInstance() \{

if (instance == null) \{

instance = new Singleton5();

return instance;

懒汉式 ： 线程非安全

缺点：并发环境下很可能出现多个Singleton2实例。

/\*\*\*

\* 双重锁模式

\*/

public class Singleton4 \{

private Singleton4() \{ \}

//静态私有变量(不初始化，不使用final关键字，使用volatile保证了多线程访问时instance变量的可见性，避免了instance初始化时其他变量属性还没赋值完时，被另外线程调用)

private static volatile Singleton4 instance;

public static Singleton4 getIstance() \{

if (instance == null) \{

synchronized (Singleton4.class) \{

if (instance == null) \{

instance = new Singleton4();

return instance;

双重锁模式 ： 线程安全，效率高

写起来复杂，但是内存占用地，效率高，线程安全，多线程操作原子性。

2）、适配器模式： 就是一个中间件，将不匹配的两个接口或者类，通过这个适配器链接之后变得匹配。类似于我们的充电器转换头等等。

适配器模式有三种：类适配器、对象适配器、接口适配器。我们常用的应该属于接口适配器了

3）、工厂模式：

4）、观察者模式： 观察者模式又被称为发布-订阅模式，在对象之间定义一对多的关系，这样在一个对象改变状态，依赖它的对象就会收到通知。

观察者模式一般用于实现订阅功能的场景，例如公众号订阅、微博订阅、抖音关注；当我们订阅的人发布了新动态，我们就会收到。

5）、策略模式：

6）、代理设计模式

2、简单工厂和抽象工厂有什么区别

2021年最新面试基础题

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java 基础高频面试题（2022年最新版）

相关 2019年java最新面试题

相关 2020年最新Redis面试题

相关 2021年最新k8s面试题

相关 2021 最新 webpack 面试题

相关 2021年最新面试基础题

相关 2021年最新ASP.NET MVC面试题汇总

相关 2021最新Spring Boot 面试题

相关 Java最新2021年面试题大汇总，附答案

相关 2018年最新PHP面试题