秋招java面试题总结1（自用）

最新推荐文章于 2022-12-15 14:13:35 发布

LzlGo

最新推荐文章于 2022-12-15 14:13:35 发布

阅读量231

点赞数

文章标签： java 面试开发语言

原文链接：https://www.nowcoder.com/exam/interview/detail?questionClassifyId=0&questionId=2412943&questionJobId=160&type=1

版权

1.请你说说线程和协程的区别

得分点 :地址空间、开销、并发性、内存

标准回答 :进程和线程的主要差别在于它们是不同的操作系统资源管理方式。

1.进程有独立的地址空间,线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间；

进程和线程切换时,需要切换进程和线程的上下文,进程的上下文切换时间开销远远大于线程上下文切换时间,耗费资源较大,效率要差一些；
进程的并发性较低,线程的并发性较高；
每个独立的进程有一个程序运行的入口、顺序执行序列和程序的出口,但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制；
系统在运行的时候会为每个进程分配不同的内存空间；而对线程而言,除了 CPU 外,系统不会为线程分配内存（线程所使用的资源来自其所属进程的资源）,线程组之间只能共享资源；
一个进程崩溃后,在保护模式下不会对其他进程产生影响,但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

协程与线程的区别

1).一个线程可以多个协程，一个进程也可以单独拥有多个协程。
2) 线程进程都是同步机制，而协程则是异步。
3)协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态。
4)线程是抢占式，而协程是非抢占式的，所以需要用户自己释放使用权来切换到其他协程，因此同一时间其实只有一个协程拥有运行权，相当于单线程的能力。
5)协程并不是取代线程, 而且抽象于线程之上, 线程是被分割的CPU资源, 协程是组织好的代码流程, 协程需要线程来承载运行,
线程是协程的资源, 但协程不会直接使用线程, 协程直接利用的是执行器(Interceptor), 执行器可以关联任意线程或线程池,
可以使当前线程, UI线程, 或新建新程.。 6)线程是协程的资源。协程通过Interceptor来间接使用线程这个资源。

2.MySQL索引,以及它们的好处和坏处

解题思路
得分点 :检索效率、存储资源、索引维护

标准回答: 索引就像指向表行的指针,是一种允许查询操作快速确定哪些行符合WHERE子句中的条件,并检索到这些行的其他列值的数据结构；

索引主要有普通索引、唯一索引、主键索引、外键索引、全文索引、复合索引几种；
在大数据量的查询中,合理使用索引的优点非常明显,不仅能大幅提高匹配where条件的检索效率,还能用于排序和分组操作的加速。当时索引如果使用不当也有比较大的坏处：比如索引必定会增加存储资源的消耗；同时也增大了插入、更新和删除操作的维护成本,因为每个增删改操作后相应列的索引都必须被更新。
加分回答:只要创建了索引,就一定会走索引吗？不一定。比如,在使用组合索引的时候,如果没有遵从“最左前缀”的原则进行搜索,则索引是不起作用的。举例,假设在id、name、age字段上已经成功建立了一个名为MultiIdx的组合索引。索引行中按id、name、age的顺序存放,索引可以搜索id、（id,name）、（id, name, age）字段组合。如果列不构成索引最左面的前缀,那么MySQL不能使用局部索引,如（age）或者（name,age）组合则不能使用该索引查询。

3.多线程

解题思路
得分点 :线程和进程的关系、为什么使用多线程

标准回答
线程是操作系统调度的最小单元,它可以让一个进程并发地处理多个任务,也叫轻量级进程。所以,在一个进程里可以创建多个线程,这些线程都拥有各自的计数器、堆栈、局部变量,并且能够共享进程内的资源。

由于共享资源,处理器便可以在这些线程之间快速切换,从而让使用者感觉这些线程在同时执行。总的来说,操作系统可以同时执行多个任务,每个任务就是一个进程。进程可以同时执行多个任务,每个任务就是一个线程。一个程序运行之后至少有一个进程,而一个进程可以包含多个线程,但至少要包含一个线程。使用多线会给开发人员带来显著的好处,而使用多线程的原因主要有以下几点：
1.更多的CPU核心现代计算机处理器性能的提升方式,已经从追求更高的主频向追求更多的核心发展,所以处理器的核心数量会越来越多,充分地利用处理器的核心则会显著地提高程序的性能。而程序使用多线程技术,就可以将计算逻辑分配到多个处理器核心上,显著减少程序的处理时间,从而随着更多处理器核心的加入而变得更有效率。

更快的响应时间我们经常要针对复杂的业务编写出复杂的代码,如果使用多线程技术,就可以将数据一致性不强的操作派发给其他线程处理（也可以是消息队列）,如上传图片、发送邮件、生成订单等。这样响应用户请求的线程就能够尽快地完成处理,大大地缩短了响应时间,从而提升了用户体验。 3. 更好的编程模型 Java为多线程编程提供了良好且一致的编程模型,使开发人员能够更加专注于问题的解决,开发者只需为此问题建立合适的业务模型,而无需绞尽脑汁地考虑如何实现多线程。一旦开发人员建立好了业务模型,稍作修改就可以将其方便地映射到Java提供的多线程编程模型上。

4.怎么保证线程安全

解题思路
得分点原子类、volatile、锁

标准回答
Java保证线程安全的方式有很多,其中较为常用的有三种,按照资源占用情况由轻到重排列,这三种保证线程安全的方式分别是原子类、volatile、锁。

1.JDK从1.5开始提供了java.util.concurrent.atomic包,这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。在atomic包里一共提供了17个类,按功能可以归纳为4种类型的原子更新方式,分别是原子更新基本类型、原子更新引用类型、原子更新属性、原子更新数组。无论原子更新哪种类型,都要遵循“比较和替换”规则,即比较要更新的值是否等于期望值,如果是则更新,如果不是则失败。
2.volatile是轻量级的synchronized,它在多处理器开发中保证了共享变量的“可见性”,从而可以保证单个变量读写时的线程安全。可见性问题是由处理器核心的缓存导致的,每个核心均有各自的缓存,而这些缓存均要与内存进行同步。volatile具有如下的内存语义：当写一个volatile变量时,该线程本地内存中的共享变量的值会被立刻刷新到主内存；当读一个volatile变量时,该线程本地内存会被置为无效,迫使线程直接从主内存中读取共享变量。
3.原子类和volatile只能保证单个共享变量的线程安全,锁则可以保证临界区内的多个共享变量的线程安全,Java中加锁的方式有两种,分别是synchronized关键字和Lock接口。synchronized是比较早期的API,在设计之初没有考虑到超时机制、非阻塞形式,以及多个条件变量。若想通过升级的方式让它支持这些相对复杂的功能,则需要大改它的语法结构,不利于兼容旧代码。因此,JDK的开发团队在1.5新增了Lock接口,并通过Lock支持了上述的功能,即：支持响应中断、支持超时机制、支持以非阻塞的方式获取锁、支持多个条件变量（阻塞队列）。
加分回答实现线程安全的方式有很多,除了上述三种方式之外,还有如下几种方式： 1. 无状态设计线程安全问题是由多线程并发修改共享变量引起的,如果在并发环境中没有设计共享变量,则自然就不会出现线程安全问题了。这种代码实现可以称作“无状态实现”,所谓状态就是指共享变量。 2. 不可变设计如果在并发环境中不得不设计共享变量,则应该优先考虑共享变量是否为只读的,如果是只读场景就可以将共享变量设计为不可变的,这样自然也不会出现线程安全问题了。具体来说,就是在变量前加final修饰符,使其不可被修改,如果变量是引用类型,则将其设计为不可变类型（参考String类）。 3. 并发工具 java.util.concurrent包提供了几个有用的并发工具类,一样可以保证线程安全： - Semaphore：就是信号量,可以控制同时访问特定资源的线程数量。 - CountDownLatch：允许一个或多个线程等待其他线程完成操作。 - CyclicBarrier：让一组线程到达一个屏障时被阻塞,直到最后一个线程到达屏障时,屏障才会打开,所有被屏障拦截的线程才会继续运行。 4. 本地存储我们也可以考虑使用ThreadLocal存储变量,ThreadLocal可以很方便地为每一个线程单独存一份数据,也就是将需要并发访问的资源复制成多份。这样一来,就可以避免多线程访问共享变量了,它们访问的是自己独占的资源,它从根本上隔离了多个线程之间的数据共享。

5.死锁定义及发生的条件

得分点争夺共享资源、相互等待、互斥条件、请求和保持条件、不剥夺条件、环路等待条件

标准回答:

1.死锁两个或两个以上的进程在执行过程中,因争夺共享资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。这些永远在互相等待的进程称为死锁进程。
2.死锁的发生必须具备以下四个必要条件：
2.1互斥条件：指进程对所分配到的资源进行排它性使用,即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源,则请求者只能等待,直至占有资源的进程用毕释放；
2.2请求和保持条件：指进程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进程占有,此时请求进程阻塞,但又对自己已获得的其它资源保持不放；
2.3不剥夺条件：指进程已获得的资源,在未使用完之前,不能被剥夺,只能在使用完时由自己释放；
2.4 环路等待条件：指在发生死锁时,必然存在一个进程——资源的环形链,即进程集合 {P0,P1,P2,···,Pn} 中的 P0 正在等待一个 P1 占用的资源；P1 正在等待 P2 占用的资源,……,Pn 正在等待已被 P0 占用的资源。

6.请你说说进程间的通信方式

得分点管道、命名管道、信号、消息队列、共享内存、内存映射、信号量、Socket

标准答案进程间通信主要包括：管道、命名管道、信号、消息队列、共享内存、内存映射、信号量、Socket

管道管道也叫无名（匿名）管道,它是是 UNIX 系统 IPC（进程间通信）的最古老形式,所有的 UNIX 系统都支持这种通信机制。管道本质其实是内核中维护的一块内存缓冲区,Linux 系统中通过 pipe() 函数创建管道,会生成两个文件描述符,分别对应管道的读端和写端。无名管道只能用于具有亲缘关系的进程间的通信。
命名管道匿名管道,由于没有名字,只能用于亲缘关系的进程间通信。为了克服这个缺点,提出了有名管道（FIFO）,也叫命名管道、FIFO文件。有名管道（FIFO）不同于匿名管道之处在于它提供了一个路径名与之关联,以 FIFO 的文件形式存在于文件系统中,并且其打开方式与打开一个普通文件是一样的,这样即使与 FIFO 的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过 FIFO 相互通信,因此,通过 FIFO 不相关的进程也能交换数据。
信号信号是 Linux 进程间通信的最古老的方式之一,是事件发生时对进程的通知机制,有时也称之为软件中断,它是在软件层次上对中断机制的一种模拟,是一种异步通信的方式。信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断,转而处理某一个突发事件。
消息队列消息队列就是一个消息的链表,可以把消息看作一个记录,具有特定的格式以及特定的优先级,对消息队列有写权限的进程可以向消息队列中按照一定的规则添加新消息,对消息队列有读权限的进程则可以从消息队列中读走消息,消息队列是随内核持续的。
共享内存共享内存允许两个或者多个进程共享物理内存的同一块区域（通常被称为段）。由于一个共享内存段会称为一个进程用户空间的一部分,因此这种 IPC 机制无需内核介入。所有需要做的就是让一个进程将数据复制进共享内存中,并且这部分数据会对其他所有共享同一个段的进程可用。与管道等要求发送进程将数据从用户空间的缓冲区复制进内核内存和接收进程将数据从内核内存复制进用户空间的缓冲区的做法相比,这种 IPC 技术的速度更快。
内存映射内存映射（Memory-mapped I/O）是将磁盘文件的数据映射到内存,用户通过修改内存就能修改磁盘文件。
信号量信号量主要用来解决进程和线程间并发执行时的同步问题,进程同步是并发进程为了完成共同任务采用某个条件来协调它们的活动。对信号量的操作分为 P 操作和 V 操作,P 操作是将信号量的值减 1,V 操作是将信号量的值加 1。当信号量的值小于等于 0 之后,再进行 P 操作时,当前进程或线程会被阻塞,直到另一个进程或线程执行了 V 操作将信号量的值增加到大于 0 之时。
Socket 套接字（Socket）,就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端,提供了应用层进程利用网络协议交换数据的机制。Socket 一般用于网络中不同主机上的进程之间的通信。

7.说说你对MVC的理解

得分点 mvc概念,model、view、controller模块功能

标准回答 MVC是一种设计模式,在这种模式下软件被分为三层,即Model（模型）、View（视图）、Controller（控制器）。

Model代表的是数据,View代表的是用户界面,Controller代表的是数据的处理逻辑,它是Model和View这两层的桥梁。
将软件分层的好处是,可以将对象之间的耦合度降低,便于代码的维护。

Model：指从现实世界中抽象出来的对象模型,是应用逻辑的反应；它封装了数据和对数据的操作,是实际进行数据处理的地方（模型层与数据库才有交互）。在MVC的三个部件中,模型拥有最多的处理任务。被模型返回的数据是中立的,模型与数据格式无关,这样一个模型能为多个视图提供数据,由于应用于模型的代码只需写一次就可以被多个视图重用,所以减少了代码的重复性。
View：负责进行模型的展示,一般就是我们见到的用户界面。
Controller：控制器负责视图和模型之间的交互,控制对用户输入的响应、响应方式和流程；它主要负责两方面的动作,一是把用户的请求分发到相应的模型,二是吧模型的改变及时地反映到视图上。

加分回答为了解耦以及提升代码的可维护性,服务端开发一般会对代码进行分层,服务端代码一般会分为三层：表现层、业务层、数据访问层。在浏览器访问服务器时,请求会先到达表现层最典型的MVC就是jsp+servlet+javabean模式。以JavaBean作为模型,既可以作为数据模型来封装业务数据,又可以作为业务逻辑模型来包含应用的业务操作。 JSP作为视图层,负责提供页面为用户展示数据,提供相应的表单（Form）来用于用户的请求,并在适当的时候（点击按钮）向控制器发出请求来请求模型进行更新。 Serlvet作为控制器,用来接收用户提交的请求,然后获取请求中的数据,将之转换为业务模型需要的数据模型,然后调用业务模型相应的业务方法进行更新,同时根据业务执行结果来选择要返回的视图。当然,这种方式现在已经不那么流行了,Spring MVC框架已经成为了MVC模式的最主流实现。 Spring MVC框架是基于Java的实现了MVC框架模式的请求驱动类型的轻量级框架。前端控制器是DispatcherServlet接口实现类,映射处理器是HandlerMapping接口实现类,视图解析器是ViewResolver接口实现类,页面控制器是Controller接口实现类

8.详细的说说Redis的数据类型

得分点 Redis5种数据结构

标准回答
Redis主要提供了5种数据结构：字符串(string)、哈希(hash)、列表(list)、集合(set)、有序集合(zset)。

Redis还提供了Bitmap、HyperLogLog、Geo类型,但这些类型都是基于上述核心数据类型实现的。5.0版本中,Redis新增加了Streams数据类型,它是一个功能强大的、支持多播的、可持久化的消息队列。 string可以存储字符串、数字和二进制数据,除了值可以是String以外,所有的键也可以是string,string最大可以存储大小为2M的数据。 list保证数据线性有序且元素可重复,它支持lpush、blpush、rpop、brpop等操作,可以当作简单的消息队列使用,一个list最多可以存储2^32-1个元素 hash的值本身也是一个键值对结构,最多能存储2^32-1个元素 set是无序不可重复的,它支持多个set求交集、并集、差集,适合实现共同关注之类的需求,一个set最多可以存储2^32-1个元素 zset是有序不可重复的,它通过给每个元素设置一个分数来作为排序的依据,一个zset最多可以存储2^32-1个元素。加分回答每种类型支持多个编码,每一种编码采取一个特殊的结构来实现各类数据结构内部的编码及结构： string：编码分为int、raw、embstr；int底层实现为long,当数据为整数型并且可以用long类型表示时可以用long存储；embstr底层实现为占一块内存的SDS结构,当数据为长度不超过32字节的字符串时,选择以此结构连续存储元数据和值；raw底层实现为占两块内存的SDS,用于存储长度超过32字节的字符串数据,此时会在两块内存中分别存储元数据和值。 list：编码分为ziplist、linkedlist和quicklist（3.2以前版本没有quicklist）。ziplist底层实现为压缩列表,当元素数量小于2且所有元素长度都小于64字节时,使用这种结构来存储；linkedlist底层实现为双端链表,当数据不符合ziplist条件时,使用这种结构存储；3.2版本之后list一般采用quicklist的快速列表结构来代替前两种。 hash：编码分为ziplist、hashtable两种,其中ziplist底层实现为压缩列表,当键值对数量小于2,并且所有的键值长度都小于64字节时使用这种结构进行存储；hashtable底层实现为字典,当不符合压缩列表存储条件时,使用字典进行存储。 set：编码分为inset和hashtable,intset底层实现为整数集合,当所有元素都是整数值且数量不超过2个时使用该结构存储,否则使用字典结构存储。 zset：编码分为ziplist和skiplist,当元素数量小于128,并且每个元素长度都小于64字节时,使用ziplist压缩列表结构存储,否则使用skiplist的字典+跳表的结构存储。

9.请你说说乐观锁和悲观锁

得分点乐观锁、悲观锁定义及使用场景

标准回答

乐观锁：*乐观锁总是假设最好的情况,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号机制和CAS算法实现。*乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库提供的类似于write_condition机制,其实都是提供的乐观锁。
悲观锁：悲观锁总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。
加分回答两种锁的使用场景乐观锁： GIT,SVN,CVS等代码版本控制管理器,就是一个乐观锁使用很好的场景,例如：A、B程序员,同时从SVN服务器上下载了code.html文件,当A完成提交后,此时B再提交,那么会报版本冲突,此时需要B进行版本处理合并后,再提交到服务器。这其实就是乐观锁的实现全过程。如果此时使用的是悲观锁,那么意味者所有程序员都必须一个一个等待操作提交完,才能访问文件,这是难以接受的。悲观锁：悲观锁的好处在于可以减少并发,但是当并发量非常大的时候,由于锁消耗资源、锁定时间过长等原因,很容易导致系统性能下降,资源消耗严重。因此一般我们可以在并发量不是很大,并且出现并发情况导致的异常用户和系统都很难以接受的情况下,会选择悲观锁进行。

10.设计模式了解么

得分点单例模式、工厂模式

标准回答
创建型包括：单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式；
结构型包括：代理模式、装饰模式、适配器模式、组合模式、桥梁模式、外观模式和享元模式；
行为型包括：模板方法模式、命令模式、责任链模式、策略模式、迭代器模式、中介者模式、观察者模式、备忘录模式、访问者模式、状态模式和解释器模式。

面试中不要求23种设计模式全部了解,但至少应掌握单例模式和工厂模式。
加分回答可以说出知道的框架所用到的设计模式或底层设计模式,例如Spring中的单例模式、工厂模式,AQS的模板模式等等。

11.说说你对AOP的理解

得分点 AOP概念、AOP作用、AOP的实现方式

标准回答 AOP( aspect oriented programming)是一种是面向切面编程,是通过预编译方式和运行期动态代理的方式实现不修改源代码的情况下给程序动态统一添加功能的技术。

AOP 有切面，连接点，通知，切点。 aop是基于动态代理的技术，在程序运行的时候，动态的修改class字节码生成新的class文件进行运行的技术，可以对某个类的某个方法、多个类的多个方法，通过配置切点表达式进行匹配，然后改造被匹配到的类的某一些方法，然后运行；动态代理已知两种，cjlib的基于子类的动态代理，jdk自带的基于接口的动态代理。常见的aop使用场景，日志统一管理，事务管理器。

12.Redis的持久化策略

得分点 RDB、AOF

标准回答 Redis4.0之后,Redis有RDB持久化、AOF持久化、RDB-AOF混合持久化这三种持久化方式。

reids的持久化方式有两种：RDB和AOF RDB：它是通过数据集快照的方式来记录redis中的所有数据，在某个时间段内，将数据写入一个临时文件中，持久化结束，用这个临时文件替换上次的持久化文件，达到数据恢复。好处：只有一个dump.rdb文件，便于存储，容灾性较好，性能最大化，子进程来完成写操作，主进程继续处理命令。缺点：数据安全性低，RDB是隔一段时间进行一次备份，在此期间，如果发生了异常，可能导致数据的不完整性。 AOF：它是通过记录redis的所有命令，每执行一次就记录一次数据，保存在AOF文件中。优点：保证了数据的安全性和完整性，即便是中途宕机，也可以恢复过来。缺点：他的文件比RDB文件大，如果是数据集大的时候，他的恢复速度比RDB文件慢，启动速度也慢。 Redis默认是用RDB文件存储。

13.请你讲讲单例模式、请你手写一下单例模式

得分点饿汉式单例模式、懒汉式单例模式、线程安全的懒汉式单例模式

标准回答单例模式（Singleton
Pattern）是最简单的创建型设计模式。它会确保一个类只有一个实例存在。单例模式最重要的特点就是构造函数私有,从而避免外界直接使用构造函数直接实例化该类的对象。

单例模式在Java种通常有两种表现形式：

饿汉式：类加载时就进行对象实例化
懒汉式：第一次引用类时才进行对象实例化饿汉式单例模式：在类被加载时就会初始化静态变量instance,这时候类的私有构造函数就会被调用,创建唯一的实例。

-
 public class Singleton{ 
    // 构造方法私有,确保外界不能直接实例化
 	private static Singleton instance = new Singleton();
 	//保证私有，这样该类就不可以被实例化
 	private Singleton(){ } 
 	//有一个唯一可以访问对象的方法
 	public static Singleton getInstance(){ 
 		return instance; 
 	} 
 	
	public void doSomething() {
        System.out.println("Do Something");
    }
    
 	//调用
    public static void main(String[] args) {
        // 正确获取唯一单例方式
        Singleton instance = Singleton.getInstance();
        // 用单例做一些事情
        instance.doSomething();
    }
}

懒汉式单例模式：类在加载时不会初始化静态变量instance,而是在第一次被调用时将自己初始化

public class LazySingleton {
 	 // 私有构造方法,确保外界不能直接实例化。
	 private static LazySingleton instance = null; 
	 // 构造方法私有，保证自身初始化
	 private LazySingleton() {} 
	 
	 //提供一个唯一的访问方法
	 public static LazySingleton getInstace() {
	 	// 此处会有线程问题，如果线程A和线程B都执行到了步骤1，并未完成步骤2，那么就会创建多个实例
		if (instance == null) { 
			instance = new LazySingleton(); 
		} 
 		return instance; 
 	} 
 	
 	public void doSomething(){
        System.out.println("Do Something");
    }
 }

但这时有一个问题,如果线程A和B同时调用此方法,会出现执行if (instance == null)语句时都为真的情况,那么线程AB都会创建一个对象,那内存中就会出现两个对象,这违反了单例模式的定义。为解决这一问题,可以使用synchronized关键字对静态方法
getInstance()进行同步,线程安全的的懒汉式单例模式代码如下：

public class LazySingleton { 
	private static LazySingleton instance = null; // 私有构造方法,确保外界不能直接实例化。 
	private LazySingleton() {} // 通过公有的静态方法获取对象实例 
	
	synchronized public static LazySingleton getInstace() { 
		if (instance == null) {
			instance = new LazySingleton();
		}
		  return instance; 
	} 
}

饿汉式单例类在资源利用效率上不如懒汉式单例类,但从速度和反应时间来看,饿汉式单例类要优于懒汉式单例类。

加分回答
1.单例模式的优点：

在一个对象需要频繁的销毁、创建,而销毁、创建性能又无法优化时,单例模式的优势尤其明显
在一个对象的产生需要比较多资源时,如读取配置、产生其他依赖对象时,则可以通过在启用时直接产生一个单例对象,然后用永久驻留内存的方式来解决。
单例模式可以避免对资源的多重占用,因为只有一个实例,避免了对一个共享资源的并发操作
单例模式可以在系统设置全局的访问点,优化和共享资源访问

2.单例模式的缺点：

单例模式无法创建子类,扩展困难,若要扩展,除了修改代码基本上没有第二种途径可以实现。
单例模式对测试不利。在并行开发环境中,如果采用单例模式的类没有完成,是不能进行测试的。
单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑,而不关心它是否是单例的,是不是要用单例模式取决于环境。

14.请你说说虚拟内存和物理内存的区别

标准回答 1. 物理内存以前,还没有虚拟内存概念的时候,程序寻址用的都是物理地址。

程序能寻址的范围是有限的,这取决于 CPU 的地址线条数。比如在 32 位平台下,寻址的范围是 2³² 也就是 4G。并且这是固定的,如果没有虚拟内存,且每次开启一个进程都给 4G 物理内存,就可能会出现很多问题：

因为物理内存是有限的,当有多个进程要执行的时候,都要给 4G 内存，当内存分配完,没有得到分配资源的进程就只能等待。当一个进程执行完了以后,再将等待的进程装入内存。这种频繁的装入内存的操作效率很低
由于指令都是直接访问物理内存的,那么任何进程都可以修改其他进程的数据,甚至会修改内核地址空间的数据,这是不安全的。