Java学习---面试基础知识点总结

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

Java中sleep和wait的区别

① 这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。② 锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。③ 使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。 synchronized(x){ x.notify() //或者wait() }

JAVA中的几种基本类型，各占用多少字节？

下图单位是bit,非字节 1B=8bit

String能被继承吗？为什么？

不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。平常我们定义的String str=”a”;其实和String str=new String(“a”)还是有差异的。

前者默认调用的是String.valueOf来返回String实例对象，至于调用哪个则取决于你的赋值，比如String num=1,调用的是

public static String valueOf(int i) {

return Integer.toString(i);

}

后者则是调用如下部分：

public String(String original) {

this.value = original.value;

this.hash = original.hash;

}

最后我们的变量都存储在一个char数组中

private final char value[];

String， Stringbuffer， StringBuilder 的区别。

String 字符串常量(final修饰，不可被继承)，String是常量，当创建之后即不能更改。(可以通过StringBuffer和StringBuilder创建String对象(常用的两个字符串操作类)。)

StringBuffer 字符串变量（线程安全）,其也是final类别的，不允许被继承，其中的绝大多数方法都进行了同步处理，包括常用的Append方法也做了同步处理(synchronized修饰)。其自jdk1.0起就已经出现。其toString方法会进行对象缓存，以减少元素复制开销。

public synchronized String toString() {

if (toStringCache == null) {

toStringCache = Arrays.copyOfRange(value, 0, count);

}

return new String(toStringCache, true);

}

StringBuilder 字符串变量（非线程安全）其自jdk1.5起开始出现。与StringBuffer一样都继承和实现了同样的接口和类，方法除了没使用synch修饰以外基本一致，不同之处在于最后toString的时候，会直接返回一个新对象。

public String toString() {

// Create a copy, don’t share the array

return new String(value, 0, count);

}

ArrayList 和 LinkedList 有什么区别。

ArrayList和LinkedList都实现了List接口，有以下的不同点：

1、ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。

2、相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。

3、LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。

讲讲类的实例化顺序，

父类静态代变量--->父类静态代码块--->子类静态变量--->子类静态代码块---->父类非静态变量(父类实例成员变量)--->
父类构造函数--->子类非静态变量（子类实例成员变量）--->子类构造函数。

测试demo：http://blog.csdn.net/u014042066/article/details/77574956

参阅我的博客《深入理解类加载》：http://blog.csdn.net/u014042066/article/details/77394480

用过哪些 Map 类，都有什么区别

hashMap是线程不安全的，HashMap是数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，采用哈希表来存储的，

参照该链接：https://zhuanlan.zhihu.com/p/21673805

JAVA8 的 ConcurrentHashMap 为什么放弃了分段锁，有什么问题吗，如果你来设计，你如何设计。

参照：https://yq.aliyun.com/articles/36781

有没有有顺序的 Map 实现类， 如果有， 他们是怎么保证有序的。

TreeMap和LinkedHashMap是有序的（TreeMap默认升序，LinkedHashMap则记录了插入顺序）。

参照：http://uule.iteye.com/blog/1522291

抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接口么。

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

2、抽象类要被子类继承，接口要被类实现。

3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

6、抽象方法只能申明，不能实现。abstract void abc();不能写成abstract void abc(){}。

7、抽象类里可以没有抽象方法

8、如果一个类里有抽象方法，那么这个类只能是抽象类

9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

10、接口可继承接口，并可多继承接口，但类只能单根继承。

继承和聚合的区别在哪。

继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java中此类关系通过关键字extends明确标识，在设计时一般没有争议性；

聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

参考：http://www.cnblogs.com/jiqing9006/p/5915023.html

讲讲你理解的 nio和 bio 的区别是啥，谈谈 reactor 模型。

IO是面向流的，NIO是面向缓冲区的

参考：https://zhuanlan.zhihu.com/p/23488863

http://developer.51cto.com/art/201103/252367.htm

http://www.jianshu.com/p/3f703d3d804c

反射的原理，反射创建类实例的三种方式是什么

参照：http://www.jianshu.com/p/3ea4a6b57f87?amp

http://blog.csdn.net/yongjian1092/article/details/7364451

反射中，Class.forName 和 ClassLoader 区别。

https://my.oschina.net/gpzhang/blog/486743

描述动态代理的几种实现方式，分别说出相应的优缺点。

Jdk cglib jdk底层是利用反射机制，需要基于接口方式，这是由于

Proxy.newProxyInstance(target.getClass().getClassLoader(),

target.getClass().getInterfaces(), this);

Cglib则是基于asm框架，实现了无反射机制进行代理，利用空间来换取了时间，代理效率高于jdk

http://lrd.ele.me/2017/01/09/dynamic_proxy/

动态代理与 cglib 实现的区别

同上（基于invocationHandler和methodInterceptor）

为什么 CGlib 方式可以对接口实现代理。

同上

final 的用途

类、变量、方法

http://www.importnew.com/7553.html

写出三种单例模式实现。

懒汉式单例，饿汉式单例，双重检查等

参考：https://my.oschina.net/dyyweb/blog/609021

如何在父类中为子类自动完成所有的 hashcode 和 equals 实现？这么做有何优劣。

同时复写hashcode和equals方法，优势可以添加自定义逻辑，且不必调用超类的实现。

参照：http://java-min.iteye.com/blog/1416727

谈谈访问修饰符 public、private、protected、default 在应用设计中的作用。

访问修饰符，主要标示修饰块的作用域，方便隔离防护

同一个类 同一个包 不同包的子类 不同包的非子类

• 1
• 2

Private √

Default √ √

Protected √ √ √

Public √ √ √ √

public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不

仅可以跨类访问，而且允许跨包（package）访问。

private: Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的类、属性以

及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。

protect: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、

属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。

default：即不加任何访问修饰符，通常称为“默认访问模式“。该模式下，只允许在同一个包中进行访

问。

深拷贝和浅拷贝区别。

http://www.oschina.net/translate/java-copy-shallow-vs-deep-in-which-you-will-swim

数组和链表数据结构描述，各自的时间复杂度

http://blog.csdn.net/snow_wu/article/details/53172721

error 和 exception 的区别，CheckedException，RuntimeException 的区别

http://blog.csdn.net/woshixuye/article/details/8230407

请列出 5 个运行时异常。

同上

在自己的代码中，如果创建一个 java.lang.String 对象，这个对象是否可以被类加载器加载？为什么

类加载无须等到“首次使用该类”时加载，jvm允许预加载某些类。。。。

http://www.cnblogs.com/jasonstorm/p/5663864.html

Object 对象中 hashCode 和 equals 方法的理解。在什么场景下需要重新实现这两个方法。

参考上边试题

在 jdk1.5 中，引入了泛型，泛型的存在是用来解决什么问题。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率

http://baike.baidu.com/item/java%E6%B3%9B%E5%9E%8B

这样的 a.hashcode() 有什么用，与 a.equals(b)有什么关系。

hashcode

hashcode（）方法提供了对象的hashCode值，是一个native方法，返回的默认值与System.identityHashCode(obj)一致。

通常这个值是对象头部的一部分二进制位组成的数字，具有一定的标识对象的意义存在，但绝不定于地址。

作用是：用一个数字来标识对象。比如在HashMap、HashSet等类似的集合类中，如果用某个对象本身作为Key，即要基于这个对象实现Hash的写入和查找，那么对象本身如何实现这个呢？就是基于hashcode这样一个数字来完成的，只有数字才能完成计算和对比操作。

hashcode是否唯一

hashcode只能说是标识对象，在hash算法中可以将对象相对离散开，这样就可以在查找数据的时候根据这个key快速缩小数据的范围，但hashcode不一定是唯一的，所以hash算法中定位到具体的链表后，需要循环链表，然后通过equals方法来对比Key是否是一样的。

equals与hashcode的关系

equals相等两个对象，则hashcode一定要相等。但是hashcode相等的两个对象不一定equals相等。

https://segmentfault.com/a/1190000004520827

有没有可能 2 个不相等的对象有相同的 hashcode。

有

Java 中的 HashSet 内部是如何工作的。

底层是基于hashmap实现的

http://wiki.jikexueyuan.com/project/java-collection/hashset.html

什么是序列化，怎么序列化，为什么序列化，反序列化会遇到什么问题，如何解决。

http://www.importnew.com/17964.html

Java中HashMap和HashTable的区别

① 历史原因: Hashtable是给予陈旧的Dictonary类的, HashMap是Java1.2引进的Map接口的一个实现② HashMap允许空的键值对, 而HashTable不允许③ HashTable同步，而HashMap非同步，效率上比HashTable要高

Java中synchronized 和 ReentrantLock 有什么不同？

相似点：

这两种同步方式有很多相似之处，它们都是加锁方式同步，而且都是阻塞式的同步，也就是说当如果一个线程获得了对象锁，进入了同步块，其他访问该同步块的线程都必须阻塞在同步块外面等待，而进行线程阻塞和唤醒的代价是比较高的（操作系统需要在用户态与内核态之间来回切换，代价很高，不过可以通过对锁优化进行改善）。

区别：

这两种方式最大区别就是对于Synchronized来说，它是java语言的关键字，是原生语法层面的互斥，需要jvm实现。而ReentrantLock它是JDK 1.5之后提供的API层面的互斥锁，需要lock()和unlock()方法配合try/finally语句块来完成。

Synchronized进过编译，会在同步块的前后分别形成monitorenter和monitorexit这个两个字节码指令。在执行monitorenter指令时，首先要尝试获取对象锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象锁，把锁的计算器加1，相应的，在执行monitorexit指令时会将锁计算器就减1，当计算器为0时，锁就被释放了。如果获取对象锁失败，那当前线程就要阻塞，直到对象锁被另一个线程释放为止。

由于ReentrantLock是java.util.concurrent包下提供的一套互斥锁，相比Synchronized，ReentrantLock类提供了一些高级功能，主要有以下3项：

1.等待可中断，持有锁的线程长期不释放的时候，正在等待的线程可以选择放弃等待，这相当于Synchronized来说可以避免出现死锁的情况。

2.公平锁，多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁，但公平锁表现的性能不是很好。

3.锁绑定多个条件，一个ReentrantLock对象可以同时绑定对个对象。

什么情况下会发生栈内存溢出。

如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常。 如果虚拟机在动态扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常。

参照：http://wiki.jikexueyuan.com/project/java-vm/storage.html

JVM 的内存结构，Eden 和 Survivor 比例。

eden 和 survior 是按8比1分配的

http://blog.csdn.net/lojze_ly/article/details/49456255

jvm 中一次完整的 GC 流程是怎样的，对象如何晋升到老年代，说说你知道的几种主要的jvm 参数。

对象诞生即新生代->eden，在进行minor gc过程中，如果依旧存活，移动到from，变成Survivor，进行标记代数，如此检查一定次数后，晋升为老年代，

http://www.cnblogs.com/redcreen/archive/2011/05/04/2037056.html

http://ifeve.com/useful-jvm-flags/

https://wangkang007.gitbooks.io/jvm/content/jvmcan_shu_xiang_jie.html

你知道哪几种垃圾收集器，各自的优缺点，重点讲下 cms，包括原理，流程，优缺点

Serial、parNew、ParallelScavenge、SerialOld、ParallelOld、CMS、G1

https://wangkang007.gitbooks.io/jvm/content/chapter1.html

垃圾回收算法的实现原理。

http://www.importnew.com/13493.html

当出现了内存溢出，你怎么排错。

首先分析是什么类型的内存溢出，对应的调整参数或者优化代码。

https://wangkang007.gitbooks.io/jvm/content/4jvmdiao_you.html

JVM 内存模型的相关知识了解多少，比如重排序，内存屏障，happen-before，主内存，工作内存等。

内存屏障：为了保障执行顺序和可见性的一条cpu指令

重排序：为了提高性能，编译器和处理器会对执行进行重拍

happen-before：操作间执行的顺序关系。有些操作先发生。

主内存：共享变量存储的区域即是主内存

工作内存：每个线程copy的本地内存，存储了该线程以读/写共享变量的副本

http://ifeve.com/java-memory-model-1/

http://www.jianshu.com/p/d3fda02d4cae

http://blog.csdn.net/kenzyq/article/details/50918457

简单说说你了解的类加载器。

类加载器的分类（bootstrap,ext,app,curstom），类加载的流程(load-link-init)

http://blog.csdn.net/gjanyanlig/article/details/6818655/

讲讲 JAVA 的反射机制。

Java程序在运行状态可以动态的获取类的所有属性和方法，并实例化该类，调用方法的功能

http://baike.baidu.com/link?url=C7p1PeLa3ploAgkfAOK-4XHE8HzQuOAB7K5GPcK_zpbAa_Aw-nO3997K1oir8N–1_wxXZfOThFrEcA0LjVP6wNOwidVTkLBzKlQVK6JvXYvVNhDWV9yF-NIOebtg1hwsnagsjUhOE2wxmiup20RRa#7

你们线上应用的 JVM 参数有哪些。

-server
Xms6000M
-Xmx6000M
-Xmn500M
-XX:PermSize=500M
-XX:MaxPermSize=500M
-XX:SurvivorRatio=65536
-XX:MaxTenuringThreshold=0
-Xnoclassgc
-XX:+DisableExplicitGC
-XX:+UseParNewGC
-XX:+UseConcMarkSweepGC
-XX:+UseCMSCompactAtFullCollection
-XX:CMSFullGCsBeforeCompaction=0
-XX:+CMSClassUnloadingEnabled
-XX:-CMSParallelRemarkEnabled
-XX:CMSInitiatingOccupancyFraction=90
-XX:SoftRefLRUPolicyMSPerMB=0
-XX:+PrintClassHistogram
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps
-XX:+PrintHeapAtGC
-Xloggc:log/gc.log

g1 和 cms 区别,吞吐量优先和响应优先的垃圾收集器选择。

Cms是以获取最短回收停顿时间为目标的收集器。基于标记-清除算法实现。比较占用cpu资源，切易造成碎片。

G1是面向服务端的垃圾收集器，是jdk9默认的收集器，基于标记-整理算法实现。可利用多核、多cpu，保留分代，实现可预测停顿，可控。

http://blog.csdn.net/linhu007/article/details/48897597

请解释如下 jvm 参数的含义：

-server -Xms512m -Xmx512m -Xss1024K

-XX:PermSize=256m -XX:MaxPermSize=512m -XX:MaxTenuringThreshold=20

XX:CMSInitiatingOccupancyFraction=80 -XX:+UseCMSInitiatingOccupancyOnly。

Server模式启动

最小堆内存512m

最大512m

每个线程栈空间1m

永久代256

最大永久代256

最大转为老年代检查次数20

Cms回收开启时机：内存占用80%

命令JVM不基于运行时收集的数据来启动CMS垃圾收集周期

开源框架知识

简单讲讲 tomcat 结构，以及其类加载器流程。

Server- –多个service

Container级别的：–>engine–》host–>context

Listenter

Connector

Logging、Naming、Session、JMX等等

通过WebappClassLoader 加载class

http://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/

http://blog.csdn.net/dc_726/article/details/11873343

http://www.cnblogs.com/xing901022/p/4574961.html

http://www.jianshu.com/p/62ec977996df

tomcat 如何调优，涉及哪些参数。

硬件上选择，操作系统选择，版本选择，jdk选择，配置jvm参数，配置connector的线程数量，开启gzip压缩，trimSpaces，集群等

http://blog.csdn.net/lifetragedy/article/details/7708724

讲讲 Spring 加载流程。

通过listener入口，核心是在AbstractApplicationContext的refresh方法，在此处进行装载bean工厂，bean，创建bean实例，拦截器，后置处理器等。

https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/

讲讲 Spring 事务的传播属性。

七种传播属性。

事务传播行为

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了如下几个表示传播行为的常量：

TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。

TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。

TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。

TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。

TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

https://www.ibm.com/developerworks/cn/education/opensource/os-cn-spring-trans/

Spring 如何管理事务的。

编程式和声明式

同上

Spring 怎么配置事务（具体说出一些关键的 xml 元素）。

说说你对 Spring 的理解，非单例注入的原理？它的生命周期？循环注入的原理， aop 的实现原理，说说 aop 中的几个术语，它们是怎么相互工作的。

核心组件：bean，context，core，单例注入是通过单例beanFactory进行创建，生命周期是在创建的时候通过接口实现开启，循环注入是通过后置处理器，aop其实就是通过反射进行动态代理，pointcut，advice等。

Aop相关：http://blog.csdn.net/csh624366188/article/details/7651702/

Springmvc 中 DispatcherServlet 初始化过程。

入口是web.xml中配置的ds，ds继承了HttpServletBean，FrameworkServlet，通过其中的init方法进行初始化装载bean和实例，initServletBean是实际完成上下文工作和bean初始化的方法。

http://www.mamicode.com/info-detail-512105.html

Java运行时内存是如何划分的

Java虚拟机在执行Java程序的时候会把他所管理的内存划分为若干个不同的数据区域，各个区域有各自的用途，以及创建和销毁的时间。有的区域随着虚拟机进程的启动而存在，有的区域则依赖用户线程的启动和结束而创建和销毁。

Java虚拟机会把运行时的数据区域分为以下几个区域：

程序计数器：

程序计数器是一块很小的内存空间，代表着当前线程执行的字节码的行号指示器，记录着所执行的行号，java虚拟机执行的是由后缀名为.java的文件编译而来的.class文件（字节码文件），所以字节码解释器根据程序计数器来执行字节码文件。每个线程都有自己的程序解释器，这样才能保证程序的正确执行，也就是说程序计数器是线程私有的。

Java虚拟机栈：

java虚拟机栈是用来描述java方法的内存模型，每个方法在执行的同时都会创建一个栈帧，而这个栈帧存储的是方法中的局部变量，操作的数据，方法的入口返回值等信息，当一个方法被调用的时候，就代表着栈帧的入栈直至方法的结束代表着栈帧的出栈。因为虚拟机栈存储的数据决定了他也是线程私有的，每个线程都拥有一个虚拟机栈记录着方法的内容。我们平时所说的栈就是指的是虚拟机栈，其中存储着基本数据类型和指向堆内存中对象的指针（对象的引用）。

本地方法栈：

这块区域和虚拟机栈执行的操作其实是一致的，但是他们之间的服务对象不一样，虚拟机栈为java方法服务，而本地方法栈为native方法服务，我们在看源码的时候经常了一看到用native关键字修饰的方法，这种方法的实现是用c/c++实现的，我们在平时是看不到他的源码实现的。

Java堆:

堆内存是这几块内存区域中最大的一块，堆内存存在的目的是存放对象的实例（通过new创建的对象，对象的引用放在虚拟机栈中指向堆中的实例），在虚拟机启动的时候堆内存也就被创建了，这块内存被所有线程共享，在虚拟机运行期间的所有线程创建的对象的实例都被存储在堆内存中。既然堆被线程所共享，那么线程创建的对象不能一直存放在这里，总会有装不下的时候，在一定条件下，java虚拟机会触发垃圾回收机制（GC），来回收这里被看作没有用的对象，虚拟机所管理的垃圾回收器总是会对这块区域进行管理操作。关于垃圾回收（GC）机制可以看另一篇文章：Java GC垃圾回收机制

方法区：

方法区和堆内存一样，是各个线程共享的数据区域，看到这个方法区这个名字很快能想到这个区域存方法信息，事实上方法区存放的数据很多，包括被虚拟机加载的类信息，用final修饰的常量，String对象，用static修饰的静态变量。

运行时常量池：

准确的说这块区域属于方法区，也就受到了方法区的空间限制，之前所说的String对象，就是字符串常量就是存放在这里，编译期生成各种字面值和符号引用，将在类价在后放入方法区的运行时常量池的。运行时常量池的存储具有动态性，并不是在类加载时才能放入数据，在程序运行期间也可以有新的常量放入。String类中的intern（）方法就是这种特点，详看之前转载的一篇文章：String的intern（）方法详解

直接内存：

这块区域和java中的新的io方式（NIO）有关，不属于虚拟机的运行时数据区。NIO是一种基于通道，缓冲区的io方式。

XSS,CSRF,SQL注入

XSS是一种经常出现在web应用中的计算机安全漏洞，它允许恶意web用户将代码植入到提供给其它用户使用的页面中。比如这些代码包括HTML代码和客户端脚本。攻击者利用XSS漏洞旁路掉访问控制——例如同源策略(same origin policy)。这种类型的漏洞由于被黑客用来编写危害性更大的网络钓鱼(Phishing)攻击而变得广为人知。对于跨站脚本攻击，黑客界共识是：跨站脚本攻击是新型的“缓冲区溢出攻击“，而JavaScript是新型的“ShellCode”。

CSRF（Cross-site request forgery）跨站请求伪造，也被称为“One Click Attack”或者Session Riding，通常缩写为CSRF或者XSRF，是一种对网站的恶意利用。尽管听起来像跨站脚本（XSS），但它与XSS非常不同，XSS利用站点内的信任用户，而CSRF则通过伪装来自受信任用户的请求来利用受信任的网站。与XSS攻击相比，CSRF攻击往往不大流行（因此对其进行防范的资源也相当稀少）和难以防范，所以被认为比XSS更具危险性。

SQL注入，就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。具体来说，它是利用现有应用程序，将（恶意的）SQL命令注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。 ^[1]比如先前的很多影视网站泄露VIP会员密码大多就是通过WEB表单递交查询字符暴出的，这类表单特别容易受到SQL注入式攻击．

java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐？

有两种实现方法，分别是继承Thread类与实现Runnable接口用synchronized关键字修饰同步方法反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被“挂起”的线程恢复运行。

对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

请简述在异常当中，throw和throws有什么区别

① throw代表动作，表示抛出一个异常的动作；throws代表一种状态，代表方法可能有异常抛出
② throw用在方法实现中，而throws用在方法声明中
③ throw只能用于抛出一种异常，而throws可以抛出多个异常

forward和redirect的区别

forward: A -> B -> C
redirect： A -> B A -> C
1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.
2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据.
3.从运用地方来说
forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.
4.从效率来说
forward:高.
redirect:低.

关于内存溢出的小结

内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。
内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
memory leak会最终会导致out of memory！内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。

java为什么要重写hashCode和equals方法？

如果不被重写（原生）的hashCode和equals是什么样的？

1. 不被重写（原生）的hashCode值是根据内存地址换算出来的一个值。
2. 不被重写（原生）的equals方法是严格判断一个对象是否相等的方法（object1 == object2）。

为什么需要重写equals和hashCode方法？

在我们的业务系统中判断对象时有时候需要的不是一种严格意义上的相等，而是一种业务上的对象相等。在这种情况下，原生的equals方法就不能满足我们的需求了

所以这个时候我们需要重写equals方法，来满足我们的业务系统上的需求。那么为什么在重写equals方法的时候需要重写hashCode方法呢？

我们先来看一下Object.hashCode的通用约定（摘自《Effective Java》第45页）

1.在一个应用程序执行期间，如果一个对象的equals方法做比较所用到的信息没有被修改的话，那么，对该对象调用hashCode方法多次，它必须始终如一地返回 同一个整数。在同一个应用程序的多次执行过程中，这个整数可以不同，即这个应用程序这次执行返回的整数与下一次执行返回的整数可以不一致。

2.如果两个对象根据equals(Object)方法是相等的，那么调用这两个对象中任一个对象的hashCode方法必须产生同样的整数结果。

3.如果两个对象根据equals(Object)方法是不相等的，那么调用这两个对象中任一个对象的hashCode方法，不要求必须产生不同的整数结果。然而，程序员应该意识到这样的事实，对于不相等的对象产生截然不同的整数结果，有可能提高散列表（hash table）的性能。

如果只重写了equals方法而没有重写hashCode方法的话，则会违反约定的第二条：相等的对象必须具有相等的散列码（hashCode）

同时对于HashSet和HashMap这些基于散列值（hash）实现的类。HashMap的底层处理机制是以数组的方法保存放入的数据的(Node<K,V>[] table)，其中的关键是数组下标的处理。数组的下标是根据传入的元素hashCode方法的返回值再和特定的值异或决定的。

如果该数组位置上已经有放入的值了，且传入的键值相等则不处理，若不相等则覆盖原来的值，如果数组位置没有条目，则插入，并加入到相应的链表中。检查键是否存在也是根据hashCode值来确定的。所以如果不重写hashCode的话，可能导致HashSet、HashMap不能正常的运作、

如果我们将某个自定义对象存到HashMap或者HashSet及其类似实现类中的时候，如果该对象的属性参与了hashCode的计算，那么就不能修改该对象参数hashCode计算的属性了。有可能会移除不了元素，导致内存泄漏。

扩展：

在重写equals方法的时候，需要遵守下面的通用约定：

1、自反性。

对于任意的引用值x，x.equals(x)一定为true。

2、对称性。

对于任意的引用值x和y，当且仅当y.equals(x)返回true时，x.equals(y)也一定返回true。

3、传递性。

对于任意的引用值x、y和z，如果x.equals(y)返回true，并且y.equals(z)也返回true，那么x.equals(z)也一定返回true。

4、一致性。

对于任意的引用值x和y，如果用于equals比较的对象没有被修改的话，那么，对此调用x.equals(y)要么一致地返回true，要么一致的返回false。

5、对于任意的非空引用值x，x.equals(null)一定返回false。

重写hashCode方法的大致方式：

a、把某个非零常数值，比如说17（最好是素数），保存在一个叫result的int类型的变量中。

b、对于对象中每一个关键域f（值equals方法中考虑的每一个域），完成一些步骤：

1、为该域计算int类型的散列吗c：

1）、如果该域是boolean类型，则计算（f？0:1）。

2)、如果该域是byte、char、short或者int类型，则计算（int）f。

3）、如果该域是float类型，则计算Float.floatToIntBits(f)。

4）、如果该域是long类型，则计算（int）（f ^ (f>>>32)）。

5）、如果该域是double类型，则计算Double.doubleToLongBits(f)得到一个long类型的值，然后按照步骤4，对该long型值计算散列值。

6）、如果该域是一个对象引用，并且该类的equals方法通过递归调用equals的方式来比较这个域，则同样对这个域递归调用hashCode。如果要求一个更为复杂的比较，则为这个域计算一个“规范表示”，然后针对这个范式表示调用hashCode。如果这个域的值为null，则返回0（或者其他某个常数）

7）、如果该域是一个数组，则把每一个元素当做单独的域来处理。也就是说，递归地应用上述规则，对每个重要的元素计算一个散列码，然后根据步骤下面的做法把这些散列值组合起来。

2、按照下面的公式，把步骤1中计算得到的散列码C组合到result中：

result = 31*result+c。

c、返回result。

d、写完hashCode方法之后，问自己“是否相等的实例具有相等的散列码”。如果不是的话，找出原因，并修改。

可以通过org.apache.commons.lang.builder.HashCodeBuilder这个工具类来方便的重写hashCode方法。

关于枚举的小结

枚举类型的那些事：https://www.cnblogs.com/hyl8218/p/5088287.html

枚举类型符合通用模式 Class Enum<E extends Enum<E>>，而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中，在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了此设置被创建的顺序。

HTTP返回码分析

301：- 永久移动。请求的资源已被永久的移动到新URI，返回信息会包括新的URI，浏览器会自动定向到新URI。今后任何新的请求都应使用新的URI代替
302：- 临时移动。与301类似。但资源只是临时被移动。客户端应继续使用原有URI

304：- 如果客户端发送了一个带条件的GET 请求且该请求已被允许,而文档的内容(自上次访问以来或者根据请求的条件)并没有改变,则服务器应当返回这个304状态码..
403：- 代表客户端错误，指的是服务器端有能力处理该请求，但是拒绝授权访问。
404：- 服务器无法根据客户端的请求找到资源（网页）。通过此代码，网站设计人员可设置"您所请求的资源无法找到"的个性页面
500：- 服务器内部错误，无法完成请求

Java程序中启动一个线程是用run()还是start()？

1.start（）方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码：
通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
然后通过此Thread类调用方法run()来完成其运行操作的，这里方法run()称为线程体，它包含了要执行的这个线程的内容，
Run方法运行结束，此线程终止，而CPU再运行其它线程。
2.run（）方法当作普通方法的方式调用，程序还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码：
而如果直接用Run方法，这只是调用一个方法而已，程序中依然只有主线程--这一个线程，其程序执行路径还是只有一条，
这样就没有达到写线程的目的。

Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。
提醒一下大家：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实际就是在操作系统中启动了一个进程。
在java程序中，只要前台有一个线程在运行，整个java程序进程不会小时，所以此时可以设置一个后台线程，这样即使java进程小时了，此后台线程依然能够继续运行。

线程状态说明

线程状态从大的方面来说，可归结为：初始状态、可运行状态、不可运行状态和消亡状态，具体可细分为上图所示7个状态，说明如下：
1）线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了thread实例后，线程就进入了初始状态；
2）当该对象调用了start()方法，就进入可运行状态；
3）进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态；
4）进入运行状态后case就比较多，大致有如下情形： ﹒run()方法或main()方法结束后，线程就进入终止状态； 当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态既停 止当前线程，但并不释放所占有的资源)。当
sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片； 当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被锁牢(synchroniza,lock)，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线
程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配 CPU时间片； 当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，
是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒
有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。 当线程调用stop方法，即可使线程进入消亡状态，但是由于stop方法是不安全的，不鼓励使用，大家可以通过run方法里的条件变通实现线程的 stop。

Java中的原始数据类型都有哪些，它们的大小及对应的封装类是什么？

• byte——1 byte——Byte
• short——2 bytes——Short
• int——4 bytes——Integer
• long——8 bytes——Long
• float——4 bytes——Float
• double——8 bytes——Double
• char——2 bytes——Character
• boolean——————Boolean

boolean数据类型非true即false。

这个数据类型表示1 bit，但是它的大小并没有精确定义。

《Java虚拟机规范》中如是说：“虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素boolean元素占8位”。这样我们可以得出boolean类型单独使用是4个字节，在数组中又是1个字节。

那虚拟机为什么要用int来代替boolean呢？为什么不用byte或short，这样不是更节省内存空间吗？

实际上，使用int的原因是，对于当下32位的CPU来说，一次进行32位的数据交换更加高效。

综上，我们可以知道：官方文档对boolean类型没有给出精确的定义，《Java虚拟机规范》给出了“单独时使用4个字节，boolean数组时1个字节”的定义，具体还要看虚拟机实现是否按照规范来，所以1个字节、4个字节都是有可能的。这其实是一种时空权衡。 boolean类型的封装类是Boolean。

位运算符的基本用法

案例演示 >>,>>>,<<的用法:

<<:左移左边最高位丢弃，右边补齐0

>>:右移最高位是0，左边补齐0;最高为是1，左边补齐1

>>>:无符号右移 无论最高位是0还是1，左边补齐0

最有效率的算出2 * 8的结果

//最有效率的算出2 * 8的结果

System.out.println(2 << 3);

谈一谈”==“与”equals()"的区别。

《Think in Java》中说：“关系操作符生成的是一个boolean结果，它们计算的是操作数的值之间的关系”。 "=="判断的是两个对象的内存地址是否一样，适用于原始数据类型和枚举类型（它们的变量存储的是值本身，而引用类型变量存储的是引用）；equals是Object类的方法，Object对它的实现是比较内存地址，我们可以重写这个方法来自定义“相等”这个概念。比如类库中的String、Date等类就对这个方法进行了重写。 综上，对于枚举类型和原始数据类型的相等性比较，应该使用"=="；对于引用类型的相等性比较，应该使用equals方法。

Java中的四种引用及其应用场景是什么？

• 强引用: 通常我们使用new操作符创建一个对象时所返回的引用即为强引用
• 软引用: 若一个对象只能通过软引用到达，那么这个对象在内存不足时会被回收，可用于图片缓存中，内存不足时系统会自动回收不再使用的Bitmap
• 弱引用: 若一个对象只能通过弱引用到达，那么它就会被回收（即使内存充足），同样可用于图片缓存中，这时候只要Bitmap不再使用就会被回收
• 虚引用: 虚引用是Java中最“弱”的引用，通过它甚至无法获取被引用的对象，它存在的唯一作用就是当它指向的对象回收时，它本身会被加入到引用队列中，这样我们可以知道它指向的对象何时被销毁。

object中定义了哪些方法？

• clone()
• equals()
• hashCode()
• toString()
• notify()
• notifyAll()
• wait()
• finalize()
• getClass()

hashCode的作用是什么？

请参考散列表的基本原理与实现

ArrayList, LinkedList, Vector的区别是什么？

• ArrayList:内部采用数组存储元素，支持高效随机访问，支持动态调整大小
• LinkedList:内部采用链表来存储元素，支持快速插入/删除元素，但不支持高效地随机访问
• Vector: 可以看作线程安全版的ArrayList

String, StringBuilder, StringBuffer的区别是什么？

• String: 不可变的字符序列，若要向其中添加新字符需要创建一个新的String对象
• StringBuilder: 可变字符序列，支持向其中添加新字符（无需创建新对象）
• StringBuffer: 可以看作线程安全版的StringBuilder

Map, Set, List, Queue、Stack的特点及用法。

• Map<k, v="">:Java中存储键值对的数据类型都实现了这个接口，表示“映射表”。支持的两个核心操作是get(Object key)以及put(K key, V value)，分别用来获取键对应的值以及向映射表中插入键值对。</k,>
• Set<e>:实现了这个接口的集合类型中不允许存在重复的元素，代表数学意义上的“集合”。它所支持的核心操作有add(E e), remove(Object o), contains(Object o)，分别用于添加元素，删除元素以及判断给定元素是否存在于集中。
• List<e>: Java中集合框架中的列表类型都实现了这个接口，表示一种有序序列。支持get(int index), add(E e)等操作。
• Queue<e>:Java集合框架中的队列接口，代表了“先进先出”队列。支持add(E element),remove()等操作。
• Stack<e>:Java集合框架中表示堆栈的数据类型，堆栈是一种“后进先出”的数据结构。支持push(E item), pop()等操作。

更详细的说明请参考官方文档，对相关数据结构不太熟悉的同学可以参考《算法导论》或其他相关书籍。

HashMap和HashTable的区别

• HashTable是线程安全的，而HashMap不是
• HashMap中允许存在null键和null值，而HashTable中不允许

HashMap的实现原理

简单的说，HashMap的底层实现是“基于拉链法的散列表”。

详细分析请参考 Map源码解析之HashMap源码分析

ConcurrentHashMap的实现原理

ConcurrentHashMap是支持并发读写的HashMap，它的特点是读取数据时无需加锁，写数据时可以保证加锁粒度尽可能的小。由于其内部采用“分段存储”，只需对要进行写操作的数据所在的“段”进行加锁。关于ConcurrentHashMap底层实现的详细分析请参考 Java并发编程：并发容器之ConcurrentHashMap

TreeMap, LinkedHashMap, HashMap的区别是什么？

• HashMap的底层实现是散列表，因此它内部存储的元素是无序的；
• TreeMap的底层实现是红黑树，所以它内部的元素的有序的。排序的依据是自然序或者是创建TreeMap时所提供的比较器（Comparator）对象。
• LinkedHashMap可以看作能够记住插入元素的顺序的HashMap。

Collection与Collections的区别是什么？

• Collection<e>是Java集合框架中的基本接口；
• Collections是Java集合框架提供的一个工具类，其中包含了大量用于操作或返回集合的静态方法。

对于“try-catch-finally”，若try语句块中包含“return”语句，finally语句块会执行吗？

会执行。只有两种情况finally块中的语句不会被执行：

• 调用了System.exit()方法；
• JVM“崩溃”了。

Java中的异常层次结构

Java中的异常层次结构如下图所示：

我们可以看到Throwable类是异常层级中的基类。

Error类表示内部错误，这类错误使我们无法控制的；Exception表示异常，RuntimeException及其子类属于未检查异常，这类异常包括ArrayIndexOutOfBoundsException、NullPointerException等，我们应该通过条件判断等方式语句避免未检查异常的发生。IOException及其子类属于已检查异常，编译器会检查我们是否为所有可能抛出的已检查异常提供了异常处理器，若没有则会报错。对于未检查异常，我们无需捕获（当然Java也允许我们捕获，但我们应该做的事避免未检查异常的发生）。

Java面向对象的三个特征与含义

三大特征：封装、继承、多态。

Override, Overload的含义与区别

• Override表示“重写”，是子类对父类中同一方法的重新定义
• Overload表示“重载”，也就是定义一个与已定义方法名称相同但签名不同的新方法

接口与抽象类的区别

• 接口是一种约定，实现接口的类要遵循这个约定；
• 抽象类本质上是一个类，使用抽象类的代价要比接口大。
• 接口与抽象类的对比如下：

抽象类中可以包含属性，方法（包含抽象方法与有着具体实现的方法），常量；接口只能包含常量和方法声明。

抽象类中的方法和成员变量可以定义可见性（比如 public、private等）；而接口中的方法只能为public（缺省为public）。

一个子类只能有一个父类（具体类或抽象类）；而一个接口可以继承一个多个接口，一个类也可以实现多个接口。

子类中实现父类中的抽象方法时，可见性可以大于等于父类中的；而接口实现类中的接口 方法的可见性只能与接口中相同（public）。

静态内部类与非静态内部类的区别

静态内部类不会持有外围类的引用，而非静态内部类会隐式持有外围类的一个引用。

Java中多态的实现原理

所谓多态，指的就是父类引用指向子类对象，调用方法时会调用子类的实现而不是父类的实现。多态的实现的关键在于“动态绑定”。详细介绍请戳 Java动态绑定的内部实现机制

简述Java中创建新线程的两种方法

• 继承Thread类（假设子类为MyThread），并重写run()方法，然后new一个MyThread对象并对其调用start()即可启动新线程。
• 实现Runnable接口（假设实现类为MyRunnable），而后将MyRunnable对象作为参数传入Thread构造器，在得到的Thread对象上调用start()方法即可。

简述Java中进行线程同步的方法

• volatile: Java Memory Model保证了对同一个volatile变量的写happens before对它的读；
• synchronized:可以来对一个代码块或是对一个方法上锁，被“锁住”的地方称为临界区，进入临界区的线程会获取对象的monitor，这样其他尝试进入临界区的线程会因无法获取monitor而被阻塞。由于等待另一个线程释放monitor而被阻塞的线程无法被中断。
• ReentrantLock: 尝试获取锁的线程可以被中断并可以设置超时参数。

简述Java中具有哪几种粒度的锁

Java中可以对类、对象、方法或是代码块上锁。

给出“生产者-消费者”问题的一种解决方案

使用阻塞队列：

public class BlockingQueueTest { private int size = 20; private ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(size); public static void main(String[] args) { BlockingQueueTest test = new BlockingQueueTest(); Producer producer = test.new Producer(); Consumer consumer = test.new Consumer(); producer.start(); consumer.start(); } class Consumer extends Thread{ @Override public void run() { while(true){ try { //从阻塞队列中取出一个元素 queue.take(); System.out.println("队列剩余" + queue.size() + "个元素"); } catch (InterruptedException e) { } } } } class Producer extends Thread{ @Override public void run() { while (true) { try { //向阻塞队列中插入一个元素 queue.put(1); System.out.println("队列剩余空间：" + (size - queue.size())); } catch (InterruptedException e) { } } } } }

ThreadLocal的设计理念与作用

ThreadLocal的作用是提供线程内的局部变量，在多线程环境下访问时能保证各个线程内的ThreadLocal变量各自独立。也就是说，每个线程的ThreadLocal变量是自己专用的，其他线程是访问不到的。ThreadLocal最常用于以下这个场景：多线程环境下存在对非线程安全对象的并发访问，而且该对象不需要在线程间共享，但是我们不想加锁，这时候可以使用ThreadLocal来使得每个线程都持有一个该对象的副本。

concurrent包的整体架构

ArrayBlockingQueue, CountDownLatch类的作用

• CountDownLatch:允许线程集等待直到计数器为0。适用场景: 当一个或多个线程需要等待指定数目的事件发生后再继续执行。
• ArrayBlockingQueue: 一个基于数组实现的阻塞队列，它在构造时需要指定容量。当试图向满队列中添加元素或者从空队列中移除元素时，当前线程会被阻塞。通过阻塞队列，我们可以按以下模式来工作：工作者线程可以周期性的将中间结果放入阻塞队列中，其它线程可以取出中间结果并进行进一步操作。若工作者线程的执行比较慢（还没来得及向队列中插入元素），其他从队列中取元素的线程会等待它（试图从空队列中取元素从而阻塞）；若工作者线程执行较快（试图向满队列中插入元素），则它会等待其它线程取出元素再继续执行。

wait()，sleep() 的区别

• wait():Object类中定义的实例方法。在指定对象上调用wait方法会让当前线程进入等待状态（前提是当前线程持有该对象的monitor），此时当前线程会释放相应对象的monitor，这样一来其它线程便有机会获取这个对象的monitor了。当其它线程获取了这个对象的monitor并进行了所需操作时，便可以调用notify方法唤醒之前进入等待状态的线程。
• sleep():Thread类中的静态方法，作用是让当前线程进入休眠状态，以便让其他线程有机会执行。进入休眠状态的线程不会释放它所持有的锁。

线程池的用法与优势

• 优势: 实现对线程的复用，避免了反复创建及销毁线程的开销；使用线程池统一管理线程可以减少并发线程的数目，而线程数过多往往会在线程上下文切换上以及线程同步上浪费过多时间。
• 用法: 我们可以调用ThreadPoolExecutor的某个构造方法来自己创建一个线程池。但通常情况下我们可以使用Executors类提供给我们的静态工厂方法来更方便的创建一个线程池对象。创建了线程池对象后，我们就可以调用submit方法提交任务到线程池中去执行了；线程池使用完毕后我们要记得调用shutdown方法来关闭它。

for-each与常规for循环的效率对比

关于这个问题我们直接看《Effective Java》给我们做的解答：

for-each能够让代码更加清晰，并且减少了出错的机会。 下面的惯用代码适用于集合与数组类型：

for (Element e : elements) {

doSomething(e);

}

使用for-each循环与常规的for循环相比，并不存在性能损失，即使对数组进行迭代也是如此。实际上，在有些场合下它还能带来微小的性能提升，因为它只计算一次数组索引的上限。

简述Java IO与NIO的区别

Java IO是面向流的，这意味着我们需要每次从流中读取一个或多个字节，直到读取完所有字节；NIO是面向缓冲的，也就是说会把数据读取到一个缓冲区中，然后对缓冲区中的数据进行相应处理。

Java IO是阻塞IO，而NIO是非阻塞IO。

Java NIO中存在一个称为选择器（selector）的东西，它允许你把多个通道（channel）注册到一个选择器上，然后使用一个线程来监视这些通道：若这些通道里有某个准备好可以开始进行读或写操作了，则开始对相应的通道进行读写。而在等待某通道变为可读/写期间，请求对通道进行读写操作的线程可以去干别的事情。

反射的作用与原理

反射的作用概括地说是运行时获取类的各种定义信息，比如定义了哪些属性与方法。原理是通过类的class对象来获取它的各种信息。

Java中的泛型机制

关于泛型机制的详细介绍请直接戳 Java核心技术点之泛型

常见设计模式

所谓“设计模式”，不过是面向对象编程中一些常用的软件设计手法，并且经过实践的检验，这些设计手法在各自的场景下能解决一些需求，因此它们就成为了如今广为流传的”设计模式“。也就是说，正式因为在某些场景下产生了一些棘手的问题，才催生了相应的设计模式。明确了这一点，我们在学习某种设计模式时要充分理解它产生的背景以及它所解决的主要矛盾是什么。

常用的设计模式可以分为以下三大类：

• 创建型模式: 包括工厂模式（又可进一步分为简单工厂模式、工厂方法模式、抽象工厂模式）、建造者模式、单例模式。
• 结构型模式: 包括适配器模式、桥接模式、装饰模式、外观模式、享元模式、代理模式。
• 行为型模式: 包括命令模式、中介者模式、观察者模式、状态模式、策略模式。

注解的基本概念与使用

注解可以看作是“增强版的注释”，它可以向编译器、虚拟机说明一些事情。 注解是描述Java代码的代码，它能够被编译器解析，注解处理工具在运行时也能够解析注解。注解本身是“被动”的信息，只有主动解析它才有意义。 除了向编译器/虚拟机传递信息，我们也可以使用注解来生成一些“模板化”的代码。

HashMap的那些事

1.1、HashMap的实现原理

1.1.1、结构

HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体，HashMap底层就是一个数组结构，数组中的每一项又是一个链表。如下图所示：

image.png

当新建一个HashMap的时候，就会初始化一个数组。哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点。这些元素一般情况是通过hash(key)%len的规则存储到数组中，也就是元素的key的哈希值对数组长度取模得到。

1.1.2、核心变量

image.png

1.1.3、put存储逻辑

当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标）， 如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。

这里有一个特殊的地方。在JDK1.6中，HashMap采用位桶+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

红黑树

红黑树和平衡二叉树（AVL树）类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。

红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL树中的非常严格的平衡。

1.1.4、get读取逻辑

从HashMap中get元素时，首先计算key的hashCode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。

如果第一个节点是TreeNode,说明采用的是数组+红黑树结构处理冲突，遍历红黑树，得到节点值。

1.1.5、归纳

简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Node 对象。HashMap 底层采用一个 Node<K,V>[] 数组来保存所有的 key-value 对，当需要存储一个 Node 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Node。

1.1.6、HashMap的resize（rehash）

当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，在对HashMap数组进行扩容时，就会出现性能问题：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过160.75=12的时候，就把数组的大小扩展为 216=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

1.2、HashMap在并发场景下的问题和解决方案

1.2.1、多线程put后可能导致get死循环

问题原因就是HashMap是非线程安全的，多个线程put的时候造成了某个key值Entry key List的死循环，问题就这么产生了。

当另外一个线程get 这个Entry List 死循环的key的时候，这个get也会一直执行。最后结果是越来越多的线程死循环，最后导致服务器dang掉。我们一般认为HashMap重复插入某个值的时候，会覆盖之前的值，这个没错。但是对于多线程访问的时候，由于其内部实现机制(在多线程环境且未作同步的情况下，对同一个HashMap做put操作可能导致两个或以上线程同时做rehash动作，就可能导致循环键表出现，一旦出现线程将无法终止，持续占用CPU，导致CPU使用率居高不下)，就可能出现安全问题了。

为HashMap以链表组形式存在，初始数组16位（为何16位，又是一堆移位算法，下一篇文章再写吧），如果长度超过75%，长度增加一倍，多线程操作的时候，恰巧两个线程插入的时候都需要扩容，形成了两个链表，这时候读取，size不一样，报错了。其实这时候报错都是好事，至少不会陷入死循环让cpu死了，有种情况，假如两个线程在读，还有个线程在写，恰巧扩容了，这时候你死都不知道咋死的，直接就是死循环，假如你是双核cpu，cpu占用率就是50%，两个线程恰巧都进入死循环了，得！中奖了。

1.2.2、多线程put的时候可能导致元素丢失

主要问题出在addEntry方法的new Entry (hash, key, value, e)，如果两个线程都同时取得了e,则他们下一个元素都是e，然后赋值给table元素的时候有一个成功有一个丢失。

1.2.3、解决方案

ConcurrentHashMap替换HashMap

Collections.synchronizedMap将HashMap包装起来

1.3、ConcurrentHashMap PK HashTable

ConcurrentHashMap具体是怎么实现线程安全的呢，肯定不可能是每个方法加synchronized，那样就变成了HashTable。

从ConcurrentHashMap代码中可以看出，它引入了一个“分段锁”的概念，具体可以理解为把一个大的Map拆分成N个小的HashTable，根据key.hashCode()来决定把key放到哪个HashTable中。

以空间换时间的结构，跟分布式缓存结构有点像，创建的时候，内存直接分为了16个segment，每个segment实际上还是存储的哈希表（Segment其实就是一个HashMap ），写入的时候，先找到对应的segment，然后锁这个segment，写完，解锁，锁segment的时候，其他segment还可以继续工作。

ConcurrentHashMap如此的设计，优势主要在于： 每个segment的读写是高度自治的，segment之间互不影响。这称之为“锁分段技术”；

二、线程，多线程，线程池的那些事

2.1、线程的各个状态及切换

Java中的线程的生命周期大体可分为5种状态：新建、可运行、运行、阻塞、死亡。

1、新建(NEW)：新创建了一个线程对象。

2、可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

3、运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。

4、阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。

阻塞的情况分三种：

1）等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。

2）同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。

3）其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

5、死亡(DEAD)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

几个方法的比较：

1）Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入阻塞，但不释放对象锁，millis后线程自动苏醒进入可运行状态。作用：给其它线程执行机会的最佳方式。

2）Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的cpu时间片，由运行状态变会可运行状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。

3）t.join()/t.join(long millis)，当前线程里调用其它线程1的join方法，当前线程阻塞，但不释放对象锁，直到线程1执行完毕或者millis时间到，当前线程进入可运行状态。

4）obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒。

5）obj.notify()，唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。

2.2、多线程的实现方式Thread、Runnable、Callable

继承Thread类，实现Runnable接口，实现Callable接口。

这三种方法的介绍和比较：

1、实现Runnable接口相比继承Thread类有如下优势：

1）可以避免由于Java的单继承特性而带来的局限

2）增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的

3）适合多个相同程序代码的线程去处理同一资源的情况

2、实现Runnable接口和实现Callable接口的区别

1）Runnable是自从java1.1就有了，而Callable是1.5之后才加上去的

2）实现Callable接口的任务线程能返回执行结果，而实现Runnable接口的任务线程不能返回结果

3）Callable接口的call()方法允许抛出异常，而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛

4）加入线程池运行，Runnable使用ExecutorService的execute方法，Callable使用submit方法

注：Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取返回结果，当不调用此方法时，主线程不会阻塞

2.3、线程池原理和运行机制

java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类。

在ThreadPoolExecutor类中提供了四个构造方法，主要参数包括下面的参数：

1、int corePoolSize：核心池的大小。

线程池的基本大小，即在没有任务需要执行的时候线程池的大小，并且只有在工作队列满了的情况下才会创建超出这个数量的线程。这里需要注意的是：在刚刚创建ThreadPoolExecutor的时候，线程并不会立即启动，而是要等到有任务提交时才会启动，除非调用了prestartCoreThread/prestartAllCoreThreads事先启动核心线程。再考虑到keepAliveTime和allowCoreThreadTimeOut超时参数的影响，所以没有任务需要执行的时候，线程池的大小不一定是corePoolSize。

2、int maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程，注意与corePoolSize区分。

线程池中允许的最大线程数，线程池中的当前线程数目不会超过该值。如果队列中任务已满，并且当前线程个数小于maximumPoolSize，那么会创建新的线程来执行任务。

3、long keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。

4、TimeUnit unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性。

5、BlockingQueue<Runnable> workQueue：一个阻塞队列，用来存储等待执行的任务。

6、ThreadFactory threadFactory：线程工厂，主要用来创建线程。

7、RejectedExecutionHandler handler：表示当拒绝处理任务时的策略。

还有一个成员变量比较重要：poolSize

线程池中当前线程的数量，当该值为0的时候，意味着没有任何线程，线程池会终止。同一时刻，poolSize不会超过maximumPoolSize。

2.4、线程池对任务的处理

1、如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；

2、如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务（maximumPoolSize）；

3、如果当前线程池中的线程数目达到maximumPoolSize（此时线程池的任务缓存队列已满），则会采取任务拒绝策略进行处理；

任务拒绝策略，通常有以下四种策略：

1）ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

2）ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

3）ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

4）ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

4、如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

2.5、线程池的状态

1、线程池的状态说明：

RUNNING（运行）：接受新任务并处理排队任务。

SHUTDOWN（关闭）：不接受新任务，会处理队列任务。

STOP（停止）：不接受新任务，不处理队列任务，并且中断进程中的任务。

TIDYING（整理）：所有任务都已终止，工作计数为零，线程将执行terminated()方法终止线程。

TERMINATED（已终止）：terminated()方法已完成。

2、各个状态之间的转换

RUNNING -> SHUTDOWN：调用shutdown()方法。

RUNNING or SHUTDOWN-> STOP：调用shutdownNow()方法。

SHUTDOWN -> TIDYING：当队列和池均都为空时。

STOP -> TIDYING：当池为空时。

TIDYING -> TERMINATED：当terminated()方法已完成。

线程和进程有什么区别？

进程和线程的区别：

对于进程来说，子进程是父进程的复制品，从父进程那里获得父进程的数据空间，堆和栈的复制品。

而线程，相对于进程而言，是一个更加接近于执行体的概念，可以和同进程的其他线程之间直接共享数据，而且拥有自己的栈空间，拥有独立序列。

共同点： 它们都能提高程序的并发度，提高程序运行效率和响应时间。线程和进程在使用上各有优缺点。 线程执行开销比较小，但不利于资源的管理和保护，而进程相反。同时，线程适合在SMP机器上运行，而进程可以跨机器迁移。

他们之间根本区别在于 多进程中每个进程有自己的地址空间，线程则共享地址空间。所有其他区别都是因为这个区别产生的。比如说：

1. 速度。线程产生的速度快，通讯快，切换快，因为他们处于同一地址空间。

2. 线程的资源利用率好。

3. 线程使用公共变量或者内存的时候需要同步机制，但进程不用。

而他们通信方式的差异也仍然是由于这个根本原因造成的。

通信方式之间的差异

因为那个根本原因，实际上只有进程间需要通信,同一进程的线程共享地址空间,没有通信的必要，但要做好同步/互斥,保护共享的全局变量。

而进程间通信无论是信号，管道pipe还是共享内存都是由操作系统保证的，是系统调用.

进程间的通信方式