Java常用类库与技巧

Java异常

异常处理机制主要回答了三个问题

What：异常类型回答了什么被抛出

Where：异常堆栈跟踪回答了在哪抛出

Why：异常信息回答了为什么被抛出

Java的异常体系

Error和Exception的区别

从概念角度解析Java的异常处理机制：

1.Error：程序无法处理的系统处理，编辑器不做检查（如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢出等）

2.Exception：程序可以处理的异常，捕获后可能恢复

• RuntimeException：不可预知的，程序应当自行避免
• 非RuntimeException：可预知的，从编译器校验的异常

从责任角度看：

1.Error属于JVM需要负担的责任

2.RuntimeException是程序应该负担的责任

3.Checked Exception可检查异常是Java编译器应该负担的责任(编译时就应该捕获或者抛出的异常)

常见Error以及Exception

RuntimeException

1.NullPointerException - 空指针引用异常

2.ClassCastException - 类型强制转换异常

3.IllegalArgumentException - 传递非法参数异常

4.IndexOutOfBoundsException - 下标越界异常

5.NumberFormatException - 数字格式异常

非RuntimeException

1.ClassNotFoundException - 找不到指定class的异常

2.IOException - IO操作异常

3.SQLException - SQL异常

Error

1.NoClassDefFoundError - 找不到class定义的异常（原因：类依赖的class或者jar不存在；类文件存在，但是存在不同的域中；大小写问题，javac编译的时候是无视大小写的，很有可能编译出来的class文件就与想要的不一样）

2.StackOverflowError - 深递归导致栈被耗尽而抛出的异常

3.OutOfMemoryError - 内存溢出异常

Java的异常处理机制

• 抛出异常：创建异常对象，交由运行时系统处理
• 捕获异常：寻找合适的异常处理器处理异常，否则终止运行

private static int doSomething(){
   try {
      int i = 10/0;
      System.out.println("i= " + i);
   } catch (ArithmeticException e) {
      System.out.println("ArithmeticException: " + e);
      return 0;
   } catch (Exception e) {
      System.out.println("Exception: " + e);
      return 1;
   } finally {
      System.out.println("Finally");
      return 2;
   }
}

public static void main(String[] args) {
   System.out.println("执行后的值为：" + doSomething());
   System.out.println("执行结束");
}

执行结果

ArithmeticException: java.lang.ArithmeticException: / by zero
Finally
执行后的值为：2
执行结束

注意

尽量细化异常，别抛出异常的父类，也是为了方便定位问题

避免在finally中写return语句，其他return不会执行

Java异常的处理原则

• 具体明确：抛出的异常应能通过异常类名和message准确说明异常的类型和产生异常的原因
• 提早抛出：应尽可能早的发现并抛出异常，便于精确定位问题
• 延迟捕获：异常的捕获和处理应尽可能延迟，让掌握更多信息的作用域来处理异常

高效主流的异常处理框架

在用户看来，应用系统发生的所有异常都是应用系统内部的异常

• 设计一个通用的继承自RuntimeException的异常来统一处理
• 其余异常都统一转译为上述异常AppException
• 在catch之后，抛出上述异常的子类，并提供足以定位的信息
• 由前端接收AppException做统一处理

看看try-catch的性能问题

private static void testException(String[] array){
   try {
      System.out.println(array[0]);
   }catch (NullPointerException e){
      System.out.println("array cannot be null");
   }
}

private static void testIf(String[] array){
   if (array != null){
      System.out.println(array[0]);
   } else {
      System.out.println("array cannot be null");
   }
}

public static void main(String[] args) {
   long start = System.nanoTime();
   testException(null);
   System.out.println("testException cost " + (System.nanoTime() - start));
}

// 运行结果
array cannot be null
testException cost 322997

public static void main(String[] args) {
   long start = System.nanoTime();
   testIf(null);
   System.out.println("testIf cost " + (System.nanoTime() - start));
}

// 运行结果
array cannot be null
testIf cost 238152

Java异常处理消耗性能的地方

• try-catch块影响JVM的优化
• 异常对象实例需要保持栈快照等信息，开销较大

Java集合框架

集合之List和Set

集合之Map

HashMap、HashTable、ConcurrentHashMap

HashMap

Java8以前(不包含)：数组+链表

数组长度默认是16，数组中每个元素存储着链表的头节点，通过hash(key.hashCode())%len(哈希函数取模操作)获得添加元素所要存放的数组的位置。

有个问题，如果哈希函数计算的值一直是同一个，会导致bucket（桶）过长，链表查询，就需要从头部开始遍历，最坏的情况下，性能会从O(1)变成O(n)。

Java8以后：数组+链表+红黑树

Java8之后做了调整，会通过一个常量TREEIFY_THRESHOLD控制是否将链接转成红黑树，性能从O(n)提高到O(logn)

HashMap使用懒加载，首次使用才初始化

HashMap：put方法的逻辑

1、如果HashMap未被初始化过，则初始化

2、对Key求Hash值，然后计算下标

3、如果没有碰撞，直接放入桶中

4、如果碰撞了，以链表的方式链接到后面

5、如果链表长度超过阈值，就把链表转成红黑树

6、如果链表长度低于6，就把红黑树转回链表

7、如果节点已经存在就替换旧值

8、如果桶满了（容量16*加载因子0.75），就需要resize（扩容2倍后重排）

HashMap：如何有效减少碰撞

• 扰动函数：促使元素位置分布均匀，减少碰撞几率（两个不相等的对象返回不同的哈希值）
• 使用final对象，并采用合适的equals()和hashCode()方法

HashMap：从获取hash到散列的过程

HashMap：扩容问题

• 多线程环境下，调整大小会存在条件竞争，容易造成死锁
• rehashing是一个比较耗时的过程

Hashtable

注意点

• 多线程安全，锁住整个HashTable，力度大
• 底层：数组+链表
• 无论key还是value都不能为null

如何优化Hashtable

通过锁细粒度化，将整锁拆解成多个锁进行优化，所以出现了ConcurrentHashMap

ConcurrentHashMap

早期的ConcurrentHashMap：通过分段锁Segment来实现

数组+链表

当前的ConcurrentHashMap：CAS+synchronized使锁更细化

数组+链表+红黑树

ConcurrentHashMap：put方法的逻辑

1.判断Node[]数组是否初始化，没有则进行初始化操作

2.通过hash定位数组的索引坐标，是否有Node节点，如果没有则使用CAS进行添加（链表的头节点），添加失败则进入下次循环

3.检查到内部正在扩容，就帮助它一块扩容。

4.如果f!=null，则使用synchronized锁住f元素（链表/红黑二叉树的头元素）

4.1如果是Node（链表结构）则执行链表的添加操作

4.2如果是TreeNode（树型结构）则执行树添加操作

5.判断链表长度已经达到临界值8（默认值），当节点数超过这个值就需要把链表转换为树结构

ConcurrentHashMap总结

• 比起Segment，锁拆得更细
• 首先使用无锁操作CAS插入头节点，失败则循环重试
• 若头节点已存在，则尝试获取头节点的同步锁，再进行操作

HashMap、Hashtable、ConcurrentHashMap区别

• HashMap线程不安全，数组+链表+红黑树
• Hashtable线程安全，锁住整个对象，数组+链表
• ConcurrentHashMap线程安全，CAS+同步锁，数组+链表+红黑树
• HashMap的key、value均可为null，而其他的两个类不支持

J.U.C知识点梳理

java.util.concurrent：提供了并发编程的解决方案

• CAS是java.util.concurrent.atomic包的基础
• AQS是java.util.concurrent.locks包以及一些常用类比如Semophore，ReentrantLock等类的基础

J.U.C包的分类

• 线程执行器executor
• 锁locks
• 原子变量类atomic
• 并发工具类tools
• 并发集合collections

并发工具类

• 闭锁CountDownLatch
• 栅栏CyclicBarrier
• 信号量Semaphore
• 交换器Exchanger

CountDownLatch

让主线程等待一组事件发生后继续执行，事件指的是CountDownLatch里的countDown()方法

CyclicBarrier

阻塞当前线程，等待其他线程

• 等待其它线程，且会阻塞自己当前线程，所有线程必须同时到达栅栏位置后，才能继续执行
• 所有线程到达栅栏处，可以触发执行另外一个预先设置的线程

Semaphore

控制某个资源可被同时访问的线程个数

Exchanger

主要用于线程间的数据交换，它提供一个同步点，一个线程到达同步点就会被阻塞，直到另外一个线程进入到同步点为止，两个线程到达同步点后，相互交换数据。

BlockingQueue

提供可阻塞的入队和出队操作，如果队列满了，入队操作将阻塞，直到有空间可用，如果队列空了，出队操作将阻塞，直到有元素可用。

主要用于生产者-消费者模式，在多线程场景时生产者线程在队列尾部添加元素，而消费者线程则在队列头部消费元素，通过这种方式能够达到将任务的生产和消费进行隔离的目的

主要有以下七个队列实现，都是线程安全的

1、ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列(有界指的是容量大小有限制，先进先出)

2、LinkedBlockingQueue：一个由链表结构组成的有界/无界阻塞队列(先进先出)

3、PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列

4、DealyQueue：一个使用优先级队列实现的无界阻塞队列

5、SynchronousQueue：一个不存储元素的阻塞队列

6、LinkedTransferQueue：一个由链表结构组成的无界阻塞队列

7、LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列

Java的IO机制

BIO

Block-IO：其实是传统的java.net，java.io包下的接口或者类，比如java.net下的socket，servletSocket和http，因为网络通信都是IO行为，所以可以说是BIO的范畴，传统的IO基于字节流和字符流进行操作，比如InputStream和OutputStream，Reader和Writer。

BIO是基于流模型实现的，这意味着其交互方式是同步阻塞的，在读取输入流或者写入输出流时，在读写操作完成之前，线程会一直阻塞，它们之间的调用是可靠的线性顺序，程序发送请求给内核，然后由内核进行通讯，在内核准备好数据之前，线程是被挂起的，所以在两个阶段，程序都处于挂起状态，类比成ClientServlet模式，其实现模式为一个连接一个线程，即客户端有连接请求时，则服务端启动一个线程处理，待操作系统返回结果，如果这个连接不做任何事情，会造成不必要的线程开销，当然，我们可以通过线程池机制来改善。

特点：在IO执行的阶段，都被阻塞住了

好处：代码比较简单

缺点：IO扩展性和效率存在瓶颈

NIO（Java4）

NonBlock-IO：构建多路复用的、同步非阻塞的IO操作，提供了更接近操作系统底层的高性能数据操作方式

特点：程序要不断去询问内核是否准备好

NIO核心

• Channels
• Buffers
• Selectors

AIO

Asynchronous IO:基于事件和回调机制

AIO如何进一步加工处理结果

• 基于回调：实现CompletionHandler接口，调用时触发回调函数
• 返回Future：通过isDone()查看是否准备好，通过get()等待返回数据

区别

AIO连server都免了，所以是0：N

BIO适用于连接数少且固定的架构，这种方式对服务器的资源要求较高，1.4之前的唯一选择

NIO适用于连接数多且短的架构，比如聊天服务器，编程复制

AIO适用于连接数多且长的架构，比如相册服务器，可以充分调用OS来参与并发操作，编程复制，1.7才出现的