2024Java核心面试题（带全部答案）

小咪咪 2024-04-08 11:24 77阅读 0赞

今天要谈的主题是关于求职，求职是在每个技术人员的生涯中都要经历多次。对于我们大部分人而言，在进入自己心仪的公司之前少不了准备工作，有一份全面细致[面试题][Link 1]将帮助我们减少许多麻烦。在跳槽季来临之前,特地做这个系列的文章，一方面帮助自己巩固下基础，另一方面也希望帮助想要换工作的朋友。

###### 相关概念 ######

###### 面向对象的三个特征 ######

封装，继承，多态，这个应该是人人皆知，有时候也会加上抽象。

###### 多态的好处 ######

允许不同[类对象][Link 2]对同一消息做出响应，即同一消息可以根据发送对象的不同而采用多种不同的行为方式(发送消息就是[函数调用][Link 3])。主要有以下优点：

1.  可替换性：多态对已存在代码具有可替换性
2.  可扩充性：增加新的子类不影响已经存在的类结构
3.  接口性：多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的。
4.  灵活性
5.  简化性

> **篇幅限制下面就只能给大家展示小册部分内容了。包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题**
> 
> **需要全套资料及答案的在【翻到文章底部，点击名片】即可免费获取 备注：“CSDN”**

###### 代码中如何实现多态 ######

实现多态主要有以下三种方式：  
1. 接口实现  
2. 继承父类重写方法  
3. 同一类中进行方法重载

###### 虚拟机是如何实现多态的 ######

动态绑定技术(dynamic binding)，执行期间判断所引用对象的实际类型，根据实际类型调用对应的方法。

###### 接口的意义 ######

接口的意义用三个词就可以概括：规范，扩展，回调。

###### 抽象类的意义 ######

抽象类的意义可以用三句话来概括：

1.  为其他子类提供一个公共的类型
2.  封装子类中重复定义的内容
3.  定义抽象方法,子类虽然有不同的实现，但是定义时一致的

###### 接口和抽象类的区别 ######

<table> 
 <tbody> 
 <tr> 
 <td> 比较 </td> 
 <td> 抽象类 </td> 
 <td> 接口 </td> 
 </tr> 
 <tr> 
 <td> 默认方法 </td> 
 <td> 抽象类可以有默认的方法实现 </td> 
 <td> java 8之前,接口中不存在方法的实现. </td> 
 </tr> 
 <tr> 
 <td> 实现方式 </td> 
 <td> 子类使用extends关键字来继承抽象类.如果子类不是抽象类,子类需要提供抽象类中所声明方法的实现. </td> 
 <td> 子类使用implements来实现接口,需要提供接口中所有声明的实现. </td> 
 </tr> 
 <tr> 
 <td> 构造器 </td> 
 <td> 抽象类中可以有构造器, </td> 
 <td> 接口中不能 </td> 
 </tr> 
 <tr> 
 <td> 和正常类区别 </td> 
 <td> 抽象类不能被实例化 </td> 
 <td> 接口则是完全不同的类型 </td> 
 </tr> 
 <tr> 
 <td> 访问修饰符 </td> 
 <td> 抽象方法可以有public,protected和default等修饰 </td> 
 <td> 接口默认是public,不能使用其他修饰符 </td> 
 </tr> 
 <tr> 
 <td> 多继承 </td> 
 <td> 一个子类只能存在一个父类 </td> 
 <td> 一个子类可以存在多个接口 </td> 
 </tr> 
 <tr> 
 <td> 添加新方法 </td> 
 <td> 想抽象类中添加新方法,可以提供默认的实现,因此可以不修改子类现有的代码 </td> 
 <td> 如果往接口中添加新方法,则子类中需要实现该方法. </td> 
 </tr> 
 </tbody> 
</table>

######  ######

###### 父类的静态方法能否被子类重写 ######

不能。重写只适用于实例方法,不能用于静态方法，而子类当中含有和父类相同签名的静态方法，我们一般称之为隐藏。

###### 什么是不可变对象 ######

不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如 String、Integer及其它包装类。

###### 静态变量和实例变量的区别? ######

静态变量存储在方法区，属于类所有。实例变量存储在堆当中，其引用存在当前线程栈。

###### 能否创建一个包含可变对象的不可变对象? ######

当然可以创建一个包含可变对象的不可变对象的，你只需要谨慎一点，不要共享可变对象的引用就可以了，如果需要变化时，就返回原对象的一个拷贝。最常见的例子就是对象中包含一个日期对象的引用。

###### java 创建对象的几种方式 ######

1.  采用new
2.  通过反射
3.  采用clone
4.  通过序列化机制

前2者都需要显式地调用构造方法。造成耦合性最高的恰好是第一种，因此你发现无论什么框架，只要涉及到解耦必先减少new的使用。

###### switch中能否使用string做参数 ######

在idk 1.7之前，switch只能支持byte, short, char, int或者其对应的封装类以及Enum类型。从idk 1.7之后switch开始支持String。

###### switch能否作用在byte, long上? ######

可以用在byte上，但是不能用在long上。

###### String s1=”ab”, String s2=”a”+”b”, String s3=”a”, String s4=”b”, s5=s3+s4请问s5==s2返回什么？ ######

返回false。在编译过程中，编译器会将s2直接优化为”ab”，会将其放置在常量池当中，s5则是被创建在堆区，相当于s5=new String(“ab”);

###### 你对String对象的intern()熟悉么? ######

intern()方法会首先从常量池中查找是否存在该常量值，如果常量池中不存在则现在常量池中创建，如果已经存在则直接返回。  
比如  
String s1=”aa”;  
String s2=s1.intern();  
System.out.print(s1==s2);//返回true

###### Object中有哪些公共方法? ######

1.  equals()
2.  clone()
3.  getClass()
4.  notify(),notifyAll(),wait()
5.  toString

###### java当中的四种引用 ######

强引用，软引用，弱引用，虚引用。不同的引用类型主要体现在GC上:

1.  强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
2.  软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。
3.  弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象。
4.  虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。

更多了解参见深入对象引用：

http://blog.csdn.net/dd864140130/article/details/49885811

###### WeakReference与SoftReference的区别? ######

这点在四种引用类型中已经做了解释,这里简单说明一下即可:  
虽然 WeakReference 与 SoftReference 都有利于提高 GC 和 内存的效率，但是 WeakReference ，一旦失去最后一个强引用，就会被 GC 回收，而软引用虽然不能阻止被回收，但是可以延迟到 JVM 内存不足的时候。

###### 为什么要有不同的引用类型 ######

不像C语言，我们可以控制内存的申请和释放，在Java中有时候我们需要适当的控制对象被回收的时机，因此就诞生了不同的引用类型，可以说不同的引用类型实则是对GC回收时机不可控的妥协。有以下几个使用场景可以充分的说明：

1.  利用软引用和弱引用解决OOM问题：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题.
2.  通过软引用实现Java对象的高速缓存:比如我们创建了一Person的类，如果每次需要查询一个人的信息,哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这将引起大量Person对象的消耗，并且由于这些对象的生命周期相对较短，会引起多次GC影响性能。此时，通过软引用和 HashMap 的结合可以构建高速缓存，提供性能。

###### java中==和eqauls()的区别,equals()和\`hashcode的区别 ######

==是运算符，用于比较两个变量是否相等，而equals是Object类的方法，用于比较两个对象是否相等。默认Object类的equals方法是比较两个对象的地址，此时和==的结果一样。换句话说：基本类型比较用==，比较的是他们的值。默认下，对象用==比较时，比较的是内存地址，如果需要比较对象内容，需要重写equal方法。

###### equals()和hashcode()的联系 ######

hashCode()是Object类的一个方法，返回一个哈希值。如果两个对象根据equal()方法比较相等，那么调用这两个对象中任意一个对象的hashCode()方法必须产生相同的哈希值。  
如果两个对象根据eqaul()方法比较不相等，那么产生的哈希值不一定相等(碰撞的情况下还是会相等的。)

###### a.hashCode()有什么用?与a.equals(b)有什么关系 ######

hashCode() 方法是相应对象整型的 hash 值。它常用于基于 hash 的集合类，如 Hashtable、HashMap、LinkedHashMap等等。它与 equals() 方法关系特别紧密。根据 Java 规范，使用 equal() 方法来判断两个相等的对象，必须具有相同的 hashcode。

将对象放入到集合中时，首先判断要放入对象的hashcode是否已经在集合中存在，不存在则直接放入集合。如果hashcode相等，然后通过equal()方法判断要放入对象与集合中的任意对象是否相等：如果equal()判断不相等，直接将该元素放入集合中，否则不放入。

###### 有没有可能两个不相等的对象有相同的hashcode ######

有可能，两个不相等的对象可能会有相同的 hashcode 值，这就是为什么在 hashmap 中会有冲突。如果两个对象相等，必须有相同的hashcode 值，反之不成立。

###### 可以在hashcode中使用随机数字吗? ######

不行，因为同一对象的 hashcode 值必须是相同的

###### a==b与a.equals(b)有什么区别 ######

如果a 和b 都是对象，则 a==b 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的同一个对象才会返回 true，而 a.equals(b) 是进行逻辑比较，所以通常需要重写该方法来提供逻辑一致性的比较。例如，String 类重写 equals() 方法，所以可以用于两个不同对象，但是包含的字母相同的比较。

###### 3\*0.1==0.3返回值是什么 ######

false，因为有些浮点数不能完全精确的表示出来。

###### a=a+b与a+=b有什么区别吗? ######

\+=操作符会进行隐式自动类型转换，此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型，而a=a+b则不会自动进行类型转换。如：  
byte a = 127;  
byte b = 127;  
b = a + b; // error : cannot convert from int to byte  
b += a; // ok  
（译者注：这个地方应该表述的有误，其实无论 a+b 的值为多少，编译器都会报错，因为 a+b 操作会将 a、b 提升为 int 类型，所以将 int 类型赋值给 byte 就会编译出错）

###### short s1= 1; s1 = s1 + 1; 该段代码是否有错,有的话怎么改？ ######

有错误，short类型在进行运算时会自动提升为int类型，也就是说s1+1的运算结果是int类型。

###### short s1= 1; s1 += 1; 该段代码是否有错，有的话怎么改？ ######

\+=操作符会自动对右边的表达式结果强转匹配左边的数据类型，所以没错。

###### & 和 &&的区别 ######

首先记住&是位操作，而&&是逻辑运算符。另外需要记住逻辑运算符具有短路特性，而&不具备短路特性。

1.  public class Test\{
2.  static String name;
3.  
4.  public static void main(String\[\] args)\{
5.  if(name!=null&userName.equals(""))\{
6.  System.out.println("ok");
7.  \}else\{
8.  System.out.println("erro");
9.  \}
10. \}
11. \}

以上代码将会抛出空指针异常。

###### 一个java文件内部可以有类？(非内部类) ######

只能有一个public公共类，但是可以有多个default修饰的类。

###### 如何正确的退出多层嵌套循环？ ######

1.  使用标号和break;
2.  通过在外层循环中添加标识符

###### 内部类的作用 ######

内部类可以有多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立.在单个外围类当中，可以让多个内部类以不同的方式实现同一接口，或者继承同一个类.创建内部[类对象][Link 2]的时刻不依赖于外部[类对象][Link 2]的创建。内部类并没有令人疑惑的”is-a”管系，它就像是一个独立的实体。

内部类提供了更好的封装，除了该外围类，其他类都不能访问。

###### final, finalize和finally的不同之处 ######

final 是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。finalize 方法是在对象被回收之前调用的方法，给对象自己最后一个复活的机会，但是什么时候调用 finalize 没有保证。finally 是一个关键字，与 try 和 catch 一起用于异常的处理。finally 块一定会被执行，无论在 try 块中是否有发生异常。

###### clone()是哪个类的方法? ######

java.lang.Cloneable 是一个标示性接口，不包含任何方法，clone 方法在 object 类中定义。并且需要知道 clone() 方法是一个本地方法，这意味着它是由 c 或 c++ 或 其他本地语言实现的。

###### 深拷贝和浅拷贝的区别是什么? ######

浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

深拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

###### static都有哪些用法? ######

几乎所有的人都知道static关键字这两个基本的用法：静态变量和静态方法。也就是被static所修饰的变量/方法都属于类的静态资源，类实例所共享。

除了静态变量和静态方法之外，static也用于静态块，多用于初始化操作：

1.  public calss PreCache\{
2.  static\{
3.  *//执行相关操作*
4.  \}
5.  \}

此外static也多用于修饰内部类，此时称之为静态内部类。

最后一种用法就是静态导包，即import static.import static是在JDK 1.5之后引入的新特性，可以用来指定导入某个类中的静态资源，并且不需要使用类名。资源名，可以直接使用资源名，比如：

1.  import static java.lang.Math.\*;
2.  
3.  public class Test\{
4.  
5.  public static void main(String\[\] args)\{
6.  *//System.out.println(Math.sin(20));传统做法*
7.  System.out.println(sin(20));
8.  \}
9.  \}

######  ######

###### final有哪些用法 ######

final也是很多面试喜欢问的地方，能回答下以下三点就不错了：  
1.被final修饰的类不可以被继承  
2.被final修饰的方法不可以被重写  
3.被final修饰的变量不可以被改变。如果修饰引用，那么表示引用不可变，引用指向的内容可变。  
4.被final修饰的方法，JVM会尝试将其内联，以提高运行效率  
5.被final修饰的常量，在编译阶段会存入常量池中。

回答出编译器对final域要遵守的两个重排序规则更好：  
1.在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。  
2.初次读一个包含final域的对象的引用，与随后初次读这个final域,这两个操作之间不能重排序。

###### 数据类型相关 ######

###### java中int char,long各占多少字节? ######

<table> 
 <tbody> 
 <tr> 
 <td> 类型 </td> 
 <td> 位数 </td> 
 <td> 字节数 </td> 
 </tr> 
 <tr> 
 <td> short </td> 
 <td> 2 </td> 
 <td> 16 </td> 
 </tr> 
 <tr> 
 <td> int </td> 
 <td> 4 </td> 
 <td> 32 </td> 
 </tr> 
 <tr> 
 <td> long </td> 
 <td> 8 </td> 
 <td> 64 </td> 
 </tr> 
 <tr> 
 <td> float </td> 
 <td> 4 </td> 
 <td> 32 </td> 
 </tr> 
 <tr> 
 <td> double </td> 
 <td> 8 </td> 
 <td> 64 </td> 
 </tr> 
 <tr> 
 <td> char </td> 
 <td> 2 </td> 
 <td> 16 </td> 
 </tr> 
 </tbody> 
</table>

###### 64位的JVM当中,int的长度是多少? ######

Java 中，int 类型变量的长度是一个固定值，与平台无关，都是 32 位。意思就是说，在 32 位 和 64 位 的Java 虚拟机中，int 类型的长度是相同的。

###### int和Integer的区别 ######

Integer是int的包装类型，在拆箱和装箱中，二者自动转换。int是基本类型，直接存数值，而integer是对象，用一个引用指向这个对象。

###### int 和Integer谁占用的内存更多? ######

Integer 对象会占用更多的内存。Integer是一个对象，需要存储对象的元数据。但是 int 是一个原始类型的数据，所以占用的空间更少。

###### String, StringBuffer和StringBuilder区别 ######

String是字符串常量，final修饰：StringBuffer字符串变量(线程安全)；  
StringBuilder 字符串变量(线程不安全)。

###### String和StringBuffer ######

String和StringBuffer主要区别是性能：String是不可变对象，每次对String类型进行操作都等同于产生了一个新的String对象，然后指向新的String对象。所以尽量不在对String进行大量的拼接操作，否则会产生很多临时对象，导致GC开始工作，影响系统性能。

StringBuffer是对对象本身操作，而不是产生新的对象，因此在有大量拼接的情况下，我们建议使用StringBuffer。

但是需要注意现在JVM会对String拼接做一定的优化：  
String s=“This is only ”+”simple”+”test”会被虚拟机直接优化成String s=“This is only simple test”，此时就不存在拼接过程。

###### StringBuffer和StringBuilder ######

StringBuffer是线程安全的可变字符串，其内部实现是可变数组。StringBuilder是jdk 1.5新增的，其功能和StringBuffer类似，但是非线程安全。因此，在没有多线程问题的前提下，使用StringBuilder会取得更好的性能。

###### 什么是编译器常量？使用它有什么风险？ ######

公共静态不可变（public static final ）变量也就是我们所说的编译期常量，这里的 public 可选的。实际上这些变量在编译时会被替换掉，因为编译器知道这些变量的值，并且知道这些变量在运行时不能改变。这种方式存在的一个问题是你使用了一个内部的或第三方库中的公有编译时常量，但是这个值后面被其他人改变了，但是你的客户端仍然在使用老的值，甚至你已经部署了一个新的jar。为了避免这种情况，当你在更新依赖 JAR 文件时，确保重新编译你的程序。

###### java当中使用什么类型表示价格比较好? ######

如果不是特别关心内存和性能的话，使用BigDecimal，否则使用预定义精度的 double 类型。

###### 如何将byte转为String ######

可以使用 String 接收 byte\[\] 参数的构造器来进行转换，需要注意的点是要使用的正确的编码，否则会使用平台默认编码，这个编码可能跟原来的编码相同，也可能不同。

###### 可以将int强转为byte类型么?会产生什么问题? ######

我们可以做强制转换，但是Java中int是32位的而byte是8 位的，所以,如果强制转化int类型的高24位将会被丢弃，byte 类型的范围是从-128到128

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

###### 关于垃圾回收 ######

###### 你知道哪些垃圾回收算法? ######

垃圾回收从理论上非常容易理解,具体的方法有以下几种:  
1. 标记-清除  
2. 标记-复制  
3. 标记-整理  
4. 分代回收  
更详细的内容参见深入理解垃圾回收算法：

http://blog.csdn.net/dd864140130/article/details/50084471

###### 如何判断一个对象是否应该被回收 ######

这就是所谓的对象存活性判断，常用的方法有两种：1.引用计数法;　2.对象可达性分析。由于引用计数法存在互相引用导致无法进行GC的问题，所以目前JVM虚拟机多使用对象可达性分析算法。

###### 简单的解释一下垃圾回收 ######

Java 垃圾回收机制最基本的做法是分代回收。内存中的区域被划分成不同的世代，对象根据其存活的时间被保存在对应世代的区域中。一般的实现是划分成3个世代：年轻、年老和永久。内存的分配是发生在年轻世代中的。当一个对象存活时间足够长的时候，它就会被复制到年老世代中。对于不同的世代可以使用不同的垃圾回收算法。进行世代划分的出发点是对应用中对象存活时间进行研究之后得出的统计规律。一般来说，一个应用中的大部分对象的存活时间都很短。比如局部变量的存活时间就只在方法的执行过程中。基于这一点，对于年轻世代的垃圾回收算法就可以很有针对性。

###### 调用System.gc()会发生什么? ######

通知GC开始工作，但是GC真正开始的时间不确定。

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

###### 进程,线程相关 ######

###### 说说进程，线程，协程之间的区别 ######

简而言之，进程是程序运行和资源分配的基本单位，一个程序至少有一个进程，一个进程至少有一个线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存资源，减少切换次数，从而效率更高。线程是进程的一个实体，是cpu调度和分派的基本单位，是比程序更小的能独立运行的基本单位。同一进程中的多个线程之间可以并发执行。

###### 你了解守护线程吗？它和非守护线程有什么区别 ######

程序运行完毕，jvm会等待非守护线程完成后关闭，但是jvm不会等待守护线程。守护线程最典型的例子就是GC线程。

###### 什么是多线程上下文切换 ######

多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU执行权的线程的过程。

###### 创建两种线程的方式?他们有什么区别? ######

通过实现java.lang.Runnable或者通过扩展java.lang.Thread类。相比扩展Thread，实现Runnable接口可能更优.原因有二：

1.  Java不支持多继承。因此扩展Thread类就代表这个子类不能扩展其他类。而实现Runnable接口的类还可能扩展另一个类。
2.  类可能只要求可执行即可，因此继承整个Thread类的开销过大。

###### Thread类中的start()和run()方法有什么区别? ######

start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。

###### 怎么检测一个线程是否持有对象监视器 ######

Thread类提供了一个holdsLock(Object obj)方法，当且仅当对象obj的监视器被某条线程持有的时候才会返回true，注意这是一个static方法，这意味着”某条线程”指的是当前线程。

###### Runnable和Callable的区别 ######

Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。  
这其实是很有用的一个特性，因为多线程相比单线程更难、更复杂的一个重要原因就是因为多线程充满着未知性，某条线程是否执行了？某条线程执行了多久？某条线程执行的时候我们期望的数据是否已经赋值完毕？无法得知，我们能做的只是等待这条多线程的任务执行完毕而已。而Callable+Future/FutureTask却可以方便获取多线程运行的结果，可以在等待时间太长没获取到需要的数据的情况下取消该线程的任务。

###### 什么导致线程阻塞 ######

阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 说明 </td> 
 </tr> 
 <tr> 
 <td> sleep() </td> 
 <td> sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。 典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止 </td> 
 </tr> 
 <tr> 
 <td> suspend() 和 resume() </td> 
 <td> 两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。 </td> 
 </tr> 
 <tr> 
 <td> yield() </td> 
 <td> yield() 使当前线程放弃当前已经分得的CPU 时间，但不使当前线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程 </td> 
 </tr> 
 <tr> 
 <td> wait() 和 notify() </td> 
 <td> 两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。 </td> 
 </tr> 
 </tbody> 
</table>

######  ######

###### wait(),notify()和suspend(),resume()之间的区别 ######

初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。上述的核心区别导致了一系列的细节上的区别。

首先，前面叙述的所有方法都隶属于 Thread 类，但是这一对却直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。初看起来这十分不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。而调用 任意对象的notify()方法则导致从调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。

其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常。

wait() 和 notify() 方法的上述特性决定了它们经常和synchronized关键字一起使用，将它们和操作系统进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能，它们的执行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）。它们的结合使得我们可以实现操作系统上一系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题。

关于 wait() 和 notify() 方法最后再说明两点：  
第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。

第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。

谈到阻塞，就不能不谈一谈死锁，略一分析就能发现，suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是，Java 并不在语言级别上支持死锁的避免，我们在编程中必须小心地避免死锁。

以上我们对 Java 中实现线程阻塞的各种方法作了一番分析，我们重点分析了 wait() 和 notify() 方法，因为它们的功能最强大，使用也最灵活，但是这也导致了它们的效率较低，较容易出错。实际使用中我们应该灵活使用各种方法，以便更好地达到我们的目的。

###### 产生死锁的条件 ######

1.互斥条件：一个资源每次只能被一个进程使用。  
2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。  
3.不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。  
4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

###### 为什么wait()方法和notify()/notifyAll()方法要在同步块中被调用 ######

这是JDK强制的，wait()方法和notify()/notifyAll()方法在调用前都必须先获得对象的锁

###### wait()方法和notify()/notifyAll()方法在放弃对象监视器时有什么区别 ######

wait()方法和notify()/notifyAll()方法在放弃对象监视器的时候的区别在于：wait()方法立即释放对象监视器，notify()/notifyAll()方法则会等待线程剩余代码执行完毕才会放弃对象监视器。

###### wait()与sleep()的区别 ######

关于这两者已经在上面进行详细的说明,这里就做个概括好了:

*  sleep()来自Thread类，和wait()来自Object类。调用sleep()方法的过程中，线程不会释放对象锁。而 调用 wait 方法线程会释放对象锁
 *  sleep()睡眠后不出让系统资源，wait让其他线程可以占用CPU
 *  sleep(milliseconds)需要指定一个睡眠时间，时间一到会自动唤醒.而wait()需要配合notify()或者notifyAll()使用

###### 为什么wait, nofity和nofityAll这些方法不放在Thread类当中 ######

一个很明显的原因是JAVA提供的锁是对象级的而不是线程级的，每个对象都有锁，通过线程获得。如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果wait()方法定义在Thread类中，线程正在等待的是哪个锁就不明显了。简单的说，由于wait，notify和notifyAll都是锁级别的操作，所以把他们定义在Object类中因为锁属于对象。

[Link 1]: https://so.csdn.net/so/search?q=%E9%9D%A2%E8%AF%95%E9%A2%98&spm=1001.2101.3001.7020
[Link 2]: https://so.csdn.net/so/search?q=%E7%B1%BB%E5%AF%B9%E8%B1%A1&spm=1001.2101.3001.7020
[Link 3]: https://so.csdn.net/so/search?q=%E5%87%BD%E6%95%B0%E8%B0%83%E7%94%A8&spm=1001.2101.3001.7020