Java常用类库与技巧

2021-04-17

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才出现的