PhantomJS是什么？

PhantomJS is a headless web browser scriptable with JavaScript. It runs on Windows, macOS, Linux, and FreeBSD.（PhantomJS 是一个可编写JS脚本的无头浏览器，可以运行在macOS，Linux，FreeBSD上）。这是PhantomJS官网上的介绍，简单来说，PhantomJS是一个没有图形用户界面（GUI）的浏览器，通常通过命令行来控制。

PhantomJS能做什么？

网页自动化测试

希望自动的登陆网站并做一些操作然后检查结果是否正常

网页监控

希望定期打开页面，检查网站是否能正常加载，加载结果是否符合预期。加载速度如何等。

网络爬虫

获取页面中使用js来下载和渲染信息，或者是获取链接处使用js来跳转后的真实地址。

网页截屏

可以打开一个网页并生成一个网页的截屏。

Guava简介

Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库，例如：集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency libraries] 、通用注解 [common annotations] 、字符串处理 [string processing] 、I/O 等等。其中EventBus是Guava中的事件处理机制，它是设计模式中观察者模式的优雅实现。对于事件监听和发布订阅模式，EventBus是一个非常优雅的解决方案，我们不用创建复杂的类和接口层次结构。

EventBus用法

我们使用Guava之后，如果要订阅消息，只需要在监听者对应的方法加上Subscribe注解。

监听者1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class EventListener {
    @Subscribe
    // 该注解表示该方法是线程安全的，可以被多个线程同时调用（不加该注解表示该方法同时只能被一个线程调用，同步开销比较大，如果该方法已经是线程安全的，那么建议加上该注解，减少同步开销），必须和Subscribe注解搭配使用
    @AllowConcurrentEvents
    public void onEvent(String obj) {
        System.out.println("obj = " + obj);
    }

    @Subscribe
    // 该注解表示该方法是线程安全的，可以被多个线程同时调用（不加该注解表示该方法同时只能被一个线程调用，同步开销比较大，如果该方法已经是线程安全的，那么建议加上该注解，减少同步开销），必须和Subscribe注解搭配使用
    @AllowConcurrentEvents
    public void onEvent(Long obj) {
        System.out.println("obj = " + obj);
    }
}

监听者2

1
2
3
4
5
6

public class EventListener2 {
    @Subscribe
    public void onEvent(Object obj) {
        System.out.println("obj2 = " + obj);
    }
}

众所周知，在Java中不需要程序员去主动管理内存，由JVM去负责内存的回收和分配。这样一来简化了程序员的工作，但是呢这也带来一个问题，就是不够灵活，垃圾回收对于程序员来说是不可控的。

在JDK1.2以前，如果一个对象不被任何变量引用，则程序无法再次使用这个对象，这个对象最终会被GC（GabageCollection：垃圾回收）。但是如果之后可能还会用到这个对象，就只能去新建一个了，这其实就降低了JVM性能，没有达到最大的优化策略。

因此，从JDK1.2开始，提供了四种类型的引用：强引用（StrongReference）、软引用（SoftReference）、弱引用（WeakReference）和虚引用（PhantomReference）。主要有两个目的：

1. 可以在代码中决定某些对象的生命周期；
2. 优化JVM的垃圾回收机制。

Excel大数据导入导出

在Java中我们导入导出Excel一般使用的是Apache POI，很多开源工具也都是基于POI的。但是POI的使用不当可能会造成线上问题，比如数据量大的时候会造成Full GC或者OOM。

从上图中可以看到POI相关的对象以及相关的XML对象占用了大量的内存空间，而且造成了频繁的

Full GC，但是却一直没有被回收。原因是导出的数据比较大，在导出结束前内存中有大量的Row，Cell，Style等没有被释放。

Excel存储格式

XLS

03版的XLS采用的是一种名为BIFF8(Binary-Interchange-File-Format)，基于OLE2规范的二进制文件格式。大家也没必要去了解它，已经被淘汰了。

XLSX

07版的XLSX则是采用OOXML(Office Open Xml)的格式存储数据。简单来说就是一堆xml文件用zip打包之后文件。这个对于大家来说就熟悉了，把xlsx文件后缀名改为zip后，再解压出来就可以看到文件结构。

Eclipse Memory Analyzer是一个快速且功能丰富的Java堆分析器，可帮助您查找内存泄漏并减少内存消耗。使用Memory Analyzer分析具有数亿个对象的高效堆转储，快速计算对象的保留大小，查看谁阻止垃圾收集器收集对象，运行报告以自动提取泄漏嫌疑者。下面来介绍下MAT工具如何使用。

获取Heap Dump文件

• 通过OOM获取，即在OutOfMemoryError后获取一份HPROF二进制Heap Dump文件，可以在jvm里添加参数：

  -XX:+HeapDumpOnOutOfMemoryError

• 主动获取，即在虚拟机添加参数如下，然后在Ctrl+Break组合键即可获取一份Heap Dump

  -XX:+HeapDumpOnCtrlBreak

• 使用HPROF agent

  使用Agent可以在程序执行结束时或受到SIGOUT信号时生成Dump文件。配置在虚拟机的参数如下：

  -agentlib:hprof=heap=dump,format=b

• jmap 可以在cmd里执行，命令如下：

  jmap -dump:format=b,file=<文件名XX.hprof> <pid>

• 使用JConsole

• 使用Memory Analyzer Tools的File —> Acquire Heap Dump功能

  

在使用MAT工具分析JVM内存占用情况的时候，我们经常会遇到两个出现频率很高的名词 Shallow Size 和 Retained Size。

这两个名词代表的是对象所占用的内存大小（JAVA对象大小=对象头+实例数据+对齐填充）。

下面是Mat文档里对Shallow Size 和 Retained Size的解释：

Shallow heap is the amount of memory consumed by one object. An Object requires 32 (or 64 bits, depending on the architecture) for each reference. Primitives such as integers and longs require 4 or 8 bytes, etc… While this can be interesting, the more useful metric is the Retained Heap.

The retained heap shows the sum of the shallow heap size of all objects that would be removed when this object is garbage collected. For example, if an ArrayList held 100,000 items, and each item required 16 bytes, then removing the ArrayList would free 16 x 100,000 + X, where X is the shallow size of the ArrayList. (Note: this assumes that these objects are only being referenced by the ArrayList, and not elsewhere).

The retained heap is computed by adding the size all the objects in the retained set. A retained set of X is the set of objects which would be removed by the GC when X is collected.

The retained heap can be calculated in two different ways, using the quick approximation or the precise retained size.

Shallow Size

非数组类型的对象的Shallow Size

shallow_size=对象头+各成员变量大小之和+对齐填充

这里的各成员变量大小之和就是实例数据，如果存在继承情况，当然要包含父类的成员变量。

注：记住不包含所引用的对象本身的大小。

数组类型对象的Shallow Size

shallow_size=对象头+类型变量大小*数组长度+对齐填充，其中如果类型是引用类型则是4字节或8字节（64位系统）,如果是boolean类型则是1字节，以此类推。

注：这里的类型变量大小*数组长度就是实例数据，强调是变量不是对象本身。

Redis的线程模型

Redis 基于 Reactor 模式来设计开发了自己的一套高效的事件处理模型 （Netty 的线程模型也基于 Reactor 模式，Reactor 模式不愧是高性能 IO 的基石），这套事件处理模型对应的是 Redis 中的文件事件处理器（file event handler）。由于文件事件处理器（file event handler）是单线程方式运行的，所以我们一般都说 Redis 是单线程模型。

Redis既然是单线程的，那么它是如何监听大量的客户端请求的呢？

Redis通过 IO多路复用程序来监听来自客户端的大量连接（socket套接字），它会将感兴趣的事件及类型（读、写）注册到内核中并监听每个事件是否发生。

这样的好处非常明显： I/O 多路复用技术的使用让 Redis 不需要额外创建多余的线程来监听客户端的大量连接，降低了资源的消耗（和 NIO 中的 Selector 组件很像）。

另外， Redis 服务器是一个事件驱动程序，服务器需要处理两类事件： 1. 文件事件; 2. 时间事件。

时间事件不需要多花时间了解，我们接触最多的还是 文件事件（客户端进行读取写入等操作，涉及一系列网络通信）。

Redis 基于 Reactor 模式开发了自己的网络事件处理器：这个处理器被称为文件事件处理器（file event handler）。文件事件处理器使用 I/O 多路复用（multiplexing）程序来同时监听多个套接字，并根据 套接字目前执行的任务来为套接字关联不同的事件处理器。

当被监听的套接字准备好执行连接应答（accept）、读取（read）、写入（write）、关 闭（close）等操作时，与操作相对应的文件事件就会产生，这时文件事件处理器就会调用套接字之前关联好的事件处理器（连接应答处理器、命令请求处理器、命令回复处理器）来处理这些事件。

虽然文件事件处理器以单线程方式运行，但通过使用 I/O 多路复用程序来监听多个套接字，文件事件处理器既实现了高性能的网络通信模型，又可以很好地与 Redis 服务器中其他同样以单线程方式运行的模块进行对接，这保持了 Redis 内部单线程设计的简单性。

以上的说法并不意味着redis只能以单线程的方式运行，在redis4.0之后的版本就已经加入了对多线程的支持（仅限于对大键值的删除操作，Redis6.0引入了多线程主要是为了提高IO读写能力，执行命令这种还是单线程顺序执行，默认Redis6.0是禁用多线程的。）。

Class文件常量池

Class文件中除了有类的版本、方法、字段等描述信息以外，还有一项信息是常量池，用于存放编译期生成的字面量和符号引用。这部分内容将在类加载以后存放在运行时常量池中。

字面量

字面量包括字符串和被final修饰的变量。下面几张图是Class常量池里的字面量（通过jclasslib查看，也可以通过javap -v XXX.class查看字节码信息）

什么是代理

代理是为其它对象提供一种代理以控制这个对象的访问，Java中的代理分为下面三种角色：

1. Subject（抽象角色）： 通过接口或抽象类声明真实角色实现的业务方法。

2. RealSubject（目标角色）： 实现抽象角色，定义目标角色所要实现的业务逻辑，供代理角色调用。

3. Proxy（代理角色）： 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

代理模式根据生成代理类时机的不同分为两种，分为静态代理和动态代理，静态代理在编译期就已经生成代理类，动态代理是在程序运行的时候动态生成代理类。

静态代理

静态代理要求委托类（RealSubject）和代理角色（Proxy）必须实现同一个接口或者继承同一个父类，否则无法生成代理类。

抽象角色

1
2
3

public interface Action {
    void doSomething();
}

目标角色

1
2
3
4
5
6

public class RealObject implements Action {
    @Override
    public void doSomething() {
        System.out.println("do something");
    }
}

代理角色

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class ProxyObject implements Action {
    private Action realObject;

    public ProxyObject(Action realObject) {
        this.realObject = realObject;
    }

    @Override
    public void doSomething() {
        // 自定义代理类的逻辑
        System.out.println("proxy do");
        // 调用被代理类的方法
        realObject.doSomething();
    }
}

测试类

1
2
3
4
5
6
7
8
9
10
11

public class StaticProxyTest {
    public static void main(String[] args) {
        // 被代理对象
        Action realObject = new RealObject();
        // 代理对象
        Action proxyObject = new ProxyObject(realObject);

        proxyObject.doSomething();

    }
}

运行结果

1
2

proxy do
do something

类加载机制

虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。需要注意的是，在Java语言里面，类型的加载、连接和初始化都是在程序运行期间完成的，这种策略虽然会导致类加载时稍微增加一些性能开销，但是给Java应用程序提供了高度的灵活性，比如说编写一个面向接口的应用程序，可以等到运行时再指定其实际的实现类。

类加载的时机

类从被加载到虚拟机内存中开始，到卸载处内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用、卸载这个七个阶段，其中验证、准备、解析属于连接阶段。

其中，加载、验证、准备、解析、初始化和卸载这5个阶段顺序是确定的，类的加载过程必须按照这种顺序按部就班的进行，但是解析阶段却不一定。在某些情况下，解析可以在初始化之后再开始，这是为了支持Java语言的运行时绑定。这里需要注意的是，这些阶段通常都是互相交叉的混合式进行的，通常会在一个阶段的执行的过程中调用、激活另外一个阶段。

上面说了那么多，什么时候会开始类加载的第一个阶段：加载呢？Java虚拟机规范中并没有强制约束这一点，这一点虚拟机可以自由实现。但是对于初始化阶段，虚拟机规范则是严格规定了有且仅有5中情况必须立即对类进行初始化（加载、验证、准备自然需要在此之前开始）。

1. 遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，如果类没有进行过初始化，则需要先初始化。比如说使用new关键字实例化对象的时候，读取或设置一个类的静态变量（被final修饰、已在编译期把结果放入常量池的静态字段除外），以及调用类的静态方法的时候。

2. 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，那么先要对类进行初始化。

3. 当初始化一个类的时候，如果发现其父类没有进行初始化，那么要先初始化父类。

   1	接口的初始化这里和类的初始化有点区别：接口在初始化的时候，并不要求父接口全部完成了初始化，只有在真正使用到父接口的时候（比如引用接口中定义的常量）才会初始化。

4. 当虚拟机启动时，用户需要指定一个主类（包含main()方法的那个类），虚拟机会先初始化这个主类。

5. 当使用JDK1.7的动态语言支持的时候，如果一个java.lang.invoke.MethodHandle实例最后的解析结果是REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄、并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。