Mysql动态生成sql

### 主要涉及知识点:
JVM JDK 和 JRE 最详细通俗的解答
Oracle JDK 和 OpenJDK 的对比
Java 和 C++的区别?
什么是 Java 程序的主类 应用程序和小程序的主类有何不同?
Java 应用程序与小程序之间有哪些差别?
import java 和 javax 有什么区别？
为什么说 Java 语言“编译与解释并存”？

#### 1.Java 虚拟机（JVM）

是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。

**什么是字节码?采用字节码的好处是什么?**

> 在 Java 中，JVM 可以理解的代码就叫做`字节码`（即扩展名为 `.class` 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效，而且，由于字节码并不针对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。

**Java 程序从源代码到运行一般有下面 3 步：**

![pic1](https://user-images.githubusercontent.com/29878636/85967217-899abe00-b9f4-11ea-8322-25b314600864.png)





我们需要格外注意的是 .class->机器码 这一步。在这一步 JVM 类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢。而且，有些方法和代码块是经常需要被调用的(也就是所谓的热点代码)，所以后面引进了 JIT 编译器，而 JIT 属于运行时编译。当 JIT 编译器完成第一次编译后，其会将字节码对应的机器码保存下来，下次可以直接使用。而我们知道，机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语言。

> HotSpot 采用了惰性评估(Lazy Evaluation)的做法，根据二八定律，消耗大部分系统资源的只有那一小部分的代码（热点代码），而这也就是 JIT 所需要编译的部分。JVM 会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。JDK 9 引入了一种新的编译模式 AOT(Ahead of Time Compilation)，它是直接将字节码编译成机器码，这样就避免了 JIT 预热等各方面的开销。JDK 支持分层编译和 AOT 协作使用。但是 ，AOT 编译器的编译质量是肯定比不上 JIT 编译器的。

**总结：**

Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。

#### 2.JDK 和 JRE

JDK 是 Java Development Kit，它是功能齐全的 Java SDK。它拥有 JRE 所拥有的一切，还有编译器（javac）和工具（如 javadoc 和 jdb）。它能够创建和编译程序。

JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有内容的集合，包括 Java 虚拟机（JVM），Java 类库，java 命令和其他的一些基础构件。但是，它不能用于创建新程序。

如果你只是为了运行一下 Java 程序的话，那么你只需要安装 JRE 就可以了。如果你需要进行一些 Java 编程方面的工作，那么你就需要安装 JDK 了。但是，这不是绝对的。有时，即使您不打算在计算机上进行任何 Java 开发，仍然需要安装 JDK。例如，如果要使用 JSP 部署 Web 应用程序，那么从技术上讲，您只是在应用程序服务器中运行 Java 程序。那你为什么需要 JDK 呢？因为应用程序服务器会将 JSP 转换为 Java servlet，并且需要使用 JDK 来编译 servlet。

#### 3. Oracle JDK 和 OpenJDK 的对比

可能在看这个问题之前很多人和我一样并没有接触和使用过 OpenJDK 。那么 Oracle 和 OpenJDK 之间是否存在重大差异？下面我通过收集到的一些资料，为你解答这个被很多人忽视的问题。

对于 Java 7，没什么关键的地方。OpenJDK 项目主要基于 Sun 捐赠的 HotSpot 源代码。此外，OpenJDK 被选为 Java 7 的参考实现，由 Oracle 工程师维护。关于 JVM，JDK，JRE 和 OpenJDK 之间的区别，Oracle 博客帖子在 2012 年有一个更详细的答案：

> 问：OpenJDK 存储库中的源代码与用于构建 Oracle JDK 的代码之间有什么区别？
>
> 答：非常接近 - 我们的 Oracle JDK 版本构建过程基于 OpenJDK 7 构建，只添加了几个部分，例如部署代码，其中包括 Oracle 的 Java 插件和 Java WebStart 的实现，以及一些封闭的源代码派对组件，如图形光栅化器，一些开源的第三方组件，如 Rhino，以及一些零碎的东西，如附加文档或第三方字体。展望未来，我们的目的是开源 Oracle JDK 的所有部分，除了我们考虑商业功能的部分。

**总结：**

1. Oracle JDK 大概每 6 个月发一次主要版本，而 OpenJDK 版本大概每三个月发布一次。但这不是固定的，我觉得了解这个没啥用处。详情参见：https://blogs.oracle.com/java-platform-group/update-and-faq-on-the-java-se-release-cadence 。
2. OpenJDK 是一个参考模型并且是完全开源的，而 Oracle JDK 是 OpenJDK 的一个实现，并不是完全开源的；
3. Oracle JDK 比 OpenJDK 更稳定。OpenJDK 和 Oracle JDK 的代码几乎相同，但 Oracle JDK 有更多的类和一些错误修复。因此，如果您想开发企业/商业软件，我建议您选择 Oracle JDK，因为它经过了彻底的测试和稳定。某些情况下，有些人提到在使用 OpenJDK 可能会遇到了许多应用程序崩溃的问题，但是，只需切换到 Oracle JDK 就可以解决问题；
4. 在响应性和 JVM 性能方面，Oracle JDK 与 OpenJDK 相比提供了更好的性能；
5. Oracle JDK 不会为即将发布的版本提供长期支持，用户每次都必须通过更新到最新版本获得支持来获取最新版本；
6. Oracle JDK 根据二进制代码许可协议获得许可，而 OpenJDK 根据 GPL v2 许可获得许可。

#### 4.Java 和 C++的区别?

我知道很多人没学过 C++，但是面试官就是没事喜欢拿咱们 Java 和 C++ 比呀！没办法！！！就算没学过 C++，也要记下来！

- 都是面向对象的语言，都支持封装、继承和多态
- Java 不提供指针来直接访问内存，程序内存更加安全
- Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
- Java 有自动内存管理机制，不需要程序员手动释放无用内存
- **在 C 语言中，字符串或字符数组最后都会有一个额外的字符‘\0’来表示结束。但是，Java 语言中没有结束符这一概念。** 这是一个值得深度思考的问题，具体原因推荐看这篇文章： https://blog.csdn.net/sszgg2006/article/details/49148189

#### 5. 什么是 Java 程序的主类 应用程序和小程序的主类有何不同?

一个程序中可以有多个类，但只能有一个类是主类。在 Java 应用程序中，这个主类是指包含 main（）方法的类。而在 Java 小程序中，这个主类是一个继承自系统类 JApplet 或 Applet 的子类。应用程序的主类不一定要求是 public 类，但小程序的主类要求必须是 public 类。主类是 Java 程序执行的入口点。


#### 6.Java 应用程序与小程序之间有哪些差别?

简单说应用程序是从主线程启动(也就是 `main()` 方法)。applet 小程序没有 `main()` 方法，主要是嵌在浏览器页面上运行(调用`init()`或者`run()`来启动)，嵌入浏览器这点跟 flash 的小游戏类似。

#### 7. import java 和 javax 有什么区别？

刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来使用。然而随着时间的推移，javax 逐渐地扩展成为 Java API 的组成部分。但是，将扩展从 javax 包移动到 java 包确实太麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准 API 的一部分。所以，实际上 java 和 javax 没有区别。这都是一个名字。



#### 8. 为什么说 Java 语言“编译与解释并存”？

高级编程语言按照程序的执行方式分为编译型和解释型两种。简单来说，编译型语言是指编译器针对特定的操作系统将源代码一次性翻译成可被该平台执行的机器码；解释型语言是指解释器对源程序逐行解释成特定平台的机器码并立即执行。比如，你想阅读一本英文名著，你可以找一个英文翻译人员帮助你阅读， 有两种选择方式，你可以先等翻译人员将全本的英文名著（也就是源码）都翻译成汉语，再去阅读，也可以让翻译人员翻译一段，你在旁边阅读一段，慢慢把书读完。

Java 语言既具有编译型语言的特征，也具有解释型语言的特征，因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（*.class 文件），这种字节码必须由 Java 解释器来解释执行。因此，我们可以认为 Java 语言编译与解释并存。

**Gtihub** 地址: github.com/liangtengyu

Java 基本功 (基础概念与常识） 

springboot自动配置:

理解3个问题:

1.达到什么条件
2.创建什么bean
3.创建的bean配置是什么

> 以EmbeddedWebServerFactoryCustomizerAutoConfiguration为例子

```java
@Configuration(proxyBeanMethods = false)  
@ConditionalOnWebApplication    				//此处满足条件1  达到什么条件
@EnableConfigurationProperties(ServerProperties.class)   // 此处满足条件3 创建bean的配置是什么
public class EmbeddedWebServerFactoryCustomizerAutoConfiguration {

	/**
	 * Nested configuration if Tomcat is being used.
	 */
	@Configuration(proxyBeanMethods = false)	//此处满足条件2 创建什么bean 
	@ConditionalOnClass({ Tomcat.class, UpgradeProtocol.class })//此处满足条件1  达到什么条件
	public static class TomcatWebServerFactoryCustomizerConfiguration {

		@Bean
		public TomcatWebServerFactoryCustomizer tomcatWebServerFactoryCustomizer(Environment environment,
				ServerProperties serverProperties) {
			return new TomcatWebServerFactoryCustomizer(environment, serverProperties);
		}

	}
```

> 简单的例子
> 无条件创建一个bean 只要满足问题2和3
>
> 2.创建什么bean
> 3.创建的bean配置是什么

```java
@Configuration  //创建什么bean 
public class DemoConfiguration {

    @Bean  //创建的bean的配置是什么
    public void object() {
        return new Obejct();
    }

}
```

如此得出结论  

> 1 `@ConditionOnClass`注解的类要满足条件才会创建bean  ,可以解决需要什么条件的问题, 当然也可以不设置条件
> 2 `@Configuration` 注解的类,可以解决创建什么bean的问题

那最后一个问题呢 其实在serverProperties中, 看代码:

```java
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {

	/**
	 * Server HTTP port.
	 */
	private Integer port;

	/**
	 * Network address to which the server should bind.
	 */
	private InetAddress address;
  
  //..........省略
```

>3 ` @ConfigurationProperties` 注解的类,可以解决**创建的 Bean 的属性？**问题

目前:

我们已经比较清晰的理解 Spring Boot 是怎么解决我们上面提出的三个问题，但是这样还是无法实现自动配置。例如说，我们引入的 `spring-boot-starter-web` 等依赖，Spring Boot 是怎么知道要扫码哪些配置类的。

springboot自动配置原理1基础



## 1.并发和并行

### 举个例子

并发(concurrency):并发的关键在于有处理多个任务的能力,但并不一定就是同时处理.

> 例1:  吃饭时,电话响起,暂时停下吃饭的动作,接完电话后继续吃饭.
>
> 例2:  一个人吃3个馒头

并行(parallelism):并行的关键在于同时处理多个任务

> 例子1: 吃饭时,电话响起,同时进行吃饭和电话2个动作
>
> 例子2: 三个人吃3个馒头

### “并发”指的是程序的结构，“并行”指的是程序运行时的状态

即使不看详细解释，也请记住这句话.

### 并行（parallelism）

这个概念很好理解。所谓并行，就是**同时执行**的意思，无需过度解读。判断程序是否处于并行的**状态**，就看同一时刻是否有超过一个“工作单位”在运行就好了。所以，**单线程永远无法达到并行状态**。

要达到并行状态，最简单的就是利用`多线程`和`多进程`。

注意: Python 的多线程由于存在著名的 GIL(`通俗理解为就是一把全局排他锁`)，无法让两个线程真正“同时运行”，所以实际上是无法到达并行状态的。

### 并发（concurrency）

要理解“并发”这个概念，必须得清楚，**并发指的是程序的“结构”**。当我们说这个程序是并发的，实际上，这句话应当表述成“这个程序采用了支持并发的设计”。好，既然并发指的是人为设计的结构，那么怎样的程序结构才叫做支持并发的设计？

正确的并发设计的标准是：**两个任务可以在重叠的时间段内启动、运行和完成(two tasks can start, run, and complete in overlapping time periods)**。

### 并发 并行 区分的关键:

是否是同时处理多个任务



## 2.同步和异步

- 所谓同步，就是在发出一个调用时，在没有得到结果之前，该调用就不返回。但是一旦调用返回，就得到返回值了。
- 异步则是相反，调用在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在调用发出后，被调用者通过状态、通知来通知调用者，或通过回调函数处理这个调用。

### 区分的关键

同步和异步关注的是**消息通信机制** (synchronous communication/ asynchronous communication)



## 3.阻塞与非阻塞

- 阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
- 非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。

### 区分的关键

阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的**状态**.





> “阻塞”与"非阻塞"  与  "同步"与“异步"不能简单的从字面理解
> 前者关注的是等待结果时的状态,后者关注的是通信机制

JAVA并发基础概念

# Java中的OutOfMemoryError的各种情况及解决和JVM内存结构

在JVM中内存一共有3种：Heap（堆内存），Non-Heap（非堆内存） 和Native（本地内存）。

堆内存是运行时分配所有类实例和数组的一块内存区域。非堆内存包含方法区和JVM内部处理或优化所需的内存，存放有类结构（如运行时常量池、字段及方法结构，以及方法和构造函数代码）。本地内存是由操作系统管理的虚拟内存。当一个应用内存不足时就会抛出java.lang.OutOfMemoryError 异常。 

<table><tbody><tr><td>问题</td><td>表象</td><td>诊断工具</td></tr><tr><td>内存不足</td><td><tt>OutOfMemoryError</tt></td><td><tt>Java Heap Analysis Tool(jhat)</tt>&nbsp;[4] <tt>Eclipse Memory Analyzer(mat)</tt>&nbsp;[5]</td></tr><tr><td>内存泄漏</td><td>使用内存增长，频繁GC</td><td><tt>Java Monitoring and Management Console(jconsole)</tt>&nbsp;[6] <tt>JVM Statistical Monitoring Tool(jstat)</tt>&nbsp;[7]</td></tr><tr><td>&nbsp;</td><td>一个类有大量的实例</td><td><tt>Memory Map(jmap) - "jmap -histo"</tt>&nbsp;[8]</td></tr><tr><td>&nbsp;</td><td>对象被误引用</td><td><tt>jconsole</tt>&nbsp;[6]&nbsp;或&nbsp;<tt>jmap -dump + jhat</tt>&nbsp;[8][4]</td></tr><tr><td><tt>Finalizers</tt></td><td>对象等待结束</td><td><tt>jconsole</tt>&nbsp;[6]&nbsp;或&nbsp;<tt>jmap -dump + jhat</tt>&nbsp;[8][4]</td></tr></tbody></table>

OutOfMemoryError在开发过程中是司空见惯的，遇到这个错误，新手程序员都知道从两个方面入手来解决：一是排查程序是否有BUG导致内存泄漏；二是调整JVM启动参数增大内存。OutOfMemoryError有好几种情况，每次遇到这个错误时，观察OutOfMemoryError后面的提示信息，就可以发现不同之处，如：

java.lang.OutOfMemoryError: Java heap space 
java.lang.OutOfMemoryError: unable to create new native thread 
java.lang.OutOfMemoryError: PermGen space 
java.lang.OutOfMemoryError: Requested array size exceeds VM limit

虽然都叫OutOfMemoryError，但每种错误背后的成因是不一样的，解决方法也要视情况而定，不能一概而论。只有深入了解JVM的内存结构并仔细分析错误信息，才有可能做到对症下药，手到病除。

#### JVM规范

JVM规范对Java运行时的内存划定了几块区域 ，有：JVM栈（Java Virtual Machine Stacks）、堆（Heap）、方法区（Method Area）、常量池（Runtime Constant Pool）、本地方法栈（Native Method Stacks），但对各块区域的内存布局和地址空间却没有明确规定，而留给各JVM厂商发挥的空间。

#### HotSpot JVM

Sun自家的HotSpot JVM实现对堆内存结构有相对明确的说明。按照HotSpot JVM的实现，堆内存分为3个代：Young Generation、Old(Tenured) Generation、Permanent Generation。众所周知，GC（垃圾收集）就是发生在堆内存这三个代上面的。Young用于分配新的Java对象，其又被分为三个部分：Eden Space和两块Survivor Space(称为From和To)，Old用于存放在GC过程中从Young Gen中存活下来的对象，Permanent用于存放JVM加载的class等元数据。详情参见[HotSpot内存管理白皮书](http://www.oracle.com/technetwork/java/javase/memorymanagement-whitepaper-150215.pdf)。堆的布局图示如下： 
![](http://liuchangit.com/wp-content/uploads/2011/05/heap.png)

 ![](https://images2015.cnblogs.com/blog/285763/201510/285763-20151022173351442-1909134869.png)

根据这些信息，我们可以推导出JVM规范的内存分区和HotSpot实现中内存区域的对应关系：JVM规范的Heap对应到Young和Old Generation，方法区和常量池对应到Permanent Generation。对于Stack内存，HotSpot实现也没有详细说明，但[HotSpot白皮书](http://www.oracle.com/technetwork/java/whitepaper-135217.html)上提到，Java线程栈是用宿主操作系统的栈和线程模型来表示的，Java方法和native方法共享相同的栈。因此，可以认为在HotSpot中，JVM栈和本地方法栈是一回事。

#### 操作系统

由于一个JVM进程首先是一个操作系统进程，因此会遵循操作系统进程地址空间的规定。32位系统的地址空间为4G，即最多表示4GB的虚拟内存。在Linux系统中，高地址的1G空间（即0xC0000000~0xFFFFFFFF）被系统内核占用，低地址的3G空间（即0×00000000~0xBFFFFFFF）为用户程序所使用（显然JVM进程运行在这3G的地址空间中）。这3G的地址空间从低到高又分为多个段；**Text**段用于存放程序二进制代码；**Data**段用于存放编译时已初始化的静态变量；**BSS**段用于存放未初始化的静态变量；**Heap**即堆，用于动态内存分配的数据结构，C语言的malloc函数申请的内存即是从此处分配的，Java的new实例化的对象也是自此分配。不同于前面三个段，Heap空间是可变的，其上界由低地址向高地址增长。**内存映射区**，加载的动态链接库位于这个区中；**Stack**即栈空间，线程的执行即是占用栈内存，栈空间也是可变的，但它是通过下界从高地址向低地址移动而增长的。 图示如下： 
![](https://images2015.cnblogs.com/blog/285763/201510/285763-20151022173540052-148760824.png)

JVM本身是由native code所编写的，所以JVM进程同样具有Text/Data/BSS/Heap/MemoryMapping/Stack等内存段。而Java语言的Heap应当是建立在操作系统进程的Heap之上的，Java语言的Stack应该也是建立操作系统进程Stack之上的。 综合HotSpot的内存区域和操作系统进程的地址空间，可以大致得到下列图示： 
![](https://images2015.cnblogs.com/blog/285763/201510/285763-20151022173640864-3375078.png)

Java线程的内存是位于JVM或操作系统的栈（Stack）空间中，不同于对象——是位于堆（Heap）中。这是很多新手程序员容易误解的地方。注意，“Java线程的内存”这个用词不是指Java.lang.Thread对象的内存，**java.lang.Thread对象本身是在Heap中分配的，当调用start()方法之后，JVM会创建一个执行单元，最终会创建一个操作系统的native thread来执行，而这个执行单元或native thread是使用Stack内存空间的**。

经过上述铺垫，可以得知，JVM进程的内存大致分为Heap空间和Stack空间两部分。Heap又分为Young、Old、Permanent三个代。Stack分为Java方法栈和native方法栈（不做区分），在Stack内存区中，可以创建多个线程栈，每个线程栈占据Stack区中一小部分内存，线程栈是一个LIFO数据结构，每调用一个方法，会在栈顶创建一个Frame，方法返回时，相应的Frame会从栈顶移除（通过移动栈顶指针）。在这每一部分内存中，都有可能会出现溢出错误。回到开头的OutOfMemoryError，下面逐个说明错误原因和解决方法（每个OutOfMemoryError都有可能是程序BUG导致，因此解决方法不包括对BUG的排查）。

**OutOfMemoryError**
--------------------

**1.java.lang.OutOfMemoryError: Java heap space** 
原因：Heap内存溢出，意味着Young和Old generation的内存不够。 
解决：调整java启动参数 -Xms -Xmx 来增加Heap内存。

堆内存溢出时，首先判断当前最大内存是多少（参数：-Xmx 或 -XX:MaxHeapSize=），可以通过命令 jinfo -flag MaxHeapSize 查看运行中的JVM的配置，如果该值已经较大则应通过 mat 之类的工具查找问题，或 jmap -histo查找哪个或哪些类占用了比较多的内存。参数-verbose:gc(-XX:+PrintGC) -XX:+PrintGCDetails可以打印GC相关的一些数据。如果问题比较难排查也可以通过参数-XX:+HeapDumpOnOutOfMemoryError在OOM之前Dump内存数据再进行分析。此问题也可以通过histodiff打印多次内存histogram之前的差值，有助于查看哪些类过多被实例化，如果过多被实例化的类被定位到后可以通过btrace再跟踪。 下面代码可再现该异常： List<String> list = new ArrayList<String>(); while(true) list.add(new String("Consume more memory!"));

**2.java.lang.OutOfMemoryError: unable to create new native thread** 
原因：Stack空间不足以创建额外的线程，要么是创建的线程过多，要么是Stack空间确实小了。 
解决：由于JVM没有提供参数设置总的stack空间大小，但可以设置单个线程栈的大小；而系统的用户空间一共是3G，除了Text/Data/BSS/MemoryMapping几个段之外，Heap和Stack空间的总量有限，是此消彼长的。因此遇到这个错误，可以通过两个途径解决：1.通过-Xss启动参数减少单个线程栈大小，这样便能开更多线程（当然不能太小，太小会出现StackOverflowError）；2.通过-Xms -Xmx 两参数减少Heap大小，将内存让给Stack（前提是保证Heap空间够用）。



在JVM中每启动一个线程都会分配一块本地内存，用于存放线程的调用栈，该空间仅在线程结束时释放。当没有足够本地内存创建线程时就会出现该错误。通过以下代码可以很容易再现该问题： \[2\] while(true){ new Thread(new Runnable(){ public void run() { try {
 Thread.sleep(60\*60\*1000);
 } catch(InterruptedException e) { } 
 } 
 }).start();
}

 

**3.java.lang.OutOfMemoryError: PermGen space** 
原因：Permanent Generation空间不足，不能加载额外的类。 
解决：调整-XX:PermSize= -XX:MaxPermSize= 两个参数来增大PermGen内存。一般情况下，这两个参数不要手动设置，只要设置-Xmx足够大即可，JVM会自行选择合适的PermGen大小。



PermGen space即永久代，是非堆内存的一个区域。主要存放的数据是类结构及调用了intern()的字符串。 List<Class<?>> classes = new ArrayList<Class<?>>(); while(true){
 MyClassLoader cl \= new MyClassLoader(); try{
 classes.add(cl.loadClass("Dummy"));
 }catch (ClassNotFoundException e) {
 e.printStackTrace();
 }
}
类加载的日志可以通过btrace跟踪类的加载情况： import com.sun.btrace.annotations.\*; import static com.sun.btrace.BTraceUtils.\*;

@BTrace public class ClassLoaderDefine {

 @SuppressWarnings("rawtypes")
 @OnMethod(clazz \= "+java.lang.ClassLoader", method = "defineClass", location = @Location(Kind.RETURN)) public static void onClassLoaderDefine(@Return Class cl) {
 println("=== java.lang.ClassLoader#defineClass ===");
 println(Strings.strcat("Loaded class: ", Reflective.name(cl)));
 jstack(10);
 }

}
除了btrace也可以打开日志加载的参数来查看加载了哪些类，可以把参数\-XX:+TraceClassLoading打开，或使用参数-verbose:class（-XX:+TraceClassLoading, -XX:+TraceClassUnloading），在日志输出中即可看到哪些类被加载到Java虚拟机中。该参数也可以通过jflag的命令java -jar jflagall.jar -flag +ClassVerbose动态打开-verbose:class。

下面是一个使用了

String.intern()的例子： 

List<String\> list = new ArrayList<String\>(); 
int i=0; 
while(true) list.add(("Consume more memory!"+(i++)).intern());

你可以通过以下btrace脚本查找该类调用：

import com.sun.btrace.annotations.\*; 
import static com.sun.btrace.BTraceUtils.\*;

@BTrace 
public class StringInternTrace {

    @OnMethod(clazz \= "/.\*/", method \= "/.\*/", location \= @Location(value \= Kind.CALL, clazz \= "java.lang.String", method \= "intern")) public static void m(@ProbeClassName String pcm, @ProbeMethodName String probeMethod, @TargetInstance Object instance) { println(strcat(pcm, strcat("#", probeMethod))); println(strcat(">>>> ", str(instance))); } 
}



**4.java.lang.OutOfMemoryError: Requested array size exceeds VM limit** 
原因：这个错误比较少见（试着new一个长度1亿的数组看看），同样是由于Heap空间不足。如果需要new一个如此之大的数组，程序逻辑多半是不合理的。 
解决：修改程序逻辑吧。或者也可以通过-Xmx来增大堆内存。

详细信息表示应用申请的数组大小已经超过堆大小。如应用程序申请512M大小的数组，但堆大小只有256M，这里会抛出OutOfMemoryError，因为此时无法突破虚拟机限制分配新的数组。在大多少情况下是堆内存分配的过小，或是应用尝试分配一个超大的数组，如应用使用的算法计算了错误的大小。

**5.在GC花费了大量时间，却仅回收了少量内存时，也会报出OutOfMemoryError**，我只遇到过一两次。当使用-XX:+UseParallelGC或-XX:+UseConcMarkSweepGC收集器时，在上述情况下会报错，在HotSpot GC Turning文档上有说明： 
The parallel(concurrent) collector will throw an OutOfMemoryError if too much time is being spent in garbage collection: if more than 98% of the total time is spent in garbage collection and less than 2% of the heap is recovered, an OutOfMemoryError will be thrown. 
对这个问题，一是需要进行GC turning，二是需要优化程序逻辑。

**6.java.lang.StackOverflowError** 
原因：这也内存溢出错误的一种，即线程栈的溢出，要么是方法调用层次过多（比如存在无限递归调用），要么是线程栈太小。 
解决：优化程序设计，减少方法调用层次；调整-Xss参数增加线程栈大小。

#### **7.java.lang.OutOfMemoryError: request <size> bytes for <reason>. Out of swap space?**

> 本地内存分配失败。一个应用的Java Native Interface(JNI)代码、本地库及Java虚拟机都从本地堆分配内存分配空间。当从本地堆分配内存失败时抛出OutOfMemoryError异常。例如：当物理内存及交换分区都用完后，再次尝试从本地分配内存时也会抛出OufOfMemoryError异常。

#### 8. **java.lang.OutOfMemoryError: <reason> <stack trace> (Native method)**

> 如果异常的详细信息是 <reason> <stack trace> (Native method) 且一个线程堆栈被打印，同时最顶端的桢是本地方法，该异常表明本地方法遇到了一个内存分配问题。与前面一种异常相比，他们的差异是内存分配失败是JNI或本地方法发现或是Java虚拟机发现。

**9.java.lang.OutOfMemoryError: Direct buffer memory**

　　即从Direct Memory分配内存失败，Direct Buffer对象不是分配在堆上，是在Direct Memory分配，且不被GC直接管理的空间（但Direct Buffer的Java对象是归GC管理的，只要GC回收了它的Java对象，操作系统才会释放Direct Buffer所申请的空间）。通过\-XX:MaxDirectMemorySize=可以设置Direct内存的大小。

List<ByteBuffer\> list \= new ArrayList<ByteBuffer\>(); 
while(true) list.add(ByteBuffer.allocateDirect(10000000));

#### 10. **java.lang.OutOfMemoryError: GC overhead limit exceeded**

JDK6新增错误类型。当GC为释放很小空间占用大量时间时抛出。一般是因为堆太小。导致异常的原因：没有足够的内存。可以通过参数\-XX:-UseGCOverheadLimit关闭这个特性。11. **java.lang.OutOfMemoryError: request <size> bytes for <reason>. Out of swap space?**

本地内存分配失败。一个应用的Java Native Interface(JNI)代码、本地库及Java虚拟机都从本地堆分配内存分配空间。当从本地堆分配内存失败时抛出OutOfMemoryError异常。例如：当物理内存及交换分区都用完后，再次尝试从本地分配内存时也会抛出OufOfMemoryError异常。

12. **java.lang.OutOfMemoryError: <reason> <stack trace> (Native method)**

如果异常的详细信息是 <reason> <stack trace> (Native method) 且一个线程堆栈被打印，同时最顶端的桢是本地方法，该异常表明本地方法遇到了一个内存分配问题。与前面一种异常相比，他们的差异是内存分配失败是JNI或本地方法发现或是Java虚拟机发现。