————————————————
面向对象编程有哪些特征？
类和对象体现了抽象和封装
抽象就是解释类与对象之间关系的词。类与对象之间的关系就是抽象的关系。一句话来说明：类是对象的抽象，而对象则是类得特例，即类的具体表现形式。
封装两个方面的含义：一是将有关数据和操作代码封装在对象当中，形成一个基本单位，各个对象之间相对独立互不干扰。二是将对象中某些属性和操作私有化，已达到数据和操作信息隐蔽，有利于数据安全，防止无关人员修改。把一部分或全部属性和部分功能（函数）对外界屏蔽，就是从外界（类的大括号之外）看不到，不可知，这就是封装的意义。
面向对象的继承是为了软件重用，简单理解就是代码复用，把重复使用的代码精简掉的一种手段。如何精简，当一个类中已经有了相应的属性和操作的代码，而另一个类当中也需要写重复的代码，那么就用继承方法，把前面的类当成父类，后面的类当成子类，子类继承父类，理所当然。就用一个关键字 extends 就完成了代码的复用。
没有继承就没有多态，继承是多态的前提。虽然继承自同一父类，但是相应的操作却各不相同，这叫多态。由继承而产生的不同的派生类，其对象对同一消息会做出不同的响应。 JDK、JRE、JVM 之间有什么关系？
/xml/ns/javaee/web-app_2_" @RequestMapping注解是一个用来处理请求地址映射的注解，可用于类或方法上。 用于类上，则表示类中的所有响应请求的方法都是以该地址作为父路径。
启动的是本地服务，默认端口是 8080，通过浏览器访问的路径就是如下地址：
默认情况下是单例模式，在多线程进行访问时存在线程安全的问题。
解决方法可以在控制器中不要写成员变量，这是因为单例模式下定义成员变量是线程不安全的。
使用单例模式是为了性能，无需频繁进行初始化操作，同时也没有必要使用多例模式。 RequestMethod 可以同时支持 POST 和 GET 请求访问吗？
GET（SELECT）：从服务器查询，在服务器通过请求参数区分查询的方式。
POST（CREATE）：在服务器新建一个资源，调用 insert 操作。
DELETE（DELETE）：从服务器删除资源，调用 delete 语句。 Spring 依赖注入有几种实现方式？
1）Constructor 构造器注入：通过将 @Autowired 注解放在构造器上来完成构造器注入，默认构造器参数通过类型自动装配。
2）Field 接口注入：通过将 @Autowired 注解放在构造器上来完成接口注入。
3）Setter 方法参数注入：通过将 @Autowired 注解放在方法上来完成方法参数注入。
通知（advice）是在程序中想要应用在其他模块中横切关注点的实现。
前置通知（BeforeAdvice）：在连接点之前执行的通知（advice），除非它抛出异常，否则没有能力中断执行流。
返回之后通知（AfterRetuningAdvice）：如果一个方法没有抛出异常正常返回，在连接点正常结束之后执行的通知（advice）。
抛出（异常）后执行通知（AfterThrowingAdvice）：若果一个方法抛出异常来退出的话，这个通知（advice）就会被执行。
后置通知（AfterAdvice）：无论连接点是通过什么方式退出的正常返回或者抛出异常都会执行在结束后执行这些通知（advice）。
围绕通知（AroundAdvice）：围绕连接点执行的通知（advice），只有这一个方法调用。这是最强大的通知（advice）。 Spring AOP 连接点和切入点是什么？
连接点是指一个应用执行过程中能够插入一个切面的点，可以理解成一个方法的执行或者一个异常的处理等。
连接点可以是调用方法、抛出异常、修改字段等时，切面代码可以利用这些点插入到应用的正规流程中。使得程序执行过程中能够应用通知的所有点。
在 Spring AOP 中一个连接点总是代表一个方法执行。如果在这些方法上使用横切的话，所有定义在 EmpoyeeManager 接口中的方法都可以被认为是一个连接点。
切入点是一个匹配连接点的断言或者表达式，如果通知定义了 “什么” 和 “何时”，那么切点就定义了 “何处”。
通知（Advice）与切入点表达式相关联，切入点用于准确定位，确定在什么地方应用切面通知。
Spring 默认使用 AspectJ 切入点表达式，由切入点表达式匹配的连接点概念是 AOP 的核心。 Spring AOP 代理模式是什么？
代理模式是使用非常广泛的设计模式之一。
代理模式是指给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是生活中常见的房产中介。
Spring AOP 代理是一个由 AOP 框架创建的用于在运行时实现切面协议的对象。
Spring AOP 默认为 AOP 代理使用标准的 JDK 动态代理，这使得任何接口（或者接口的集合）可以被代理。
Spring AOP 也可以使用 CGLIB 代理，如果业务对象没有实现任何接口那么默认使用 CGLIB。 Spring 框架有哪些特点？
1）方便解耦，简化开发
通过 Spring 提供的 IoC 容器，可以将对象之间的依赖关系交由 Spring 进行控制，避免编码所造成的过度耦合。使用 Spring 可以使用户不必再为单实例模式类、属性文件解析等底层的需求编码，可以更专注于上层的业务逻辑应用。
2）支持 AOP 面向切面编程
通过 Spring 提供的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松完成。
通过 Spring 可以从单调繁琐的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
使用非容器依赖的编程方式进行几乎所有的测试工作，通过 Spring 使得测试不再是高成本的操作，而是随手可做的事情。Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序。
5）方便便捷集成各种中间件框架
Spring 配置元数据可以采用三种方式，可以混合使用。
1）基于 XML 的配置元数据
使用 XML 文件标签化配置 Bean 的相关属性。
| 此项必填，指定要创建 Bean 的类 (全路径) |
| 全局唯一 指定 bean 的唯一标示符 |
| 全局唯一 指定 bean 的唯一标示符 |
| 对象初始化后调用的方法 |
| 容器启动时不会初始化，只有使用时初始化 |
2）基于注解的配置元数据
3）基于 Java 的配置元数据
目前常用的方式是第二种和第三种，也经常结合使用。
HTTP1.0 规定浏览器与服务器只保持短暂的连接，浏览器的每次请求都需要与服务器建立一个 TCP 连接，服务器完成请求处理后立即断开 TCP 连接，服务器不跟踪每个客户也不记录过去的请求。
HTTP1.1 支持长连接，在请求头中有 Connection：Keep-Alive。在一个 TCP 连接上可以传送多个 HTTP 请求和响应，减少了建立和关闭连接的消耗和延迟。
HTTP1.0 中存在一些浪费带宽的现象，例如客户端只是需要某个对象的一部分，而服务器却将整个对象传输过去，并且不支持断点续传功能。
HTTP1.1 支持只发送 header 信息，不携带其他任何 body 信息，如果服务器认为客户端有权限请求服务器，则返回 100 状态码，客户端接收到 100 状态码后把请求 body 发送到服务器；如果返回 401 状态码，客户端无需发送请求 body 节省带宽。
HTTP1.0 没有 host 域，HTTP1.0 中认为每台服务器都绑定一个唯一的 IP 地址，因此，请求消息中的 URL 并没有传递主机名（hostname）。
HTTP1.1 的请求消息和响应消息都支持 host 域，且请求消息中若是 host 域会报告 400 Bad Request 错误。一台物理服务器上可以同时存在多个虚拟主机（Multi-homed Web Servers），并且它们可以共享一个 IP 地址。
HTTP1.1 中新增 24 个错误状态响应码，比如 409（Conflict）表示请求的资源与资源的当前状态发生冲突；410（Gone）表示服务器上的某个资源被永久性的删除。 HTTP1.1 和 HTTP2.0 有什么区别？
HTTP2.0 使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比 HTTP1.1 大了好几个数量级。
HTTP1.1 可以建立多个 TCP 连接来支持处理更多并发的请求，但是创建 TCP 连接本身也是有开销的。
HTTP1.1 中 HTTP 请求和响应都是由状态行、请求 / 响应头部、消息主体三部分组成。
一般而言，消息主体都会经过 gzip 压缩或本身传输的就是压缩过后的二进制文件，但状态行和头部却没有经过任何压缩，直接以纯文本传输。
随着 Web 功能越来越复杂，每个页面产生的请求数也越来越多，导致消耗在头部的流量越来越多，尤其是每次都要传输 UserAgent、Cookie 等不会频繁变动的内容，完全是一种浪费资源的体现。
HTTP1.1 不支持 header 数据的压缩，而 HTTP2.0 使用 HPACK 算法对 header 的数据进行压缩，压缩的数据体积小，在网络上传输更快。
服务端推送是一种在客户端请求前发送数据的机制。
网页中使用了许多资源：HTML、样式表、脚本、图片等，在 HTTP1.1 中这些资源每一个都必须明确地请求，这是一个很慢的过程。
浏览器从获取 HTML 开始，然后在它解析和评估页面时获取更多的资源，因为服务器必须等待浏览器做每一个请求，网络经常是空闲和未充分使用的。
HTTP2.0 引入了 server push，允许服务端推送资源给浏览器，在浏览器明确请求前，不用客户端再次创建连接发送请求到服务器端获取，客户端可以直接从本地加载这些资源，不用再通过网络。 Spring Boot 支持哪几种内嵌容器？
Spring Boot 内嵌容器支持 Tomcat、Jetty、Undertow 等应用服务的 starter 启动器，在应用启动时被加载，可以快速的处理应用所需要的一些基础环境配置。
starter 解决的是依赖管理配置复杂的问题，可以理解成通过 pom.xml 文件配置很多 jar 包组合的 maven 项目，用来简化 maven 依赖配置，starter 可以被继承也可以依赖于别的 starter。
| 核心启动器，包括自动配置支持，日志记录和 YAML |
| 用于构建 RSocket 客户端和服务器的启动器 |
分布式架构中断路器模式的作用基本类似的，当某个服务单元发生故障，类似家用电器发生短路后，通过断路器的故障监控，类似熔断保险丝，向调用方返回一个错误响应，不需要长时间的等待。这样就不会出现因被调用的服务故障，导致线程长时间占用而不释放，避免了在分布式系统中故障的蔓延。 Spring Cloud 核心组件有哪些？
Eureka：服务注册与发现，Eureka 服务端称服务注册中心，Eureka 客户端主要处理服务的注册与发现。
Feign：基于 Feign 的动态代理机制，根据注解和选择的机器，拼接请求 url 地址，发起请求。
Ribbon：负载均衡，服务间发起请求时基于 Ribbon 实现负载均衡，从一个服务的多台机器中选择一台。
Hystrix：提供服务隔离、熔断、降级机制，发起请求是通过 Hystrix 提供的线程池，实现不同服务调用之间的隔离，避免服务雪崩问题。
Zuul：服务网关，前端调用后端服务，统一由 Zuul 网关转发请求给对应的服务。 Spring Cloud 如何实现服务的注册？
1、当服务发布时，指定对应的服务名，将服务注册到注册中心，比如 Eureka、Zookeeper 等。
服务注册表是一个记录当前可用服务实例的网络信息的数据库，是服务发现机制的核心。
服务注册表提供查询 API 和管理 API，使用查询 API 获得可用的服务实例，使用管理 API 实现注册和注销；
Spring Cloud Config 为分布式系统中的外部配置提供服务器和客户端支持，可以方便的对微服务各个环境下的配置进行实时更新、集中式管理。
1）假设某一时间某个微服务宕机了，而 Eureka 不会自动清除，依然对微服务的信息进行保存。
2）在默认的情况系，Eureka Server 在一定的时间内没有接受到微服务的实例心跳（默认为 90 秒），Eureka Server 将会注销该实例。
3）但是在网络发生故障时微服务在 Eureka Server 之间是无法通信的，因为微服务本身实例是健康的，此刻本不应该注销这个微服务。那么 Eureka 自我保护模式就解决了这个问题。
4）当 Eureka Server 节点在短时间内丢失过客户端时包含发生的网络故障，那么节点就会进行自我保护。
5）一但进入自我保护模式，Eureka Server 就会保护服务注册表中的信息，不再删除服务注册表中的数据注销任何微服务。
6）当网络故障恢复后，这个 Eureka Server 节点会自动的退出自我保护机制。
7）在自我保护模式中 Eureka Server 会保护服务注册表中的信息，不在注销任何服务实例，当重新收到心跳恢复阀值以上时，这个 Eureka Server 节点就会自动的退出自我保护模式，这种设计模式是为了宁可保留错误的服务注册信息，也不盲目的注销删除任何可能健康的服务实例。
8）自我保护机制就是一种对网络异常的安全保护实施，它会保存所有的微服务，不管健康或不健康的微服务都会保存，而不会盲目的删除任何微服务，可以让 Eureka 集群更加的健壮、稳定。
9）在 Eureka Server 端可取消自我保护机制，但是不建议取消此功能。 常用的并发工具类有哪些？
CountDownLatch 是一个同步计数器，初始化时传入需要计数线程的等待数，可能是等于或大于等待执行完的线程数。调用多个线程之间的同步或说起到线程之间的通信（不是互斥）一组线程等待其他线程完成工作后在执行，相当于加强的 join。
CyclicBarrier 字面意思是栅栏，是多线程中重要的类，主要用于线程之间互相等待的问题，初始化时传入需要等待的线程数。
作用：让一组线程达到某个屏障被阻塞直到一组内最后一个线程达到屏蔽时，屏蔽开放，所有被阻塞的线程才会继续运行。
semaphore 称为信号量是操作系统的一个概念，在 Java 并发编程中，信号量控制的是线程并发的数量。
作用：semaphore 管理一系列许可每个 acquire () 方法阻塞，直到有一个许可证可以获得，然后拿走许可证，每个 release 方法增加一个许可证，这可能会释放一个阻塞的 acquire () 方法，然而并没有实际的许可保证这个对象，semaphore 只是维持了一个可获取许可的数量，主要控制同时访问某个特定资源的线程数量，多用在流量控制。
Exchange 类似于交换器可以在队中元素进行配对和交换线程的同步点，用于两个线程之间的交换。
具体来说，Exchanger 类允许两个线程之间定义同步点，当两个线程达到同步点时，它们交换数据结构，因此第一个线程的数据结构进入到第二个线程当中，第二个线程的数据结构进入到第一个线程当中。 并发和并行有什么区别？
并行（parallellism）是指两个或者多个事件在同一时刻发生，而并发（parallellism）是指两个或多个事件在同一时间间隔发生。
并行是在不同实体上的多个事件，而并发是在同一实体上的多个事件。
并行是在一台处理器上同时处理多个任务（Hadoop 分布式集群），而并发在多台处理器上同时处理多个任务。 JSP 模版引擎如何解析 ${} 表达式？
目前开发中已经很少使用 JSP 模版引擎，JSP 虽然是一款功能比较强大的模板引擎，并被广大开发者熟悉，但它前后端耦合比较高。
其次是 JSP 页面的效率没有 HTML 高，因为 JSP 是同步加载。而且 JSP 需要 Tomcat 应用服务器部署，但不支持 Nginx 等，已经快被时代所淘汰。
JSP 页面中使用 ${表达式} 展示数据，但是页面上并没有显示出对应数据，而是把 ${表达式} 当作纯文本显示。
原因分析：这是由于 jsp 模版引擎默认会无视 EL 表达式，需要手动设置 igNoreEL 为 false。
什么是服务熔断？什么是服务降级？
熔断机制是应对雪崩效应的一种微服务链路保护机制。
当某个微服务不可用或者响应时间过长时会进行服务降级，进而熔断该节点微服务的调用，快速返回 “错误” 的响应信息。
当检测到该节点微服务调用响应正常后恢复调用链路。
在 Spring Cloud 框架里熔断机制通过 Hystrix 实现，Hystrix 会监控微服务间调用的状况，当失败的调用到一定阈值，缺省是 5 秒内调用 20 次，如果失败，就会启动熔断机制。
服务降级一般是从整体负荷考虑，当某个服务熔断后，服务器将不再被调用，此时客户端可以准备一个本地 fallback 回调，返回一个缺省值。这样做目的是虽然水平下降，但是是可以使用，相比直接挂掉要强很多。
Spring Boot 是 Spring 推出用于解决传统框架配置文件冗余，装配组件繁杂的基于 Maven 的解决方案，旨在快速搭建单个微服务。
Spring Cloud 专注于解决各个微服务之间的协调与配置，整合并管理各个微服务，为各个微服务之间提供配置管理、服务发现、断路器、路由、事件总线等集成服务。
Spring Boot 专注于快速、方便的开发单个的微服务个体，Spring Cloud 是关注全局的服务治理框架。 你都知道哪些微服务技术栈？
| 服务接口调用（客户端调用服务发简单工具） |
| 服务路由（API 网关） |
| 接口和抽象类有什么区别？ |
| 抽象类可以有默认的方法实现 | JDK1。8 之前版本，接口中不存在方法的实现 |
| 子类使用 extends 关键字来继承抽象类。如果子类不是抽象类，子类需要提供抽象类中所声明方法的实现 | 子类使用 implements 来实现接口，需要提供接口中所有声明的实现。 |
| 接口则是完全不同的类型 | |
| 接口默认是 public，不能使用其他修饰符 | |
| 一个子类只能存在一个父类 | 一个子类可以存在多个接口 |
| 抽象类中添加新方法，可以提供默认的实现，因此可以不修改子类现有的代码 | 如果往接口中添加新方法，则子类中需要实现该方法 |
线程死锁是指多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
产生死锁必须具备以下四个条件：
互斥条件：该资源任意一个时刻只由一个线程占用；
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源持有不释放；
不剥夺条件：线程已获得的资源，在末使用完之前不能被其他线程强行剥夺，只有使用完毕后才释放资源；
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。 如何避免线程死锁？
只需要破坏产生死锁的四个条件中任意一个就可以避免线程死锁，但是互斥条件是没有办法破坏的，因为锁的意义就是想让线程之间存在资源互斥访问。
1）破坏请求与保持条件，一次性申请所有的资源；
2）破坏不剥夺条件，占用部分资源的线程进一步申请其他资源时如果申请不到，使其主动释放占有的资源；
3）破坏循环等待条件，按序申请资源来预防线程死锁，按某一顺序申请资源，释放资源则反序释放。 父类中静态方法能否被子类重写？
父类中静态方法不能被子类重写。
重写只适用于实例方法，不能用于静态方法，而且子类当中含有和父类相同签名的静态方法，一般称之为隐藏。
如上述代码所示，如果能够被重写，则输出的应该是 “这是子类静态方法”。与此类似的是，静态变量也不能被重写。如果想要调用父类的静态方法，应该使用类来直接调用。
什么是不可变对象？有什么好处？
不可变对象是指对象一旦被创建，状态就不能再改变，任何修改都会创建一个新的对象。
不可变对象最大的好处是线程安全。 静态变量和实例变量有什么区别？
静态变量：独立存在的变量，只是位置放在某个类下，可以直接类名加点调用静态变量名使用。并且是项目或程序一启动运行到该类时就直接常驻内存。不需要初始化类再调用该变量。用关键字 static 声明。静态方法也是同样，可以直接调用。
实例变量：相当于该类的属性，需要初始化这个类后才可以调用。如果这个类未被再次使用，垃圾回收器回收后这个实例也将不存在了，下次再使用时还需要初始化这个类才可以再次调用。
1）存储区域不同：静态变量存储在方法区属于类所有，实例变量存储在堆当中；
2）静态变量与类相关，普通变量则与实例相关；
3）内存分配方式不同。
判断其他对象是否 “等于” 此对象。
表示返回对象的字符串。通常，ToString 方法返回一个 “以文本方式表示” 此对象的字符串。结果应该是一个简洁但信息丰富的表达，很容易让人阅读。建议所有子类都重写此方法。
表示当前线程进入等待状态。
唤醒在该对象上等待的某个线程。
唤醒在该对象上等待的所有线程。
返回对象的哈希代码值。用于哈希查找，可以减少在查找中使用 equals 的次数，重写 equals 方法一般都要重写 hashCode 方法。这个方法在一些具有哈希功能的 Collection 中用到。
假设 a 和 b 都是对象
a==b 是比较两个对象内存地址，当 a 和 b 指向的是堆中的同一个对象才会返回 true。
多数情况下需要重写这个方法，如 String 类重写 equals () 用于比较两个不同对象，但是包含的字母相同的比较：
hashCode () 方法是为对象产生整型的 hash 值，用作对象的唯一标识。
将对象放入到集合中时，首先要判断放入对象的 hashcode 是否已经存在，不存在则直接放入集合。
如果 hashcode 相等，然后通过 equal () 方法判断要放入对象与集合中的其他对象是否相等，使用 equal () 判断不相等，则直接将该元素放入集合中，反之不放入集合中。 hashcode () 中可以使用随机数字吗？
逻辑运算符具有短路特性，而 & 不具备短路特性。
来看一下代码执行结果：
上述代码执行时抛出空指针异常，若果 & 替换成 &&，则输出日志是 error。 一个 .java 类文件中可以有多少个非内部类？
一个.java 类文件中只能出现一个 public 公共类，但是可以有多个 default 修饰的类。如果存在两个 public 修饰的类时，会报如下错误：
Java 中如何正确退出多层嵌套循环？
lable 是跳出循环标签。
当执行跳出循环语句时会跳出循环标签下方循环的末尾后面。
上述代码在执行过程中，当 i=2 时，执行跳出循环语句，控制台只输出 i=0 和 i=1 的结果，执行继续 for 循环后面的代码。
0
执行for后面的程序代码
2）通过在外层循环中添加标识符，比如定义布尔类型 bo = false，当 bo=true 跳出循环语句。 浅拷贝和深拷贝有什么区别？
浅拷贝是指被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。
深拷贝是指被复制对象的所有变量都含有与原来的对象相同的值，而那些引用其他对象的变量将指向被复制过的新对象，并且不再是原有的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。 Java 中 final 关键字有哪些用法？
Java 代码中被 final 修饰的类不可以被继承。
Java 代码中被 final 修饰的方法不可以被重写。
Java 代码中被 final 修饰的变量不可以被改变，如果修饰引用类型，那么表示引用类型不可变，引用类型指向的内容可变。
Java 代码中被 final 修饰的方法，JVM 会尝试将其内联，以提高运行效率。
一个是字符串字面常数，在字符串常量池中。
String 是不可变对象，每次对 String 类型进行操作都等同于产生了一个新的 String 对象，然后指向新的 String 对象。因此尽量避免对 String 进行大量拼接操作，否则会产生很多临时对象，导致 GC 开始工作，影响系统性能。
StringBuffer 是对象本身操作，而不是产生新的对象。因此在有大量拼接的情况下，建议使用 StringBuffer。
需要注意是 Java 从 JDK5 开始，在编译期间进行了优化。如果是无变量的字符串拼接时，那么在编译期间值都已经确定了的话，javac 工具会直接把它编译成一个字符常量。比如：
String str = "关注微信公众号" + "“Java精选”" + "，面试经验、专业规划、技术文章等各类精品Java文章分享！";在编译期间会直接被编译成如下：
String str = "关注微信公众号“Java精选”，面试经验、专业规划、技术文章等各类精品Java文章分享！";这是由于在计算机中浮点数的表示是误差的。所以一般情况下不进行两个浮点数是否相同的比较。而是比较两个浮点数的差点绝对值，是否小于一个很小的正数。如果条件满足，就认为这两个浮点数是相同的。
分析：3*0.1 的结果是浮点型，值是 0.00004，但是 4*0.1 结果值是 0.4。这个是二进制浮点数算法的计算原因。
+= 操作符会进行隐式自动类型转换，a+=b 隐式的将相加操作结果类型强制转换为持有结果的类型，而 a=a+b 则不会自动进行类型转换。
Java 中线程阻塞都有哪些原因？
阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），Java 提供了大量方法来支持阻塞。
| sleep () 方法允许指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到 CPU 时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep () 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止 |
| 两个方法配套使用，suspend () 使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume () 被调用，才能使得线程重新进入可执行状态。典型地，suspend () 和 resume () 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume () 使其恢复。 |
| yield () 使当前线程放弃当前已经分得的 CPU 时间，但不使当前线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield () 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程 |
| 两个方法配套使用，wait () 使得线程进入阻塞状态，它有两种形式，一种允许指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify () 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify () 被调用。 |
感谢阅读，更多的java课程学习路线,笔记,面试等架构资料，需要的同学可以私信我（资料）即可免费获取！
，一个游戏开发收藏夹~
如果图片长时间未显示，请使用Chrome内核浏览器。
