10年java程序员,2024年正好35岁,2024年11月公司裁员,记录自己找工作时候复习的一些要点。
java基础
hashCode()与equals()的相关规定
- 如果两个对象相等,则hashcode一定也是相同的
- 两个对象相等,对两个对象分别调用equals方法都返回true
- 两个对象有相同的hashcode值,它们也不一定是相等的
“你重写过 hashcode 和 equals 么,为什么重写equals时必须重写hashCode
方法?”
BIO,NIO,AIO 有什么区别?
-
简答
-
BIO:Block IO 同步阻塞式 IO,就是我们平常使用的传统 IO,它的特点是模式简单使用方
便,并发处理能力低。 -
NIO:Non IO 同步非阻塞 IO,是传统 IO 的升级,客户端和服务器端通过 Channel(通道)
通讯,实现了多路复用。 -
AIO:Asynchronous IO 是 NIO 的升级,也叫 NIO2,实现了异步非堵塞 IO ,异步 IO 的操
作基于事件和回调机制。 -
详细回答
-
BIO (Blocking I/O): 同步阻塞I/O模式,数据的读取写入必须阻塞在一个线程内等待其完
成。在活动连接数不是特别高(小于单机1000)的情况下,这种模型是比较不错的,可以让
每一个连接专注于自己的 I/O 并且编程模型简单,也不用过多考虑系统的过载、限流等问
题。线程池本身就是一个天然的漏斗,可以缓冲一些系统处理不了的连接或请求。但是,当
面对十万甚至百万级连接的时候,传统的 BIO 模型是无能为力的。因此,我们需要一种更高
效的 I/O 处理模型来应对更高的并发量。 -
NIO (New I/O): NIO是一种同步非阻塞的I/O模型,在Java 1.4 中引入了NIO框架,对应
java.nio 包,提供了 Channel , Selector,Buffer等抽象。NIO中的N可以理解为Nonblocking,不单纯是New。它支持面向缓冲的,基于通道的I/O操作方法。 NIO提供了与传统
BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和
ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模
式。阻塞模式使用就像传统中的支持一样,比较简单,但是性能和可靠性都不好;非阻塞模
式正好与之相反。对于低负载、低并发的应用程序,可以使用同步阻塞I/O来提升开发速率和
更好的维护性;对于高负载、高并发的(网络)应用,应使用 NIO 的非阻塞模式来开发 -
AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它
是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的,也就是应用操作之后会直接
返回,不会堵塞在那里,当后台处理完成,操作系统会通知相应的线程进行后续的操作。AIO
是异步IO的缩写,虽然 NIO 在网络操作中,提供了非阻塞的方法,但是 NIO 的 IO 行为还是
同步的。对于 NIO 来说,我们的业务线程是在 IO 操作准备好时,得到通知,接着就由这个
线程自行进行 IO 操作,IO操作本身是同步的。查阅网上相关资料,我发现就目前来说 AIO
的应用还不是很广泛,Netty 之前也尝试使用过 AIO,不过又放弃了。
java集合框架
常用的集合类有哪些?
- Map接口和Collection接口是所有集合框架的父接口:
1、 Collection接口的子接口包括:Set接口和List接口;
2、 Map接口的实现类主要有:HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等;
3、 Set接口的实现类主要有:HashSet、TreeSet、LinkedHashSet等;
4、 List接口的实现类主要有:ArrayList、LinkedList、Stack以及Vector等;
List,Set,Map三者的区别?
-
Java 容器分为 Collection 和 Map 两大类,Collection集合的子接口有Set、List、Queue三种子接
口。我们比较常用的是Set、List,Map接口不是collection的子接口。 -
Collection集合主要有List和Set两大接口
-
List:一个有序(元素存入集合的顺序和取出的顺序一致)容器,元素可以重复,可以插入多
个null元素,元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。 -
Set:一个无序(存入和取出顺序有可能不一致)容器,不可以存储重复元素,只允许存入一
个null元素,必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及TreeSet。 -
Map是一个键值对集合,存储键、值和之间的映射。 Key无序,唯一;value 不要求有序,允许重
复。Map没有继承于Collection接口,从Map集合中检索元素时,只要给出键对象,就会返回对应
的值对象。 -
Map 的常用实现类:HashMap、TreeMap、HashTable、LinkedHashMap、ConcurrentHashMap
集合框架底层数据结构
- Collection
1、 List;
* Arraylist: Object数组
* Vector: Object数组
* LinkedList: 双向循环链表
2、 Set;
* HashSet(无序,唯一):基于 HashMap 实现的,底层采用 HashMap 来保存元素
* LinkedHashSet: LinkedHashSet 继承与 HashSet,并且其内部是通过 LinkedHashMap 来实现的。有点类似于我们之前说的LinkedHashMap 其内部是基于 Hashmap 实现一样,不过还是有一点点区别的。
* TreeSet(有序,唯一): 红黑树(自平衡的排序二叉树。)
-
Map
-
HashMap: JDK1.8之前HashMap由数组+链表组成的,数组是HashMap的主体,链表则是
主要为了解决哈希冲突而存在的(“拉链法”解决冲突).JDK1.8以后在解决哈希冲突时有了较
大的变化,当链表长度大于阈值(默认为8)时,将链表转化为红黑树,以减少搜索时间 -
LinkedHashMap:LinkedHashMap 继承自 HashMap,所以它的底层仍然是基于拉链式散
列结构即由数组和链表或红黑树组成。另外,LinkedHashMap 在上面结构的基础上,增加
了一条双向链表,使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的
操作,实现了访问顺序相关逻辑。 -
HashTable: 数组+链表组成的,数组是 HashMap 的主体,链表则是主要为了解决哈希冲突
而存在的 -
TreeMap: 红黑树(自平衡的排序二叉树)
哪些集合类是线安全的?
- Vector:就比Arraylist多了个 synchronized (线程安全),因为效率较低,现在已经不太建议使
用。 - hashTable:就比hashMap多了个synchronized (线程安全),不建议使用。
- ConcurrentHashMap:是Java5中支持高并发、高吞吐量的线程安全HashMap实现。它由Segment数组结构和HashEntry数组结构组成。Segment数组在ConcurrentHashMap里扮演锁的角色,HashEntry则用于存储键-值对数据。一个ConcurrentHashMap里包含一个Segment数组,Segment的结构和HashMap类似,是一种数组和链表结构;一个Segment里包含一个HashEntry数组,每个HashEntry是一个链表结构的元素;每个Segment守护着一个HashEntry数组里的元素,当对HashEntry数组的数据进行修改时,必须首先获得它对应的Segment锁。(推荐使用)
说一下 ArrayList 的优缺点
-
ArrayList的优点如下:
-
ArrayList 底层以数组实现,是一种随机访问模式。ArrayList 实现了 RandomAccess 接口,因此查找的时候非常快。
-
ArrayList 在顺序添加一个元素的时候非常方便。
-
ArrayList 的缺点如下:
-
删除元素的时候,需要做一次元素复制操作。如果要复制的元素很多,那么就会比较耗费性能。
-
插入元素的时候,也需要做一次元素复制操作,缺点同上。
-
ArrayList 比较适合顺序添加、随机访问的场景。
说一下 HashSet 的实现原理?
- HashSet 是基于 HashMap 实现的,HashSet的值存放于HashMap的key上,HashMap的value统一为present,因此 HashSet 的实现比较简单,相关 HashSet 的操作,基本上都是直接调用底层HashMap 的相关方法来完成,HashSet 不允许重复的值。
HashSet如何检查重复?HashSet是如何保证数据不可重复的?
- 向HashSet 中add ()元素时,判断元素是否存在的依据,不仅要比较hash值,同时还要结合equles 方法比较。
- HashSet 中的add ()方法会使用HashMap 的put()方法。
- HashMap 的 key 是唯一的,由源码可以看出 HashSet 添加进去的值就是作为HashMap 的key,并且在HashMap中如果K/V相同时,会用新的V覆盖掉旧的V,然后返回旧的V。所以不会重复(HashMap 比较key是否相等是先比较hashcode 再比较equals )。
说一下HashMap的实现原理?
jdk1.7 数组+链表
jdk1.8 数组+链表+红黑树
不同 | JDK 1.7 | JDK 1.8 |
---|---|---|
存储结构 | 数组 + 链表 | 数组 + 链表 + 红黑树 |
初始化方式 | 单独函数: inflateTable() | 直接集成到了扩容函数 resize() 中 |
hash值计算方式 | 扰动处理 = 9次扰动 = 4次位运算 + 5次异或运算 | 扰动处理 = 2次扰动 = 1次位运算 + 1次异或运算 |
存放数据的规则 | 无冲突时,存放数组;冲突时,存放链表 | 无冲突时,存放数组;冲突 & 链表长度 <8:存放单链表;冲突 & 链表长度 > 8:树化并存放红黑树 |
插入数据方式 | 头插法(先讲原位置的数据移到后1位,再插入数据到该位置) | 尾插法(直接插入到链表尾部/红黑树) |
扩容后存储位置的计算方式 | 全部按照原来方法进行计算(即hashCode ->> 扰动函数 ->> (h&length-1)) | 按照扩容后的规律计算(即扩容后的位置=原位置 or 原位置 + 旧容量) |
put
get
扩容
并发编程
三个必要因素
- 原子性:原子,即一个不可再被分割的颗粒。原子性指的是一个或多个操作要么全部执行成功要么
全部执行失败。 - 可见性:一个线程对共享变量的修改,另一个线程能够立刻看到。(synchronized,volatile)
- 有序性:程序执行的顺序按照代码的先后顺序执行。(处理器可能会对指令进行重排序)
Java 程序中怎么保证多线程的运行安全?
-
出现线程安全问题的原因一般都是三个原因:
-
线程切换带来的原子性问题 解决办法:使用多线程之间同步synchronized或使用锁(lock)。
-
缓存导致的可见性问题 解决办法:synchronized、volatile、LOCK,可以解决可见性问题
-
编译优化带来的有序性问题 解决办法:Happens-Before 规则可以解决有序性问题
形成死锁的四个必要条件是什么
- 互斥条件:在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源,就只能等
待,直至占有资源的进程用毕释放。 - 占有且等待条件:指进程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进
程占有,此时请求进程阻塞,但又对自己已获得的其它资源保持不放。 - 不可抢占条件:别人已经占有了某项资源,你不能因为自己也需要该资源,就去把别人的资源抢过
来。 - 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。(比如一个进程集合,A在
等B,B在等C,C在等A)
创建线程的四种方式
- 继承 Thread 类;
public class MyThread extends Thread {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " run()方法正在执行...");}
- 实现 Runnable 接口;
public class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " run()方法执行中...");}
- 实现 Callable 接口;
public class MyCallable implements Callable<Integer> {@Overridepublic Integer call() {System.out.println(Thread.currentThread().getName() + " call()方法执行中...");return 1;}}
- 使用匿名内部类方式
public class CreateRunnable {public static void main(String[] args) {//创建多线程创建开始Thread thread = new Thread(new Runnable() {public void run() {for (int i = 0; i < 10; i++) {System.out.println("i:" + i);}}});thread.start();}}
18. 说一下 runnable 和 callable 有什么区别
相同点:
- 都是接口
- 都可以编写多线程程序
- 都采用Thread.start()启动线程
主要区别: - Runnable 接口 run 方法无返回值;Callable 接口 call 方法有返回值,是个泛型,和Future、
FutureTask配合可以用来获取异步执行的结果 - Runnable 接口 run 方法只能抛出运行时异常,且无法捕获处理;Callable 接口 call 方法允许抛出
异常,可以获取异常信息 注:Callalbe接口支持返回执行结果,需要调用FutureTask.get()得到,
此方法会阻塞主进程的继续往下执行,如果不调用不会阻塞。
线程的 run()和 start()有什么区别?
- 每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的,run()方法称为线程
体。通过调用Thread类的start()方法来启动一个线程。 - start() 方法用于启动线程,run() 方法用于执行线程的运行时代码。run() 可以重复调用,而 start()
只能调用一次。 - start()方法来启动一个线程,真正实现了多线程运行。调用start()方法无需等待run方法体代码执
行完毕,可以直接继续执行其他的代码; 此时线程是处于就绪状态,并没有运行。 然后通过此
Thread类调用方法run()来完成其运行状态, run()方法运行结束, 此线程终止。然后CPU再调度
其它线程。 - run()方法是在本线程里的,只是线程里的一个函数,而不是多线程的。 如果直接调用run(),其实
就相当于是调用了一个普通函数而已,直接待用run()方法必须等待run()方法执行完毕才能执行下
面的代码,所以执行路径还是只有一条,根本就没有线程的特征,所以在多线程执行时要使用
start()方法而不是run()方法。
什么是 Callable 和 Future?
- Callable 接口类似于 Runnable,从名字就可以看出来了,但是 Runnable 不会返回结果,并且无
法抛出返回结果的异常,而 Callable 功能更强大一些,被线程执行后,可以返回值,这个返回值
可以被 Future 拿到,也就是说,Future 可以拿到异步执行任务的返回值。 - Future 接口表示异步任务,是一个可能还没有完成的异步任务的结果。所以说 Callable用于产生
结果,Future 用于获取结果。
线程状态
sleep() 和 wait() 有什么区别?
两者都可以暂停线程的执行
- 类的不同:sleep() 是 Thread线程类的静态方法,wait() 是 Object类的方法。
- 是否释放锁:sleep() 不释放锁;wait() 释放锁。
- 用途不同:Wait 通常被用于线程间交互/通信,sleep 通常被用于暂停执行。
- 用法不同:wait() 方法被调用后,线程不会自动苏醒,需要别的线程调用同一个对象上的 notify()
或者 notifyAll() 方法。sleep() 方法执行完成后,线程会自动苏醒。或者可以使用wait(long
timeout)超时后线程会自动苏醒。
为什么线程通信的方法 wait(), notify()和 notifyAll()被定义在 Object 类里?
- 因为Java所有类的都继承了Object,Java想让任何对象都可以作为锁,并且 wait(),notify()等方法
用于等待对象的锁或者唤醒线程,在 Java 的线程中并没有可供任何对象使用的锁,所以任意对象
调用方法一定定义在Object类中。 - 有的人会说,既然是线程放弃对象锁,那也可以把wait()定义在Thread类里面啊,新定义的线程继
承于Thread类,也不需要重新定义wait()方法的实现。然而,这样做有一个非常大的问题,一个线
程完全可以持有很多锁,你一个线程放弃锁的时候,到底要放弃哪个锁?当然了,这种设计并不是
不能实现,只是管理起来更加复杂。
为什么 wait(), notify()和 notifyAll()必须在同步方法或者同步块中被调用?
- 当一个线程需要调用对象的 wait()方法的时候,这个线程必须拥有该对象的锁,接着它就会释放这
个对象锁并进入等待状态直到其他线程调用这个对象上的 notify()方法。同样的,当一个线程需要
调用对象的 notify()方法时,它会释放这个对象的锁,以便其他在等待的线程就可以得到这个对象
锁。由于所有的这些方法都需要线程持有对象的锁,这样就只能通过同步来实现,所以他们只能在
同步方法或者同步块中被调用。
重排序遵守的规则
- as-if-serial:
1、 不管怎么排序,结果不能改变;
2、 不存在数据依赖的可以被编译器和处理器重排序;
3、 一个操作依赖两个操作,这两个操作如果不存在依赖可以重排序;
4、 单线程根据此规则不会有问题,但是重排序后多线程会有问题;
as-if-serial规则和happens-before规则的区别
- as-if-serial语义保证单线程内程序的执行结果不被改变,happens-before关系保证正确同步的多
线程程序的执行结果不被改变。 - as-if-serial语义给编写单线程程序的程序员创造了一个幻境:单线程程序是按程序的顺序来执行
的。happens-before关系给编写正确同步的多线程程序的程序员创造了一个幻境:正确同步的多
线程程序是按happens-before指定的顺序来执行的。 - as-if-serial语义和happens-before这么做的目的,都是为了在不改变程序执行结果的前提下,尽
可能地提高程序执行的并行度。
多线程中 synchronized 锁升级的原理是什么?
- synchronized 锁升级原理:在锁对象的对象头里面有一个 threadid 字段,在第一次访问的时候
threadid 为空,jvm 让其持有偏向锁,并将 threadid 设置为其线程 id,再次进入的时候会先判断
threadid 是否与其线程 id 一致,如果一致则可以直接使用此对象,如果不一致,则升级偏向锁为
轻量级锁,通过自旋循环一定次数来获取锁,执行一定次数之后,如果还没有正常获取到要使用的
对象,此时就会把锁从轻量级升级为重量级锁,此过程就构成了 synchronized 锁的升级。
锁的升级的目的:锁升级是为了减低了锁带来的性能消耗。在 Java 6 之后优化 synchronized 的实现方
式,使用了偏向锁升级为轻量级锁再升级到重量级锁的方式,从而减低了锁带来的性能消耗。
- 偏向锁,顾名思义,它会偏向于第一个访问锁的线程,如果在运行过程中,同步锁只有一个线程访
问,不存在多线程争用的情况,则线程是不需要触发同步的,减少加锁/解锁的一些CAS操作(比
如等待队列的一些CAS操作),这种情况下,就会给线程加一个偏向锁。 如果在运行过程中,遇
到了其他线程抢占锁,则持有偏向锁的线程会被挂起,JVM会消除它身上的偏向锁,将锁恢复到标
准的轻量级锁。 - 轻量级锁是由偏向所升级来的,偏向锁运行在一个线程进入同步块的情况下,当第二个线程加入锁
争用的时候,轻量级锁就会升级为重量级锁; - 重量级锁是synchronized ,是 Java 虚拟机中最为基础的锁实现。在这种状态下,Java 虚拟机会阻
塞加锁失败的线程,并且在目标锁被释放的时候,唤醒这些线程。