Java面试知识点
本帖最后由 java 于 2019-5-7 11:29 编辑什么是Java内存模型？
data:image/png;base64,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
多线程同步和互斥有哪几种实现方法？线程间的同步方法大体可分为两类：用户模式和内核模式。顾名思义，内核模式就是指利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换到内核态，只在用户态完成操作。用户模式下的方法有：原子操作（例如一个单一的全局变量），临界区。内核模式下的方法有：事件，信号量，互斥量。1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。
2、互斥量:为协调共同对一个共享资源的单独访问而设计的。
3、信号量:为控制一个具有有限数量用户资源而设计。
4、事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。
悲观锁和乐观锁有什么区别？
悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。
乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write_condition机制的其实都是提供的乐观锁。
两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下，即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果经常产生冲突，上层应用会不断的进行retry，这样反倒是降低了性能，所以这种情况下用悲观锁就比较合适。
Java的锁实现机制，使用场景分析
ReentranLock源码，设计原理，整体过程
volatile的实现原理
AQS的实现过程
应聘高级Java开发工程师：
1. 如何保证系统高可用
通过冗余+自动故障转移来实现系统的高可用，两套nginx，Tomcat，redis主从服务器+哨兵
https://linux.cn/article-8377-1.html
http://gitbook.cn/books/583c1335c7f2666319396f7f/index.html
http://dbaplus.cn/news-141-591-1.html
2. 系统容灾设计
http://blog.51cto.com/zhaisj/40986
3. 保证分布式系统数据一致性
https://mp.weixin.qq.com/s?__biz ... 0c21bd3e5d&scene=21
4. Java内存管理
http://blog.csdn.net/suifeng3051/article/details/48292193
5. JDK常用类库源码
http://blog.csdn.net/u011915230/article/details/53243515
http://blog.csdn.net/tanggao1314/article/details/50989589
http://770736680.iteye.com/blog/2034936
http://blog.csdn.net/jjzhu_zju/article/details/53674497
6. HashMap原理及数据存储过程
https://yikun.github.io/2015/04/ ... %E5%AE%9E%E7%8E%B0/
7. Java并发控制工具
http://blog.csdn.net/coderinchina/article/details/54914852
http://blog.csdn.net/zq602316498/article/details/41779431
http://softbeta.iteye.com/blog/1797163
http://blog.csdn.net/axi295309066/article/details/52914867
8. SQL查询慢的原因
http://blog.csdn.net/lzkqcc/article/details/79099942
9. spring启动容器加载初始化过程
http://www.cnblogs.com/luyanliang/p/5567164.html
http://blog.csdn.net/u013510838/article/details/75066884
http://www.cnblogs.com/ViviChan/p/4981712.html
10.项目设计的时候关注哪些方面或者系统设计需要考虑哪些方面
http://vividfree.github.io/%E4%B ... about-system-design
---------------------
原文：https://blog.csdn.net/dutianqi110/article/details/79501031
JAVA8 十大新特性详解
本帖最后由 java 于 2019-4-19 19:21 编辑
ArrayList、Vector和LinkedList
首先看这两类都实现List接口，而List接口一共有三个实现类，分别是ArrayList、Vector和LinkedList。List用于存放多个元素，能够维护元素的次序，并且允许元素的重复。3个具体实现类的相关区别如下：
[*]ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
[*]Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
[*]LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。
[*]vector是线程（Thread）同步（Synchronized）的，所以它也是线程安全的，而Arraylist是线程异步（ASynchronized）的，是不安全的。如果不考虑到线程的安全因素，一般用Arraylist效率比较高。
[*]如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度
的50%.如过在集合中使用数据量比较大的数据，用vector有一定的优势。
[*]如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，都是0(1),这个时候使用vector和arraylist都可以。而
如果移动一个指定位置的数据花费的时间为0(n-i)n为总长度，这个时候就应该考虑到使用Linkedlist,因为它移动一个指定位置的数据
所花费的时间为0(1),而查询一个指定位置的数据时花费的时间为0(i)。
ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，
都允许直接序号索引元素，但是插入数据要设计到数组元素移动 等内存操作，所以索引数据快插入数据慢，
Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差
，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快！
[*]笼统来说：LinkedList：增删改快
ArrayList：查询快（有索引的存在）
线程安全
数组和链表
空间增长率
访问读写速度
本帖最后由 java 于 2019-4-19 19:47 编辑
Spring注解
[*]@Repository、@Component、@Service、@Constroller，都是将一个类标识为Bean，Spring容器根据注解的过滤规则扫描读取注解Bean定义类，并将其注册到Spring IoC容器中，它们分别用于软件系统的不同层次：
[*]@Repository 将 DAO 类声明为 Bean，同时它还能将所标注的类中抛出的数据访问异常封装为 Spring 的数据访问异常类型。
[*]@Component 是一个泛化的概念，仅仅表示一个组件 (Bean) ，可以作用在任何层次。
[*]@Service通常作用在业务层，但是目前该功能与 @Component 相同。
[*]@Constroller 通常作用在控制层，但是目前该功能与 @Component 相同。
-@Autowired进行装配，默认是byType的方式进行自动装配的。
SpringBoot注解
[*]@RestController 在源码声明上同时有 @Controller 和 @ResponseBody 注解,所以使用了这个注解的类会被看作一个Controller，所以 @RestController 与 @Controller 的区别就是，@Controller返回的是ViewAndModel，@RestController返回的是字符串直接发送回给客户端。
[*]@EnableAutoConfiguration 注解是类级别的，这个注解告诉Spring Boot“猜测”将如何配置Spring，它是基于添加的jar依赖。
链接：https://www.jianshu.com/p/13de8e13173c
Filter是Spring过滤器，要定义一个Filter类有以下步骤：
首先定义一个Filter类，继承javax.servlet.Filter类，重写其init、doFilter、destroy方法。init()方法会在Filter初始化后进行调用，在init()方法里面我们可以通过FilterConfig访问到初始化参数( getInitParameter()或getInitParameters() )、ServletContext (getServletContext)和当前Filter部署的名称( getFilterName() )等信息。destroy()方法将在Filter被销毁之前调用。而doFilter()方法则是真正进行过滤处理的方法，在doFilter()方法内部，我们可以过滤请求的request和返回的response，同时我们还可以利用FilterChain把当前的request和response传递给下一个过滤器或Servlet进行处理。
同时配置过滤器和拦截器然后请求，结果如下：
init yes
filter test
interceptortest pre
controller
interceptortest post
interceptortest after
可以看到filter优先于interceptor被调用。
过滤器和拦截器主要区别如下：
1.二者适用范围不同。Filter是Servlet规范规定的，只能用于Web程序中，而拦截器既可以用于Web程序，也可以用于Application、Swing程序中。
2.规范不同。Filter是在Servlet规范定义的，是Servlet容器支持的，而拦截器是在Spring容器内的，是Spring框架支持的。
3.使用的资源不同。同其他代码块一样，拦截器也是一个Spring的组件，归Spring管理，配置在Spring文件中，因此能使用Spring里的任何资源、对象(各种bean)，而Filter不行。
4.深度不同。Filter只在Servlet前后起作用，而拦截器能够深入到方法前后、异常跑出前后等，拦截器的使用有更大的弹性。
volatile关键字保证不了线程安全
想要线程安全必须保证原子性，可见性，有序性。而volatile只能保证可见性和有序性
总线锁
缓存一致性协议
我写入之后发现这是共享变量就使得其他cpu缓存了的值失效，让它再次去内存中读取。
这样如果有一个变量i = 0用volatile修饰，两个线程对其进行i++操作，如果线程1从内存中读取i=0进了缓存，然后把数据读入寄存器，之后时间片用完了，然后线程2也从内存中读取i进缓存，因为线程1还未执行写操作，内存屏障是插入在写操作之后的指令，意味着还未触发这个指令，所以缓存行是不会失效的。然后线程2执行完毕，内存中i=1，然后线程1又开始执行，然后将数据写回缓存再写回内存，结果还是1。
https://blog.csdn.net/qq_33330687/article/details/80990729
本帖最后由 java 于 2019-4-27 16:52 编辑
String s=new String("xyz");创建了几个String Object？二者之前的区别是什么？ 两个。第一个对象是字符串常量"xyz" 第二个对象是new String("xyz")的时候产生的，在堆中分配内存给这个对象，只不过这个对象的内容是指向字符串常量"xyz" 另外还有一个引用s，指向第二个对象。这是一个变量，在栈中分配内存。----------- //检查型异常（Checked Exception） FileNotFoundException //非检查型异常（Unchecked Exception）数组越界、访问null对象，这种错误你自己是可以避免的。编译器不会强制你检查这种异常。-----------------
存在i+1<i的数
-------------
二分查找要求结点 ___A___。
A．有序，顺序存储
B．有序，链接存储
C．无序，顺序存储
D．无序，链接存储
[解析] 二分查找要求结点有序且顺序存储。因为查找时，是根据中间元素的位置来确定应该是在左边查找，还是在右边查找。
-------------
如果你想列出当前目录以及子目录下所有扩展名为“.txt”的文件，那么你可以使用的命令是
[*]find . -name "*.txt"
---------------
String是线程安全的
因为String是不可改变的，所以是线程安全的，改不了。
String 字符串常量（产生新变量 线程安全）
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）
-----------------
垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？1、对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。 通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。 2、可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。
----------------------------
Set里的元素是不能重复的，那么用什么方法来区分重复与否呢？是用==还是equals()？它们有什么区别？ Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判断两个Set是否相等。 ==比较两个变量本身的值，即两个对象在内存中的首地址是否相同。 equals()主要是比较对象中包含的值是否相同。1、什么是Set?(what) Set是Collection容器的一个子接口，它不允许出现重复元素，当然也只允许有一个null对象。2、如何来区分重复与否呢？(how) “ 用 iterator() 方法来区分重复与否 ”，这是在网上流传的答案，个人认为这是个错误的答案。JPI中写的很明白：“set 不包含满足e1.equals(e2) 的元素对 e1 和 e2 ”，由此可见回答使用equals()区分更合适。 3、为什么用equals()而不用==来区分？(why) 应该从它俩的区别谈起，==是用来判断两者是否是同一对象（同一事物），而equals是用来判断是否引用同一个对象。再看一下Set里面存的是对象，还是对象的引用。根据java的存储机制可知，set里面存放的是对象的引用，所以当两个元素只要满足了equals()时就已经指向同一个对象，也就出现了重复元素。所以应该用equals()来判断。
-------------------
Servlet执行时一般实现哪几个方法？
答：
public void init(ServletConfig config)
public ServletConfig getServletConfig()
public String getServletInfo()
public void service(ServletRequest request,ServletResponse response)
public void destroy()
-----------------------
try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，还是在return之后执行？
https://www.cnblogs.com/hongten/ ... n_java_finally.html
上图是当程序执行完finally模块后，返回到return代码块。
但是在最后的运行效果中，我们看到的结果是：1，而不是我们想象中的：2
为什么会出现这样的情况：
总结
这一个面试题，看似简单，却暗藏杀机啊！
可是说了这么多，结果就是finally在return之后执行吗？
非也，你没看见return没有真正的执行完就开始执行finally吗？并且是先执行完了finally，才执行完return，这也就很好理解java规范中的finally在return之前执行了。
不过，按如上情况，这句话应该变成这样：finally比return先执行完毕。是不是就更容易理解了呢？
也就是说，return先被执行了，执行return的时候发现有finally，于是不能那么快执行完毕return，先去执行finally，等finally执行完毕之后，return才能执行完毕。
-------------
abstract class和interface有什么区别
含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
下面比较一下两者的语法区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
------------
怎么获取 Java 程序使用的内存？堆使用的百分比？
1、可以使用JMAP或者JStat工具查看Java内存的详细使用情况
2、也可以使用VisualGC查看内存使用情况。可视化工具。
------------
什么是线程局部变量?做例子测试threadlocal
----------------
简述synchronized和java.util.concurrent.locks.Lock的异同？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。
页:
[1]